C# Online Compiler | .NET Fiddle

<no name> by Anonymous

Communication/Ethernet.cs
/* 
 * Copyright (C) Samsung Electronics Co., Ltd., Inc - All Rights Reserved
 * Unauthorized copying of this file, via any medium is strictly prohibited
 * Proprietary and confidential
 * 
 * Written by Donghyun Ko <dh79.ko@samsung.com>, June 2022
 * Written by Sanghyeon Lee <sirano06.lee@samsung.com>, June 2022
 * 
 */
using System;
using System.Collections.Generic;
using System.IO.Ports;
using System.Linq;
using System.Net;
using System.Net.NetworkInformation;
using System.Net.Sockets;
using System.Text;
using Auto_Insert_Sim_Tray.UI;
using Auto_Insert_Sim_Tray.Utils;
using Auto_Insert_Sim_Tray.Configs.Model;
using static Auto_Insert_Sim_Tray.Define.LogDefine;

namespace Auto_Insert_Sim_Tray.Communication
{
    /**
     * @brief Ethernet 모드
     */
    public enum EthernetMode
    {
        eNone,
        eServerMode,
        eClientMode
    };

    /**
     * @brief Ethernet 결과
     */
    public enum EthernetResult
    {
        SUCCESS,
        SERVER_ACCEPT_ERROR,
        CLIENT_CONNECT_ERROR,
        SEND_DATA_ERROR,
        SEND_DATA_CONNECT_CLOSE_ERROR,
    };

    /**
     * @brief 비동기 통신 상태 정보 클래스
     */
    public class ConnectedSocketStateObject
    {
        // Client  socket.  
        private Socket workSocket = null;
        // Size of receive buffer.  
        private const int bufferSize = 1024;
        // Receive buffer.  
        private byte[] receiveBuffer = new byte[bufferSize];
        // Receive buffer.  
        private int receiveDataSize;
        // Received data string.  
        private StringBuilder receiveDataStringBuilder = new StringBuilder();

        public Socket WorkSocket
        {
            get { return workSocket; }
            set { workSocket = value; }
        }
        public int BufferSize
        {
            get { return bufferSize; }
        }
        public byte[] ReceiveBuffer
        {
            get { return receiveBuffer; }
            set { receiveBuffer = value; }
        }
        public int ReceiveDataSize
        {
            get { return receiveDataSize; }
            set { receiveDataSize = value; }
        }
        public StringBuilder ReceiveDataStringBuilder
        {
            get { return receiveDataStringBuilder; }
            set { receiveDataStringBuilder = value; }
        }

        public void ClearBuffer()
        {
            Array.Clear(receiveBuffer, 0, BufferSize); // Xóa và đặt các phần tử của mảng về giá trị mặc định là 0
        }
    }

    /**
     * @brief Ethernet 통신 클래스
     */
    public class Ethernet
    {
        private static string CLASS_NAME = "Ethernet";

        private const int MinimumPortNum = 0;
        private const int InvalidPortNum = -1;

        private EthernetMode mode;
        private IPAddress ipAddress;
        private int portNum;
        private Socket mainSocket;
        private IPEndPoint endPoint;
        public List<ConnectedSocketStateObject> connectedSocketList;

        public delegate void ConnectCallbackEvent(EthernetResult result, string remoteEndPoint);
        public event ConnectCallbackEvent ConnectCallbackEventHandler;
        public delegate void SendDataCallbackEvent(EthernetResult result, string remoteEndPoint, string sendData = null);
        public event SendDataCallbackEvent SendDataCallbackEventHandler;
        public delegate void ReceiveDataCallbackEvent(string readData, string remoteEndPoint);
        public event ReceiveDataCallbackEvent ReceiveDataCallbackEventHandler;
        public delegate void DisconnectedCallbackEvent(string remoteEndPoint);
        public event DisconnectedCallbackEvent DisconnectedCallbackEventHandler;

        

        /**
         * @brief Ethernet 클래스 생성자
         * @param[in] mode EthernetMode 타입의 모드
         * @param[in] ipAddress Target IP address (string)
         * @param[in] portNum Target port number
         */
        public Ethernet(EthernetMode mode = EthernetMode.eNone, string ipAddress = null, int portNum = InvalidPortNum)
        {
            this.mode = mode;
            this.ipAddress = IPAddress.Parse(ipAddress);
            this.portNum = portNum;

            mainSocket = null;
            endPoint = null;
        }
        /**
         * @brief Ethernet 클래스 생성자
         * @param[in] mode EthernetMode 타입의 모드
         * @param[in] ipAddress Target IP address (IPAddress)
         * @param[in] portNum Target port number
         */
        public Ethernet(EthernetMode mode = EthernetMode.eNone, IPAddress ipAddress = null, int portNum = InvalidPortNum)
        {
            this.mode = mode;
            this.ipAddress = ipAddress;
            this.portNum = portNum;

            mainSocket = null;
            endPoint = null;
        }

        /**
         * @brief Ethernet 연결 함수
         * @details 생성자로 전달 된 EthernetMode에 맞는 연결 요청
         */
        public void Connect()
        {
            LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, "Connect", CONTENT_TYPE.INFO);
            if (!IsOpen)
            {
                try
                {
                    switch (mode)
                    {
                        case EthernetMode.eServerMode:
                            startServer();
                            break;

                        case EthernetMode.eClientMode:
                            startClient();
                            break;

                        default:
                            LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, "Wrong mode", CONTENT_TYPE.DEBUG);
                            break;
                    }
                }
                catch (Exception ex)
                {
                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"{ex}", CONTENT_TYPE.EXCEPTION);
                    throw ex;
                }
            }
        }

        /**
         * @brief Ethernet 연결 종료 함수
         * @details 생성자로 전달 된 EthernetMode에 맞는 연결 종료 처리
         */
        public void DisConnect()
        {
            LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, "Disconnect", CONTENT_TYPE.INFO);
            try
            {
                switch (mode)
                {
                    case EthernetMode.eServerMode:
                        CloseAllSocket();
                        break;
                    case EthernetMode.eClientMode:
                        CloseAllSocket();
                        break;
                }
            }
            catch (Exception ex)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"{ex}", CONTENT_TYPE.EXCEPTION);
                throw ex;
            }

        }

        /**
         * @brief 서버 시작 함수
         * @details EthernetMode 중 server mode 일때 해당
         */
        private void startServer()
        {
            LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, "startServer", CONTENT_TYPE.DEBUG);
            if ((ipAddress == null) || (portNum < MinimumPortNum))
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, "Wrong parameter", CONTENT_TYPE.DEBUG);
                throw new Exception("Wrong parameter");
            }

            endPoint = new IPEndPoint(ipAddress, portNum);
            mainSocket = new Socket(ipAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
            connectedSocketList = new List<ConnectedSocketStateObject>();

            try
            {
                mainSocket.Bind(endPoint);
                mainSocket.Listen(10);
                mainSocket.BeginAccept(new AsyncCallback(AcceptCallback), mainSocket);
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, "Wrong BeginAccept", CONTENT_TYPE.INFO);

            }
            catch (Exception ex)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"{ex}", CONTENT_TYPE.EXCEPTION);
                throw ex;
            }
        }

        /**
         * @brief 연결 허가 callback 함수
         * @param[in] ar IAsyncResult 타입으로 ascync state 등의 정보를 가지고 있는 매개변수
         */
        private void AcceptCallback(IAsyncResult ar)
        {
            LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, "AcceptCallback", CONTENT_TYPE.DEBUG);
            Socket client = null;
            try
            {
                // Get the socket that handles the client request.
                client = ((Socket)ar.AsyncState).EndAccept(ar);
                mainSocket.BeginAccept(AcceptCallback, mainSocket);

                // Create the state object.
                ConnectedSocketStateObject connSocketState = new ConnectedSocketStateObject();
                connSocketState.WorkSocket = client;
                connectedSocketList.Add(connSocketState);

                ConnectCallbackEventHandler?.Invoke(EthernetResult.SUCCESS, client.RemoteEndPoint.ToString());

                client.BeginReceive(connSocketState.ReceiveBuffer, 0, connSocketState.BufferSize, 0, new AsyncCallback(ReceiveDataCallback), connSocketState);
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, "Accept success", CONTENT_TYPE.INFO);

            }
            catch (Exception ex)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"{ex}", CONTENT_TYPE.EXCEPTION);
                string endPoint = null;

                if ((client != null) && (client.RemoteEndPoint != null))
                {
                    endPoint = client.RemoteEndPoint.ToString();
                }
                ConnectCallbackEventHandler?.Invoke(EthernetResult.SERVER_ACCEPT_ERROR, endPoint);
            }
        }

        /**
         * @brief Client 시작 함수
         * @details EthernetMode 중 client mode 일때 해당
         */
        public void startClient()
        {
            LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, "startClient", CONTENT_TYPE.DEBUG);
            if ((ipAddress == null) || (portNum < MinimumPortNum))
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, "Wrong parameter", CONTENT_TYPE.DEBUG);
                throw new Exception("Wrong parameter");
            }

            endPoint = new IPEndPoint(ipAddress, portNum);
            mainSocket = new Socket(ipAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp);

            if (!mainSocket.Connected)
            {
                try
                {
                    mainSocket.BeginConnect(endPoint, new AsyncCallback(ConnectCallback), mainSocket);
                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, "BeginConnect", CONTENT_TYPE.INFO);
                }
                catch (Exception ex)
                {
                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"{ex}", CONTENT_TYPE.EXCEPTION);
                    throw new Exception("Start client error!");
                }
            }
        }

        /**
         * @brief Connection에 대한 응답이 이루어지는 함수
         * @param[in] ar IAsyncResult 타입으로 ascync state 등의 정보를 가지고 있는 매개변수
         */
        private void ConnectCallback(IAsyncResult ar)
        {
            LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, "ConnectCallback", CONTENT_TYPE.DEBUG);
            Socket client = null;
            try
            {
                // Retrieve the socket from the state object.  
                client = (Socket)ar.AsyncState;

                // Complete the connection.  
                client.EndConnect(ar);

                ConnectedSocketStateObject connSocketState = new ConnectedSocketStateObject();
                connSocketState.WorkSocket = mainSocket;

                ConnectCallbackEventHandler?.Invoke(EthernetResult.SUCCESS, ipAddress.ToString());

                client.BeginReceive(connSocketState.ReceiveBuffer, 0, connSocketState.BufferSize, 0, new AsyncCallback(ReceiveDataCallback), connSocketState);
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, "BeginReceive", CONTENT_TYPE.INFO);


            }
            catch (Exception ex)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"{ex}", CONTENT_TYPE.EXCEPTION);
                ConnectCallbackEventHandler?.Invoke(EthernetResult.CLIENT_CONNECT_ERROR, ipAddress.ToString());
                CloseAllSocket();
            }
        }

        /**
         * @brief Target으로 부터 receive 받게 되면 불리는 함수
         * @param[in] ar IAsyncResult 타입으로 ascync state 등의 정보를 가지고 있는 매개변수
         */
        private void ReceiveDataCallback(IAsyncResult ar)
        {
            LogUtil.Instance.Log(LOG_TYPE.TCP_LOG, $"[{mode}][Port {portNum}] ReceiveData:", CONTENT_TYPE.LOG);
            string content = String.Empty;

            // Retrieve the state object and the handler socket  
            // from the asynchronous state object.  
            ConnectedSocketStateObject connSocketState = (ar.AsyncState) as ConnectedSocketStateObject;

            try
            {
                // Read data from the remote socket.
                connSocketState.ReceiveDataSize = connSocketState.WorkSocket.EndReceive(ar);

                if (connSocketState.ReceiveDataSize > 0)
                {
                    // There  might be more data, so store the data received so far.  
                    connSocketState.ReceiveDataStringBuilder.Append(Encoding.UTF8.GetString(connSocketState.ReceiveBuffer, 0, connSocketState.ReceiveDataSize));
                    content = connSocketState.ReceiveDataStringBuilder.ToString();
                    connSocketState.ClearBuffer();
                    connSocketState.ReceiveDataStringBuilder.Clear();
                    connSocketState.ReceiveDataSize = 0;
                    ReceiveDataCallbackEventHandler?.Invoke(content, connSocketState.WorkSocket.RemoteEndPoint.ToString());

                    connSocketState.WorkSocket.BeginReceive(connSocketState.ReceiveBuffer, 0, connSocketState.BufferSize, 0, new AsyncCallback(ReceiveDataCallback), connSocketState);            
                    LogUtil.Instance.Log(LOG_TYPE.TCP_LOG, $"[{connSocketState.WorkSocket.RemoteEndPoint}]{content}", CONTENT_TYPE.LOG);
                }
                else
                {
                    throw new Exception("ReceivedDataSize Error!");
                }
            }
            catch (ObjectDisposedException objectDisposedException)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"{objectDisposedException}", CONTENT_TYPE.EXCEPTION);
            }
            catch (Exception ex)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"{ex}", CONTENT_TYPE.EXCEPTION);

                string endPoint = null;

                if (mode == EthernetMode.eServerMode)
                {
                    if ((connSocketState != null) && (connSocketState.WorkSocket != null))
                    {
                        if (connSocketState.WorkSocket.RemoteEndPoint != null)
                        {
                            endPoint = connSocketState.WorkSocket.RemoteEndPoint.ToString();
                        }
                        removeDisconnectedSocket(connSocketState.WorkSocket);
                    }
                }
                else
                {
                    endPoint = ipAddress.ToString();
                }

                DisconnectedCallbackEventHandler?.Invoke(endPoint);
            }
        }

        /**
         * @brief 연결이 끊긴 socket을 메모리에서 제거하는 함수
         * @param[in] socket 연결 끊긴 socket
         */
        private void removeDisconnectedSocket(Socket socket)
        {
            if (connectedSocketList != null)
            {
                for (int connectedClientsCount = connectedSocketList.Count - 1; connectedClientsCount >= 0; connectedClientsCount--)
                {
                    ConnectedSocketStateObject connSocketState = connectedSocketList[connectedClientsCount];
                    if (socket.RemoteEndPoint.Equals(connSocketState.WorkSocket.RemoteEndPoint) &&
                        socket.LocalEndPoint.Equals(connSocketState.WorkSocket.LocalEndPoint))
                    {
                        connSocketState.WorkSocket.Close();
                        connectedSocketList.RemoveAt(connectedClientsCount);
                        break;
                    }
                }
            }
        }

        /**
         * @brief 데이터 전송 함수
         * @param[in] data 전송할 데이터
         * @param[in] remoteIpAddress Target의 IP address (string)
         * @param[in] remotePortNum Target의 Port number
         */
        public void SendData(string data, string remoteIpAddress = null, int remotePortNum = InvalidPortNum)
        {

            LogUtil.Instance.Log(LOG_TYPE.TCP_LOG, $"[{mode}][Port {portNum}] SendData: {data}", CONTENT_TYPE.LOG);
            if (mode == EthernetMode.eClientMode)
            {
                if (isSocketConnected(mainSocket))
                {
                    LogUtil.Instance.Log(LOG_TYPE.TCP_LOG, $"[{mainSocket.RemoteEndPoint}]{data}", CONTENT_TYPE.LOG);
                    SendData(mainSocket, data);
                }
                else
                {
                    if (mainSocket != null)
                    {
                        SendDataCallbackEventHandler?.Invoke(EthernetResult.SEND_DATA_CONNECT_CLOSE_ERROR, mainSocket.RemoteEndPoint.ToString());
                    }
                    CloseAllSocket();
                }
            }
            else
            {
                Socket client = null;
                for (int connectedClientsCount = connectedSocketList.Count - 1; connectedClientsCount >= 0; connectedClientsCount--)
                {
                    ConnectedSocketStateObject connSocketState = connectedSocketList[connectedClientsCount];
                    if ((remoteIpAddress == null)
                        || ((remoteIpAddress != null) && IsSameDestination(remoteIpAddress, remotePortNum, connSocketState.WorkSocket)))
                    {
                        client = connSocketState.WorkSocket;
                        if (isSocketConnected(client))
                        {
                            LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"[{client.RemoteEndPoint}]{data}", CONTENT_TYPE.DEBUG);
                            SendData(client, data);
                        }
                        else
                        {
                            string endPoint = null;

                            if (client != null && client.RemoteEndPoint != null)
                            {
                                endPoint = client.RemoteEndPoint.ToString();
                            }
                            SendDataCallbackEventHandler?.Invoke(EthernetResult.SEND_DATA_CONNECT_CLOSE_ERROR, endPoint);
                            DisconnectedCallbackEventHandler?.Invoke(endPoint);

                            client.Close();
                            connectedSocketList.RemoveAt(connectedClientsCount);
                        }
                    }
                }
            }
        }

        /**
         * @brief 데이터 전송 함수
         * @param[in] handler 전송할 Target의 socket
         * @param[in] data 전송할 데이터
         */

        private void SendData(Socket handler, string data)
        {
            // Convert the string data to byte data using ASCII encoding.  
            byte[] byteData = Encoding.UTF8.GetBytes(data);
            //byte[] byteData = Encoding.ASCII.GetBytes(data);

            string endPoint = null;

            if (handler != null && handler.RemoteEndPoint != null)
            {
                endPoint = handler.RemoteEndPoint.ToString();
            }

            try
            {
                if (handler != null)
                {
                    // Begin sending the data to the remote device.  
                    handler.BeginSend(byteData, 0, byteData.Length, 0, new AsyncCallback(SendDataCallback), handler);
                    SendDataCallbackEventHandler?.Invoke(EthernetResult.SUCCESS, endPoint, data);
                }
            }
            catch (Exception ex)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"{ex}", CONTENT_TYPE.EXCEPTION);
                SendDataCallbackEventHandler?.Invoke(EthernetResult.SEND_DATA_ERROR, endPoint);

            }
        }

        /**
         * @brief 데이터 전송 후 불리는 callback 함수
         * @param[in] ar IAsyncResult 타입으로 ascync state 등의 정보를 가지고 있는 매개변수
         */
        private void SendDataCallback(IAsyncResult ar)
        {
            Socket handler = null;

            try
            {
                // Retrieve the socket from the state object.  
                handler = (Socket)ar.AsyncState;

                // Complete sending the data to the remote device.  
                int bytesSent = handler.EndSend(ar);

                if (handler != null)
                {
                    SendDataCallbackEventHandler?.Invoke(EthernetResult.SUCCESS, handler.RemoteEndPoint.ToString());
                }
            }
            catch (Exception ex)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"{ex}", CONTENT_TYPE.EXCEPTION);

                string endPoint = null;

                if (handler != null && handler.RemoteEndPoint != null)
                {
                    endPoint = handler.RemoteEndPoint.ToString();
                }
                SendDataCallbackEventHandler?.Invoke(EthernetResult.SEND_DATA_ERROR, endPoint);
            }
        }

        /**
         * @brief 연결 된 모든 socket 연결 종료 함수
         * @details ServerMode 일 경우에만 사용 
         */
        private void CloseAllSocket()
        {
            try
            {
                if (mainSocket != null)
                {
                    mainSocket.Close();
                }

                if ((mode == EthernetMode.eServerMode) && (connectedSocketList != null))
                {
                    for (int connectedClientsCount = connectedSocketList.Count - 1; connectedClientsCount >= 0; connectedClientsCount--)
                    {
                        ConnectedSocketStateObject connSocketState = connectedSocketList[connectedClientsCount];
                        if ((connSocketState != null) && (connSocketState.WorkSocket != null))
                        {
                            connSocketState.WorkSocket.Close();
                        }
                        connectedSocketList.RemoveAt(connectedClientsCount);
                    }
                }

                mainSocket = null;
                connectedSocketList = null;
            }
            catch (Exception ex)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"{ex}", CONTENT_TYPE.EXCEPTION);
                throw ex;
            }
        }

        /**
         * @brief 소켓이 연결 되어있는지 확인하는 함수
         * @param[in] socket Target socket
         */
        private bool isSocketConnected(Socket socket)
        {
            bool result = false;
            IPGlobalProperties ipProperties = IPGlobalProperties.GetIPGlobalProperties();

            TcpConnectionInformation[] tcpConnections;

            try
            {
                if (socket == null)
                {
                    throw new Exception("Socket is null");
                }
                else
                {
                    tcpConnections = ipProperties.GetActiveTcpConnections().Where(
                        x => x.LocalEndPoint.Equals(socket.LocalEndPoint) && x.RemoteEndPoint.Equals(socket.RemoteEndPoint)).ToArray();
                }
            }
            catch (Exception ex)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"{ex}", CONTENT_TYPE.EXCEPTION);
                return false;
            }

            if ((tcpConnections != null) && (tcpConnections.Length > 0))
            {
                TcpState stateOfConnection = tcpConnections.First().State;

                if (stateOfConnection == TcpState.Established)
                {
                    result = true; ;
                }
            }

            return result;
        }

        /**
         * @brief End point가 동일한 목적지인지 확인하는 함수 (동일 Target인지)
         * @param[in] remoteIpAddress Target IP address (string)
         * @param[in] remotePortNum Target port number
         * @param[in] socket Target socket
         * @return 동일한지 여부
         */
        private bool IsSameDestination(string remoteIpAddress, int remotePortNum, Socket socket)
        {
            bool result = false;

            try
            {
                IPEndPoint endPoint = (IPEndPoint)socket.RemoteEndPoint;
                string socketIpAddress = endPoint.Address.ToString();
                if (remoteIpAddress.Equals(socketIpAddress))
                {
                    if (remotePortNum != InvalidPortNum)
                    {
                        if (remotePortNum == endPoint.Port)
                        {
                            result = true;
                        }
                    }
                    else
                    {
                        result = true;
                    }
                }
            }
            catch (Exception ex)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"{ex}", CONTENT_TYPE.EXCEPTION);
                throw ex;
            }

            return result;
        }

        /**
         * @brief 현재 나의 IPAdress 얻는 클래스
         * @return IPAddress의 루프백
         */
        private IPAddress GetDefaultIpAddress()
        {
            IPHostEntry hostEntry = Dns.GetHostEntry(Dns.GetHostName());
            foreach (IPAddress address in hostEntry.AddressList)
            {
                if (address.AddressFamily == AddressFamily.InterNetwork)
                {
                    return address;
                }
            }

            return IPAddress.Loopback;
        }
        public bool IsOpen
        {
            get
            {
                if (connectedSocketList is null)
                {
                    return false;
                }
                return true;
            }
        }
        //private void LogDataSent(string msg)
        //{

        //    LogUtil.Instance.Log(LOG_TYPE.TCP_LOG, $"{mSerialPort.PortName} => {msg}", CONTENT_TYPE.LOG);
        //}
        //private void LogDataRecv(string msg)
        //{
        //    LogUtil.Instance.Log(LOG_TYPE.TCP_LOG, $"{mSerialPort.PortName} <= {msg}", CONTENT_TYPE.LOG);
        //}
    }
}

Configs/Model/AxisParamData.Cs
/* 
 * Copyright (C) Samsung Electronics Co., Ltd., Inc - All Rights Reserved
 * Unauthorized copying of this file, via any medium is strictly prohibited
 * Proprietary and confidential
 * 
 * Written by Donghyun Ko <dh79.ko@samsung.com>, June 2022
 * Written by Sanghyeon Lee <sirano06.lee@samsung.com>, June 2022
 * 
 */
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace Auto_Insert_Sim_Tray.Configs.Model
{
    /**
     * @brief Axis 동작시키기위한 Data 클래스
     * @details scale, 평상시/Jog이동시/Origin시의 속도, 가감속을 입력받아야 한다
     */
    public class AxisParamData
    {
        // distance = pitch * 톱니바퀴 갯수
        // scale = resolution / distance

        //public object resolution; //pulse;
        //public object distance; //mm
        //public object vel; // (mm/s)
        //public object acc; // (ms)
        //public object dec; // (ms)
        //public object jogVel; // (mm/s)
        //public object jogAcc; // (ms)
        //public object jogDec; // (ms)
        //public object oriVel; // (mm/s)
        //public object oriAcc; // (ms)
        //public object oriDec; // (ms)
        //public object oriReturn; // (pulse)

        /*
         * Fix by hung96.tran
         */
        [DisplayName("[Axis Parameter] Resolution")]
        [Description("Resolution for motor (pulse)")]
        [JsonProperty]
        [TypeConverter(typeof(AxisParamExpandableObjectConverter))]
        public object resolution { get; set; } //pulse;

        [DisplayName("[Axis Parameter] Distance")]
        [Description("Distance of motor's pulley (cm)")]
        [JsonProperty]
        [TypeConverter(typeof(AxisParamExpandableObjectConverter))]
        public object distance { get; set; } //cm

        [DisplayName("[Axis Parameter] Velocity high")]
        [Description("Default motor velocity high (mm/s)")]
        [JsonProperty]
        [TypeConverter(typeof(AxisParamExpandableObjectConverter))]
        public object vel_high { get; set; } = 0;// (cm/s)

        [DisplayName("[Axis Parameter] Velocity medium")]
        [Description("Default motor velocity medium (mm/s)")]
        [JsonProperty]
        [TypeConverter(typeof(AxisParamExpandableObjectConverter))]
        public object vel_medium { get; set; } = 0;// (cm/s)

        [DisplayName("[Axis Parameter] Velocity low")]
        [Description("Default motor velocity low (mm/s)")]
        [JsonProperty]
        [TypeConverter(typeof(AxisParamExpandableObjectConverter))]
        public object vel_low { get; set; } = 0; // (cm/s)

        [DisplayName("[Axis Parameter] Velocity value maximum")]
        [Description("Default motor velocity value maximum (mm/s)")]
        [JsonProperty]
        [TypeConverter(typeof(AxisParamExpandableObjectConverter))]
        public object vel_value_max { get; set; } = 0; // (cm/s)

        [DisplayName("[Axis Parameter] Velocity value minimum")]
        [Description("Default motor velocity value minimum (mm/s)")]
        [JsonProperty]
        [TypeConverter(typeof(AxisParamExpandableObjectConverter))]
        public object vel_value_min { get; set; } = 0; // (cm/s)

        [DisplayName("[Axis Parameter] Acceleration")]
        [Description("Default motor acceleration (ms)")]
        [JsonProperty]
        [TypeConverter(typeof(AxisParamExpandableObjectConverter))]
        public object acc { get; set; } // (ms)

        [DisplayName("[Axis Parameter] Deceleration")]
        [Description("Default motor dcceleration (ms)")]
        [JsonProperty]
        [TypeConverter(typeof(AxisParamExpandableObjectConverter))]
        public object dec { get; set; } // (ms)

        [DisplayName("[Axis Parameter] Jog velocity")]
        [Description("Jog motor velocity (mm/s)")]
        [JsonProperty]
        [TypeConverter(typeof(AxisParamExpandableObjectConverter))]
        public object jogVel { get; set; } = 0; // (mm/s)

        [DisplayName("[Axis Parameter] Jog acceleration")]
        [Description("Jog motor acceleration (ms)")]
        [JsonProperty]
        [TypeConverter(typeof(AxisParamExpandableObjectConverter))]
        public object jogAcc { get; set; } // (ms)

        [DisplayName("[Axis Parameter] Jog dcceleration")]
        [Description("Jog motor dcceleration (ms)")]
        [JsonProperty]
        [TypeConverter(typeof(AxisParamExpandableObjectConverter))]
        public object jogDec { get; set; } // (ms)

        [DisplayName("[Axis Parameter] Origin velocity")]
        [Description("Origin motor velocity (mm/s)")]
        [JsonProperty]
        [TypeConverter(typeof(AxisParamExpandableObjectConverter))]
        public object oriVel { get; set; }// (mm/s)

        [DisplayName("[Axis Parameter] Origin acceleration")]
        [Description("Origin motor acceleration (ms)")]
        [JsonProperty]
        [TypeConverter(typeof(AxisParamExpandableObjectConverter))]
        public object oriAcc { get; set; } // (ms)

        [DisplayName("[Axis Parameter] Origin dcceleration")]
        [Description("Origin motor dcceleration (ms)")]
        [JsonProperty]
        [TypeConverter(typeof(AxisParamExpandableObjectConverter))]
        public object oriDec { get; set; } // (ms)

        [DisplayName("[Axis Parameter] Origin return value")]
        [Description("If you don't use origin origin and limit +, - sensors, you can insert null (pulse)")]
        [JsonProperty]
        [TypeConverter(typeof(AxisParamExpandableObjectConverter))]
        public object oriReturn { get; set; } // (pulse)

        [DisplayName("[Axis Parameter] Inposition flag")]
        [Description("(Only Fastech) When motor be stopped, you can reference inposition flag or not (bool)")]
        [JsonProperty]
        //[TypeConverter(typeof(AxisParamExpandableObjectConverter))]
        public bool inpositionFlag { get; set; } // Motor Stop시 Inposition flag 확인 여부 설정(Only for Fastech)

        public AxisParamData(object resolution, object distance, object vel, object vel_low, object acc, object dec,
                           object jogVel, object jogAcc, object jogDec,
                           object oriVel, object oriAcc, object oriDec, object oriReturn = null, bool inpositionFlag = false)
        {
            this.resolution = resolution;
            this.distance = distance;
            this.vel_high = vel;
            this.vel_low = vel_low;
            this.acc = acc;
            this.dec = dec;
            this.jogVel = jogVel;
            this.jogAcc = jogAcc;
            this.jogDec = jogDec;
            this.oriVel = oriVel;
            this.oriAcc = oriAcc;
            this.oriDec = oriDec;
            this.oriReturn = oriReturn;
            this.inpositionFlag = inpositionFlag;
        }

        public AxisParamData() { }
    }
    public class AxisParamExpandableObjectConverter : ExpandableObjectConverter
    {
        double tempData = 0;
        public override bool CanConvertTo(ITypeDescriptorContext context, System.Type destinationType)
        {
            return true;
        }

        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, System.Type destinationType)
        {
            tempData = Convert.ToDouble(value);
            return Convert.ToString(value);
        }

        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
        {
            return true;
        }

        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
        {
            try
            {
                return Convert.ToDouble(value);
            }
            catch (Exception e)
            {
                MessageBox.Show(e.Message.ToString());
                return tempData;
            }
        }
    }
}
Configs/Model/ConfigMC.cs
using Microsoft.Office.Interop.Excel;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Auto_Insert_Sim_Tray.Configs.Model
{
    public class ConfigMC
    {
        //[Category("Out Tray")]
        //[Description("Number of tray")]

        [Category("Out Tray")]
        [DisplayName("Number of tray")]
        [Description("Number of tray")]
        [JsonProperty]
        public int Number_Of_Tray_Max { get; set; } = 0;

        [Browsable(false)]
        [Category("Out Tray")]
        [DisplayName("Current tray")]
        [Description("Current tray on out tray")]
        [JsonProperty]
        public int Count_Tray_OutTray { get; set; } = 0;

        [Category("Out Tray")]
        [DisplayName("Offset Tray")]
        [Description("Define Offset value (cm)")]
        [JsonProperty]
        public decimal Offset_OutTray { get; set; } = 0; //cm

        [Category("Cylinder Rotate")]
        [DisplayName("Cyliner Rotate LD SET Front")]
        [Description("Select true: Rotate Front/ false:  Rotate Rear")]
        [JsonProperty]
        public bool Rotate_LD_SET { get; set; } = true;

        [Category("Cylinder Rotate")]
        [DisplayName("Cyliner Rotate ULD SET Rear")]
        [Description("Select true: Rotate Front/ false:  Rotate Rear")]
        [JsonProperty]
        public bool Rotate_ULD_SET { get; set; } = true;

        [Category("By Pass Mode")]
        [DisplayName("Select where to place set")]
        [Description("Select true: Set OK/ false:  SET NG")]
        [JsonProperty]
        public bool ByPassSetOK { get; set; } = true;

        [Category("Jig Left")]
        [DisplayName("Number of insert Tray Sim Fail")]
        [Description("Number of insert Tray Sim Fail")]
        [JsonProperty]
        public int Number_Of_NG_Jig_Left { get; set; } = 0;

        [Category("Jig Right")]
        [DisplayName("Number of insert Tray Sim Fail")]
        [Description("Number of insert Tray Sim Fail")]
        [JsonProperty]
        public int Number_Of_NG_Jig_Right { get; set; } = 0;

        [Category("Robot XYZ")]
        [DisplayName("Number of Grip Tray Sim fail")]
        [Description("Number of Grip Tray Sim fail")]
        [JsonProperty]
        public int Number_Of_Grip_Tray_Sim_Fail { get; set; } = 0;

        //[Browsable(false)]
        [Category("Robot XYZ")]
        [DisplayName("Use Run Servo ABSLiner")]
        [Description("Cài đặt True sẽ chạy ABSLiner từ điểm Wait đi gắp Tray Sim, False sẽ chạy đơn từng trục từ điểm Wait đi gắp Tray Sim")] //Dùng cho trường hợp chạy ABSLiner bị giật trục ở vài điểm cố định
        [JsonProperty]
        public bool Use_Run_Servo_ABSLiner { get; set; } = true;

    }
}

Configs/Model/DelayTimeModel.cs
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Auto_Insert_Sim_Tray.Configs.Model
{
    public class DelayTimeModel
    {
        [Category("Cylinder of Jig")]
        [DisplayName("1. Cylinder Align Hor")]
        [Description("Define Align Hor Sol delay (s)")]
        [JsonProperty]
        public double Jig_Align_Hor_Delay { get; set; } = 0.1f; //s
        [Category("Cylinder of Jig")]
        [DisplayName("2. Cylinder Align Ver")]
        [Description("Define Align Hor Sol delay (s)")]
        [JsonProperty]
        public double Jig_Align_Ver_Delay { get; set; } = 0.1f; //s

        [Category("Cylinder of Shutter NG")]
        [DisplayName("1. NG Cylinder Up/Down")]
        [Description("Define Up/Down Sol delay (s)")]
        [JsonProperty]
        public double NG_UpDownSolDelay { get; set; } = 0.1f; //s

        [Category("Cylinder of Shutter NG")]
        [DisplayName("2. NG FW")]
        [Description("Define FW Sol delay (s)")]
        [JsonProperty]
        public double NG_FWSolDelay { get; set; } = 0.1f; //s

        [Category("Cylinder of Shutter NG")]
        [DisplayName("3. NG BW")]
        [Description("Define BW Sol delay (s)")]
        [JsonProperty]
        public double NG_BWSolDelay { get; set; } = 0.1f; //s

        [Category("Intray")]
        [DisplayName("1. Check Khay Tray Sim")]
        [Description("Define Check Tray Sim delay to Align  (s)")]
        [JsonProperty]
        public double Intray_Check_Tray_Sim_Delay { get; set; } = 0.1f; //s

        [Category("Intray")]
        [DisplayName("2. Cycliner Align Tray")]
        [Description("Define Cylinder Align delay (s)")]
        [JsonProperty]
        public double Intray_Align_Delay { get; set; } = 0.1f; //s

        [Category("Intray")]
        [DisplayName("3. Cycliner Unalign Tray")]
        [Description("Define Cylinder Align delay (s)")]
        [JsonProperty]
        public double Intray_Unalign_Delay { get; set; } = 0.1f; //s

        [Category("Intray")]
        [DisplayName("4. Separate Tray Sim")]
        [Description("Define Cylinder Cylinder of Intray delay (s)")]
        [JsonProperty]

        public double Step_Separate_Delay { get; set; } = 0.1f; //s

        [Category("Robot XYZ")]
        [DisplayName("1. Time check NG")]
        [Description("Define time check NG when insert sim tray (s)")]
        [JsonProperty]
        public double Insert_Sim_Tray_Check_NG { get; set; } = 0.1f; //s

        [Category("Robot XYZ")]
        [DisplayName("2. Grip Sim Tray ")]
        [Description("Define time Grip Sim Tray delay (s)")]
        [JsonProperty]
        public double RobotXYZ_Grip_Delay { get; set; } = 0.1f; //s

        [Category("Robot XYZ")]
        [DisplayName("3. Down Cylinder Rear ")]
        [Description("Define time Down Cylinder Rear delay (s)")]
        [JsonProperty]
        public double RobotXYZ_Down_Rear_Delay { get; set; } = 0.1f; //s

        [Category("Robot XYZ")]
        [DisplayName("4. Down Cylinder Front ")]
        [Description("Define time Down Cylinder Front delay (s)")]
        [JsonProperty]
        public double RobotXYZ_Down_Front_Delay { get; set; } = 0.1f; //s

        [Category("Robot XYZ")]
        [DisplayName("5. Check Tray Sim ")]
        [Description("Define time to check Grip Tray Sim Ok or NG (s)")]
        [JsonProperty]
        public double RobotXYZ_Check_Tray_Sim { get; set; } = 0.1f; //s





        [Category("Conveyor")]
        [DisplayName("Load CV delay")]
        [Description("Define CV run after detecting sensor out On <-> Off (s)")]
        [JsonProperty]
        public double LoadCVDelay { get; set; } = 0.1f; //s

        [Category("Conveyor")]
        [DisplayName("Unload CV delay")]
        [Description("Define CV run after detecting sensor out On <-> Off (s)")]
        [JsonProperty]
        public double UnloadCVDelay { get; set; } = 0.1f; //s

        [Category("Conveyor")]
        [DisplayName("CV Input Tray Sim")]
        [Description("Define CV Input Tray Sim run after detecting sensor out On <-> Off (s)")]
        [JsonProperty]
        public double CVInputDelay { get; set; } = 0.1f; //s

        [Category("Conveyor")]
        [DisplayName("CV Outtray Tray Sim")]
        [Description("Define CV Input Tray Sim run after detecting sensor out On <-> Off (s)")]
        [JsonProperty]
        public double CVOuttrayDelay { get; set; } = 0.1f; //s


        [Category("Testing")]
        [DisplayName("Dry Run Testing time")]
        [Description("Define Dry Run Testing Time (s)")]
        [JsonProperty]
        public double TestDryrunTime { get; set; } = 10.0f; //s  

        [Category("Testing")]
        [DisplayName("Dry Run Down RF Cable time")]
        [Description("Define Dry Run Down RF Cable time (s)")]
        [JsonProperty]
        public double TestRFDownTime { get; set; } = 5.0f; //s  

        [Category("Buzzer")]
        [DisplayName("On buzzer time")]
        [Description("Define buzzer time (s)")]
        [JsonProperty]
        public double OnBuzzerTime { get; set; } = 5.0f; //s  

        [Category("Common")]
        [DisplayName("Out Set Timer")]
        [Description("Define Out Set Timer (s)")]
        [JsonProperty]
        public double OutSetTime { get; set; } = 5.0f; //s  

        [Category("Load SET")]
        [DisplayName("1. Time check model SET")]
        [Description("Define  Time check model SET vs model Tray Sim delay (s)")]
        [JsonProperty]
        public double Wait_To_LD_Pick_Set { get; set; } = 0.1f; //s

        [Category("Load SET")]
        [DisplayName("2. Clamp On LD")]
        [Description("Define time Clamp On LD delay (s)")]
        [JsonProperty]
        public double Clamp_On_LD_Delay { get; set; } = 0.1f; //s

        [Category("Load SET")]
        [DisplayName("3. Clamp On ULD")]
        [Description("Define time Clamp On ULD delay (s)")]
        [JsonProperty]
        public double Clamp_On_ULD_Delay { get; set; } = 0.1f; //s
    }
}

Configs/Model/LogisticModel.cs
/* 
 * Copyright (C) Samsung Electronics Co., Ltd., Inc - All Rights Reserved
 * Unauthorized copying of this file, via any medium is strictly prohibited
 * Proprietary and confidential
 * 
 * Written by Donghyun Ko <dh79.ko@samsung.com>, June 2022
 * Written by Sanghyeon Lee <sirano06.lee@samsung.com>, June 2022
 * 
 */
using Auto_Insert_Sim_Tray.Utils;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static Auto_Insert_Sim_Tray.Define.SystemDefine;

namespace Auto_Insert_Sim_Tray.Configs.Model
{
    /**
     * @brief 물류 프로그램에서 사용할 Config의 데이터 클래스
     * @details Json property 타입의 변수들을 가지는 클래스
     */
    public class LogisticModel
    {
        [Browsable(false)]
        [Category("Logistics")]
        [DisplayName("Make metal duration")]
        [Description("Make metal duration for dry run(ms)")]
        [JsonProperty]
        public int MakeMetalDurationForDryrun { get; set; } = 5000; //ms

        [Browsable(false)]
        [Category("Logistics")]
        [DisplayName("Use door sensor")]
        [Description("Select true/false to use door sensor")]
        [JsonProperty]
        public bool IsUseDoorSensor { get; set; } = true;

        [Browsable(false)]
        [Category("Logistics")]
        [DisplayName("Use area sensor")]
        [Description("Select true/false to use area sensor")]
        [JsonProperty]
        public bool IsUseAreaSensor { get; set; } = true;

        [Category("Logistics")]
        [DisplayName("Use sensor check tray sim")]
        [Description("Select true/false to use area sensor")]
        [JsonProperty]
        public bool IsUseSensorCheckTraySim { get; set; } = true;

        //[Category("Logistics")]
        //[DisplayName("Use printer label")]
        //[Description("Select true/false to use printer label")]
        //[JsonProperty]
        //public bool IsUsePrinter { get; set; } = true;

        [Category("Logistics")]
        [DisplayName("X Ready Signal at CV In")]
        [Description("True: NC Signal || False: NO Signal")]
        [JsonProperty]
        public bool IsIF_XReady_CVIn_NC { get; set; } = true;

        [Category("Logistics")]
        [DisplayName("Y Busy Signal at CV In")]
        [Description("True: NC Signal || False: NO Signal")]
        [JsonProperty]
        public bool IsIF_YBusy_CVIn_NC { get; set; } = true;

        [Category("Logistics")]
        [DisplayName("X Busy Signal at CV Out")]
        [Description("True: NC Signal || False: NO Signal")]
        [JsonProperty]
        public bool IsIF_XBusy_CVOut_NC { get; set; } = true;

        [Category("Logistics")]
        [DisplayName("Y Ready Signal at CV Out")]
        [Description("True: NC Signal || False: NO Signal")]
        [JsonProperty]
        public bool IsIF_YReady_CVOut_NC { get; set; } = true;

        [Category("Logistics")]
        [DisplayName("Last machine")]
        [Description("Select true/false to check last machine for same modules or line")]
        [JsonProperty]
        public bool IsEndMachine { get; set; } = false;

        [Category("Logistics")]
        [DisplayName("Barcode")]
        [Description("Select true/false to use or not use Barcode")]
        [JsonProperty]
        public bool UseBarcode { get; set; } = false;

        [Category("Logistics")]
        [DisplayName("Vision")]
        [Description("Select true/false to use or not use Vision")]
        [JsonProperty]
        public bool UseVision { get; set; } = false;

        [Category("Logistics")]
        [DisplayName("AGV")]
        [Description("Select true/false to use or not use AGV")]
        [JsonProperty]
        public bool UseAGV { get; set; } = false;

        #region Logistics Time
        [Category("Logistics Time")]
        [DisplayName("#1 Shift Start Time")]
        [Description("Time to start #1 shift")]
        [JsonProperty]
        public string lineStartTime1 { get; set; } = "08:00";

        [Category("Logistics Time")]
        [DisplayName("#1 Shift End Time")]
        [Description("Time to end #1 shift")]
        [JsonProperty]
        public string lineEndTime1 { get; set; } = "17:00";

        [Category("Logistics Time")]
        [DisplayName("#2 Shift Start Time")]
        [Description("Time to start #2 shift")]
        [JsonProperty]
        public string lineStartTime2 { get; set; } = "21:30";

        [Category("Logistics Time")]
        [DisplayName("#2 Shift End Time")]
        [Description("Time to end #2 shift")]
        [JsonProperty]
        public string lineEndTime2 { get; set; } = "06:30";

        [Browsable(false)]
        [Category("Logistics Time")]
        [DisplayName("#1 Rest Start Time")]
        [Description("Time to start #1 rest time")]
        [JsonProperty]
        public string lineRestStartTime1 { get; set; } = "10:30";

        [Browsable(false)]
        [Category("Logistics Time")]
        [DisplayName("#1 Rest End Time")]
        [Description("Time to end #1 rest time")]
        [JsonProperty]
        public string lineRestEndTime1 { get; set; } = "10:45";

        [Browsable(false)]
        [Category("Logistics Time")]
        [DisplayName("#2 Rest Start Time")]
        [Description("Time to start #2 rest time")]
        [JsonProperty]
        public string lineRestStartTime2 { get; set; } = "15:00";

        [Browsable(false)]
        [Category("Logistics Time")]
        [DisplayName("#2 Rest End Time")]
        [Description("Time to end #2 rest time")]
        [JsonProperty]
        public string lineRestEndTime2 { get; set; } = "15:15";

        [Browsable(false)]
        [Category("Logistics Time")]
        [DisplayName("#3 Rest Start Time")]
        [Description("Time to start #3 rest time")]
        [JsonProperty]
        public string lineRestStartTime3 { get; set; } = "23:30";

        [Browsable(false)]
        [Category("Logistics Time")]
        [DisplayName("#3 Rest End Time")]
        [Description("Time to end #3 rest time")]
        [JsonProperty]
        public string lineRestEndTime3 { get; set; } = "23:45";

        [Browsable(false)]
        [Category("Logistics Time")]
        [DisplayName("#4 Rest Start Time")]
        [Description("Time to start #3 rest time")]
        [JsonProperty]
        public string lineRestStartTime4 { get; set; } = "03:30";

        [Browsable(false)]
        [Category("Logistics Time")]
        [DisplayName("#4 Rest End Time")]
        [Description("Time to end #4 rest time")]
        [JsonProperty]
        public string lineRestEndTime4 { get; set; } = "03:45";

        [Category("Logistics Time")]
        [DisplayName("Initializing interval(ms)")]
        [Description("Interval time for tact time or initializing system")]
        [JsonProperty]
        public int tactTimeResetCheckInterval { get; set; } = 1000 * 15; // 50sec
        #endregion


        //[Category("Logistics Password")]
        //[DisplayName("Password for dat tab")]
        //[Description("Password when you want to access data tab")]
        [ReadOnly(true)]
        [JsonProperty]
        public string dataPwd { get; set; } = "0000";

        //[Category("Logistics Password")]
        //[DisplayName("Password for origin tab")]
        //[Description("Password when you want to access origin tab. Which has to different from data tab and origin tab")]
        [ReadOnly(true)]
        [JsonProperty]
        public string originReturnPwd { get; set; } = "0001";


        [Browsable(false)]
        [Category("Block Condition")]
        [DisplayName("Continue fail block count")]
        [Description("Set continue fail block count (times)")]
        [JsonProperty]
        public int nPackFailBlockCount { get; set; } = 0;

        [Browsable(false)]
        [Category("Block Condition")]
        [DisplayName("Fail rate block percent")]
        [Description("Set fail rate block percent (%)")]
        [JsonProperty]
        public float nFailRateBlock { get; set; } = 100;

        [Browsable(false)]
        [Category("Block Condition")]
        [DisplayName("Max retest count on current JIG")]
        [Description("Set max retest count on current JIG (times)")]
        [JsonProperty]
        public int nRetestPackCount { get; set; } = 0;

        [Browsable(false)]
        [Category("Jig Tester Operation")]
        [DisplayName("Use retest tab on next JIG")]
        [Description("Select true/false to use retest tab on next JIG")]
        [JsonProperty]
        public bool IsUseRetestOnNextJig { get; set; } = true;

        [Browsable(false)]
        [Category("Jig Tester Operation")]
        [DisplayName("Delay Rf cable insert after Pack insert")]
        [Description("Define delay (ms)")]
        [JsonProperty]
        public uint RfCableInsertDelay { get; set; } = 30000;

        [Category("01 Line Name")]
        [DisplayName("Line Name")]
        [Description("Setup current line name")]
        [JsonProperty]
        public string sLineName { get; set; } = "01";

        //[Category("Common")]
        //[DisplayName("Use blow dusty")]
        //[Description("Select true/false to use blow dusty")]
        //[JsonProperty]
        //public bool IsUseBlowDusty { get; set; } = true;

        //[Category("Common")]
        //[DisplayName("Use clean vinyl")]
        //[Description("Select true/false to use clean vinyl")]
        //[JsonProperty]
        //public bool IsUseCleanVinyl { get; set; } = true;

        [Browsable(false)]
        [Category("Logistics")]
        [DisplayName("Model name")]
        [Description("Current selected model name")]
        [JsonProperty]
        public string modelName { get; set; } = "None";

        [Browsable(false)]
        [Category("Logistics")]
        [DisplayName("Model name sim tray left")]
        [Description("Current selected model name sim tray left")]
        [JsonProperty]
        public string modelSimTrayLeft { get; set; } = "None";

        [Browsable(false)]
        [Category("Logistics")]
        [DisplayName("Model name sim tray right")]
        [Description("Current selected model name sim tray right")]
        [JsonProperty]
        public string modelSimTrayRight { get; set; } = "None";

        [Browsable(false)]

        public MACHINE_TYPE modelType = MACHINE_TYPE.B;

        public ProductInfoModel productInfo { get; set; } = new ProductInfoModel();

        public TactTimeUtil TackTime = new TactTimeUtil();
    }
}
Configs/Model/VisionConfig.cs
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static Auto_Insert_Sim_Tray.Define.SystemEnum;

namespace Auto_Insert_Sim_Tray.Configs.Model
{
    public class VisionConfig
    {
        [Browsable(false)]
        [Category("Vision Left")]
        [DisplayName("IP Address of Vision Left")]
        [Description("IP Address of Vision Left")]
        [JsonProperty]
        public string IPAddress_Vision_1 { get; set; } = "107.114.203.127";

        [Category("Vision Left")]
        [DisplayName("Port of Vision Left")]
        [Description("Port of Vision Left")]
        [JsonProperty]
        public int Port_Vision_1 { get; set; } = 5000;

        [Category("Vision Left")]
        [DisplayName("Use Vision Left")]
        [Description("Select true/false to use or not use Vision Left")]
        [JsonProperty]
        public bool UseVision_Left { get; set; } = true;

        [Browsable(false)]
        [Category("Vision Right")]
        [DisplayName("IP Address of Vision Right")]
        [Description("IP Address of Vision Right")]
        [JsonProperty]
        public string IPAddress_Vision_2 { get; set; } = "107.114.203.127";

        [Category("Vision Right")]
        [DisplayName("Port of Vision Right")]
        [Description("Port of Vision Right")]
        [JsonProperty]
        public int Port_Vision_2 { get; set; } = 5050;

        [Category("Vision Right")]
        [DisplayName("Use Vision Right")]
        [Description("Select true/false to use or not use Vision Right")]
        [JsonProperty]
        public bool UseVision_Right { get; set; } = true;


        [Category("Vision Setting")]
        [DisplayName("Timeout")]
        [Description("Timeout")]
        [JsonProperty]
        public int TimeOut { get; set; } = 3000; //ms

        [Category("Vision Setting")]
        [DisplayName("Max Retry")]
        [Description("Max Retry")]
        [JsonProperty]
        public int MaxRetry { get; set; } = 3;

        [Browsable(false)]
        [Category("Vision Setting")]
        [DisplayName("Read Command")]
        [Description("Read Command")]
        [JsonProperty]
        public string ReadCommand { get; set; } = "grab";
    }
    /*public class VisionConfig
    {
        [JsonProperty]
        public string Name { get; set; }
        [JsonProperty]
        public string IPAddress { get; set; }
        [JsonProperty]
        public int Port { get; set; }
    }*/
}

Configs/JsonHelper.cs
/* 
 * Copyright (C) Samsung Electronics Co., Ltd., Inc - All Rights Reserved
 * Unauthorized copying of this file, via any medium is strictly prohibited
 * Proprietary and confidential
 * 
 * Written by Donghyun Ko <dh79.ko@samsung.com>, June 2022
 * Written by Sanghyeon Lee <sirano06.lee@samsung.com>, June 2022
 * 
 */
using Auto_Insert_Sim_Tray.Configs.Model;
using Auto_Insert_Sim_Tray.Define;
using Auto_Insert_Sim_Tray.Define.Position;
using Auto_Insert_Sim_Tray.HW.Common;
using Auto_Insert_Sim_Tray.Utils;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Ports;
using System.Linq;
using System.Runtime.Serialization.Json;
using System.Text;
using System.Threading.Tasks;
using static Auto_Insert_Sim_Tray.Define.AxisDefine;
using static Auto_Insert_Sim_Tray.Define.LogDefine;
using static Auto_Insert_Sim_Tray.Define.SystemEnum;
using static Auto_Insert_Sim_Tray.HW.Vendor.Fastech.Lib.EZI_COMM_DEFINE;

namespace Auto_Insert_Sim_Tray.Configs
{
    /**
     * @brief Json parsing과 write 를 지원하는 class
     * @details newton json library 활용으로 Json 형태의 파일의 직렬/역직렬화 하여 변수로 read / write 할 수 있다
     */
    public class JsonHelper
    {
        private static JsonHelper instance;
        public static JsonHelper Instance
        {
            get
            {
                if (instance == null)
                    instance = new JsonHelper();
                return instance;
            }
        }

        // TODO : 아래 Json 으로 read / write 할 자료구조 선정 및 변수 선언 후 이용
        [JsonProperty]
        public LogisticModel logisticModel = new LogisticModel();
        

        [JsonProperty]
        public Dictionary<AXIS_LIST, AxisParamData> axisParams = new Dictionary<AXIS_LIST, AxisParamData>()
        {
            { AXIS_LIST.X_AXIS_LD_SET, new AxisParamData() },
            { AXIS_LIST.X_AXIS_ULD_SET, new AxisParamData() },

            { AXIS_LIST.X_AXIS_ROBOTXYZ, new AxisParamData() },
            { AXIS_LIST.Y_AXIS_ROBOTXYZ, new AxisParamData() },
            { AXIS_LIST.Z_AXIS_ROBOTXYZ, new AxisParamData() },

            { AXIS_LIST.X_AXIS_ULD_TRAY, new AxisParamData() },
            { AXIS_LIST.Z_AXIS_OUT_TRAY, new AxisParamData() },

            { AXIS_LIST.R_AXIS_RELOAD_SIM, new AxisParamData() },
        };

        /*[JsonProperty]
        public Dictionary<LIST_ETHERNET, EthernetModel> ethernetConnections = new Dictionary<LIST_ETHERNET, EthernetModel>()
        {
            {LIST_ETHERNET.VISION_1, new EthernetModel() { Name = "VISION 1", IPAddress = "127.0.0.1", Port = 0} },
            {LIST_ETHERNET.VISION_2, new EthernetModel() { Name = "VISION 2", IPAddress = "127.0.0.1", Port = 1} },
        };*/
        [JsonProperty]
        public Dictionary<AxisPositionKey, Tuple<decimal, decimal>> axisPos = new Dictionary<AxisPositionKey, Tuple<decimal, decimal>>(new AxisPositionComparer());

        [JsonProperty]
        public Dictionary<int, Tuple<string, string, string>> errorMsg = new Dictionary<int, Tuple<string, string, string>>();

        //[JsonProperty]
        //public Dictionary<SerialPortElement, SerialPortModel> serialPortModel = new Dictionary<SerialPortElement, SerialPortModel>()
        //{
        //    {SerialPortElement.SERIAL_PC1, new SerialPortModel(){PortName = "COM10", ReadTimeout = 3000, WriteTimeout = 3000} },
        //};

        [JsonProperty]
        public DelayTimeModel delayTime = new DelayTimeModel();

        [JsonProperty]
        public TimeoutModel timeout = new TimeoutModel();

        [JsonProperty]
        public ConfigMC configMC = new ConfigMC();

        //[JsonProperty]
        //public Vinyl_MC2_Model vinyl_MC2_Model = new Vinyl_MC2_Model();

        //[JsonProperty]
        //public AxisZ_Wait_Offset_Model offset = new AxisZ_Wait_Offset_Model();

        [JsonProperty]
        public List<string> modelList = new List<string>();

        [JsonProperty]
        public Dictionary<string, string> models = new Dictionary<string, string>();

        [JsonProperty]
        public ProductInfoModel productInfo = new ProductInfoModel();

        [JsonProperty]
        public VisionConfig visionConfig = new VisionConfig();

        [JsonProperty]
        public BarcodeConfig barcodeConfig = new BarcodeConfig();

        [JsonProperty]
        public Dictionary<TOWERLAMP_MODE, TOWERLAMP_ELEMENT> towerLamp = new Dictionary<TOWERLAMP_MODE, TOWERLAMP_ELEMENT>()
        {
            { TOWERLAMP_MODE.MANUAL, TOWERLAMP_ELEMENT.Y },
            { TOWERLAMP_MODE.AUTO, TOWERLAMP_ELEMENT.G },
            { TOWERLAMP_MODE.ERROR, TOWERLAMP_ELEMENT.R },
            { TOWERLAMP_MODE.OPP, TOWERLAMP_ELEMENT.Y },
            { TOWERLAMP_MODE.OP_CALL, TOWERLAMP_ELEMENT.Y },
            { TOWERLAMP_MODE.IDLE, TOWERLAMP_ELEMENT.Y },
        };

        [JsonProperty]
        public Dictionary<string, PatternsModel> patterns = new Dictionary<string, PatternsModel>();

        public Dictionary<AXIS_LIST, Tuple<int, int>> dic_Limit_Speed = new Dictionary<AXIS_LIST, Tuple<int, int>>();
        /**
         * @details 원하는 Config type의 json 저장 경로를 리턴해 준다
         * @param[in] type CONFIG_TYPE : JSON config type
         * @todo CONFIG_TYPE이 추가되면 case 추가 필요하다
         * @return 해당 Config의 JSON 파일 경로를 리턴한다
         */
        private string GetPath(CONFIG_TYPE type)
        {
            string path = "";
            switch (type)
            {
                case CONFIG_TYPE.LOGISTIC:
                    path = ConfigDefine.logisticJson;
                    break;
                case CONFIG_TYPE.AXIS:
                    path = ConfigDefine.axisParamJson;
                    break;
                case CONFIG_TYPE.PRODUCT_INFO:
                    path = ConfigDefine.productInfoJson;
                    break;
                case CONFIG_TYPE.ERROR:
                    path = ConfigDefine.errorJson;
                    break;
                case CONFIG_TYPE.SERIAL_PORT:
                    path = ConfigDefine.serialJson;
                    break;
                case CONFIG_TYPE.DELAY_TIME:
                    path = ConfigDefine.delayTimeJson;
                    break;
                case CONFIG_TYPE.TIMEOUT:
                    path = ConfigDefine.timeoutJson;
                    break;
                case CONFIG_TYPE.MODEL_LIST:
                    path = ConfigDefine.modelListJson;
                    break;
                case CONFIG_TYPE.MODEL:
                    path = ConfigDefine.modelJson;
                    break;
                case CONFIG_TYPE.AXIS_POS:
                    path = ConfigDefine.axisPosDirectory + JsonHelper.Instance.logisticModel.modelName + "_AxisPos.json";
                    break;
                case CONFIG_TYPE.PATTERNS:
                    path = ConfigDefine.patternJson;
                    break;
                case CONFIG_TYPE.VISION:
                    path = ConfigDefine.vision;
                    break;
                case CONFIG_TYPE.TOWER_LAMP:
                    path = ConfigDefine.towerLampJson;
                    break;
                case CONFIG_TYPE.CONFIG_MC:
                    path = ConfigDefine.config_MC;
                    break;
                default:
                    break;
            }
            return path;
        }

        /**
         * @details CONFIG_TYPE에 맞춰 serialize 하기 위한 객체를 리턴해준다
         * @param[in] type CONFIG_TYPE : JSON config type
         * @todo CONFIG_TYPE 추가 시에, 리턴하는 객체 case를 추가해야 한다
         * @return CONFIG를 저장하고 있는 멤버변수를 object화 하여 리턴한다
         */
        private object GetSerialInstance(CONFIG_TYPE type)
        {
            object ob;
            switch (type)
            {
                case CONFIG_TYPE.LOGISTIC:
                    ob = logisticModel;
                    break;
                case CONFIG_TYPE.AXIS:
                    ob = axisParams;
                    break;
                case CONFIG_TYPE.PRODUCT_INFO:
                    ob = productInfo;
                    break;
                case CONFIG_TYPE.TOWER_LAMP:
                    ob = towerLamp;
                    break;
                case CONFIG_TYPE.ERROR:
                    ob = errorMsg;
                    break;
                case CONFIG_TYPE.SERIAL_PORT:
                    ob = barcodeConfig;
                    break;
                case CONFIG_TYPE.DELAY_TIME:
                    ob = delayTime;
                    break;
                case CONFIG_TYPE.TIMEOUT:
                    ob = timeout;
                    break;
                case CONFIG_TYPE.MODEL_LIST:
                    ob = modelList;
                    break;
                case CONFIG_TYPE.MODEL:
                    ob = models;
                    break;
                case CONFIG_TYPE.AXIS_POS:
                    ob = axisPos;
                    break;
                case CONFIG_TYPE.PATTERNS:
                    ob = patterns;
                    break;
                case CONFIG_TYPE.VISION:
                    ob = visionConfig;
                    break;
                case CONFIG_TYPE.CONFIG_MC:
                    ob = configMC;
                    break;
                default:
                    ob = null;
                    break;
            }
            return ob;
        }

        private Type GetType(CONFIG_TYPE type)
        {
            Type ob;
            switch (type)
            {
                case CONFIG_TYPE.LOGISTIC:
                    ob = logisticModel.GetType();
                    break;
                case CONFIG_TYPE.AXIS:
                    ob = axisParams.GetType();
                    break;
                case CONFIG_TYPE.AXIS_POS:
                    ob = axisPos.GetType();
                    break;
                case CONFIG_TYPE.PRODUCT_INFO:
                    ob = productInfo.GetType();
                    break;
                case CONFIG_TYPE.TOWER_LAMP:
                    ob = towerLamp.GetType();
                    break;
                case CONFIG_TYPE.ERROR:
                    ob = errorMsg.GetType();
                    break;
                case CONFIG_TYPE.SERIAL_PORT:
                    ob = barcodeConfig.GetType();
                    break;
                case CONFIG_TYPE.TIMEOUT:
                    ob = timeout.GetType();
                    break;
                case CONFIG_TYPE.MODEL_LIST:
                    ob = modelList.GetType();
                    break;
                case CONFIG_TYPE.MODEL:
                    ob = models.GetType();
                    break;
                case CONFIG_TYPE.DELAY_TIME:
                    ob = delayTime.GetType();
                    break;
                case CONFIG_TYPE.PATTERNS:
                    ob = patterns.GetType();
                    break;
                case CONFIG_TYPE.VISION:
                    ob = visionConfig.GetType();
                    break;
                case CONFIG_TYPE.CONFIG_MC:
                    ob = configMC.GetType();
                    break;
                default:
                    ob = null;
                    break;
            }
            return ob;
        }

        /**
         * @details 읽어온 Json string을 deserialize하여 객체화 한다
         * @param[in] type CONFIG_TYPE : JSON config type
         * @param[in] strJson Json에서 읽어온 string 데이터
         * @todo CONFIG_TYPE 추가 시에, 객체화 하는 case 추가
         */
        public void Deserialize(CONFIG_TYPE type, string strJson)
        {
            if (strJson != "")
            {
                DataContractJsonSerializer serializer = new DataContractJsonSerializer(GetType(type));

                switch (type)
                {
                    case CONFIG_TYPE.LOGISTIC:
                        logisticModel = JsonConvert.DeserializeObject<LogisticModel>(strJson);
                        break;
                    case CONFIG_TYPE.AXIS:
                        axisParams = JsonConvert.DeserializeObject<Dictionary<AXIS_LIST, AxisParamData>>(strJson);
                        break;
                    case CONFIG_TYPE.PRODUCT_INFO:
                        productInfo = JsonConvert.DeserializeObject<ProductInfoModel>(strJson);
                        break;
                    case CONFIG_TYPE.TOWER_LAMP:
                        towerLamp = JsonConvert.DeserializeObject<Dictionary<TOWERLAMP_MODE, TOWERLAMP_ELEMENT>>(strJson);
                        break;
                    case CONFIG_TYPE.ERROR:
                        errorMsg = JsonConvert.DeserializeObject<Dictionary<int, Tuple<string, string, string>>>(strJson);
                        break;
                    case CONFIG_TYPE.SERIAL_PORT:
                        barcodeConfig = JsonConvert.DeserializeObject<BarcodeConfig>(strJson);
                        if (barcodeConfig.scanner is null)
                        {
                            barcodeConfig.scanner = new HW.BarcodeReader.BarcodeReaderConfig()
                            {
                                ReadCommand = "T",
                                DataLength = 10,
                                RetryRead = 3,
                                NewLine = "\r\n"
                            };
                        }
                        break;
                    case CONFIG_TYPE.DELAY_TIME:
                        delayTime = JsonConvert.DeserializeObject<DelayTimeModel>(strJson);
                        break;
                    case CONFIG_TYPE.TIMEOUT:
                        timeout = JsonConvert.DeserializeObject<TimeoutModel>(strJson);
                        break;
                    case CONFIG_TYPE.MODEL_LIST:
                        modelList = JsonConvert.DeserializeObject<List<string>>(strJson);
                        break;
                    case CONFIG_TYPE.MODEL:
                        models = JsonConvert.DeserializeObject<Dictionary<string, string>>(strJson);
                        break;
                    case CONFIG_TYPE.AXIS_POS:
                        // axisPos = JsonConvert.DeserializeObject<Dictionary<AxisPositionKey, Tuple<decimal, string>>>(strJson);
                        using (MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(strJson)))
                        {
                            Dictionary<AxisPositionKey, Tuple<decimal, decimal>> temp = (Dictionary<AxisPositionKey, Tuple<decimal, decimal>>)serializer.ReadObject(ms);
                            for (int i = 0; i < temp.Count(); i++)
                            {
                                if (axisPos.Keys.Contains(temp.ElementAt(i).Key))
                                {
                                    axisPos[temp.ElementAt(i).Key] = temp.ElementAt(i).Value;
                                }
                                else
                                {
                                    axisPos.Add(temp.ElementAt(i).Key, temp.ElementAt(i).Value);
                                }
                            }
                        }
                        break;
                    case CONFIG_TYPE.PATTERNS:
                        patterns = JsonConvert.DeserializeObject<Dictionary<string, PatternsModel>>(strJson);
                        break;
                    case CONFIG_TYPE.VISION:
                        visionConfig = JsonConvert.DeserializeObject<VisionConfig>(strJson);
                        break;
                    case CONFIG_TYPE.CONFIG_MC:
                        configMC = JsonConvert.DeserializeObject<ConfigMC>(strJson);
                        //if (configMC.scanner.Count == 0 || connectionData.screwConnections.Count == 0)
                        //{
                        //    //Init Defaul Value
                        //    InitDefaultValue(CONFIG_TYPE.CONNECTION);
                        //}
                        break;
                    default:
                        break;
                }
            }
        }

        /**
         * @details CONFIG_TYPE에 맞춰 JSON 파일에 내용 저장
         * @param[in] type CONFIG_TYPE : JSON config type
         */
        public void SaveSettings(CONFIG_TYPE type)
        {
            try
            {
                string path = GetPath(type);

                if (type == CONFIG_TYPE.AXIS_POS)
                {
                    if (!File.Exists(path))
                    {
                        string msg = "Config path not found : " + type.ToString();
                        LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, msg, CONTENT_TYPE.WARNING);
                        Directory.CreateDirectory(ConfigDefine.axisPosDirectory);
                    }

                    DataContractJsonSerializer serializer = new DataContractJsonSerializer(GetType(type));
                    using (MemoryStream ms = new MemoryStream())
                    {
                        serializer.WriteObject(ms, GetSerialInstance(type));
                        string strJson = Encoding.Default.GetString(ms.ToArray());
                        string strJson_Idt = JToken.Parse(strJson).ToString(Formatting.Indented);
                        File.WriteAllText(path, strJson_Idt, Encoding.UTF8);
                    }
                }
                else
                {
                    if (!File.Exists(path))
                    {
                        string msg = "Config path not found : " + type.ToString();
                        LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, msg, CONTENT_TYPE.WARNING);
                        Directory.CreateDirectory(ConfigDefine.configRootPath);
                    }
                    string strJson = JsonConvert.SerializeObject(GetSerialInstance(type));
                    string strJson_Idt = JToken.Parse(strJson).ToString(Formatting.Indented);
                    File.WriteAllText(path, strJson_Idt, Encoding.UTF8);
                }
            }
            catch (Exception ex)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, ex.ToString(), CONTENT_TYPE.EXCEPTION);
            }
        }

        /**
         * @details CONFIG_TYPE에 맞춰 JSON 파일에서 객체로 parsing 해오는 함수
         * @param[in] type CONFIG_TYPE : JSON config type
         */
        public void LoadSettings(CONFIG_TYPE type)
        {
            string path = GetPath(type);

            if (File.Exists(path) == true)
            {
                try
                {
                    string strJson = File.ReadAllText(path, Encoding.UTF8);
                    Deserialize(type, strJson);
                }
                catch (Exception ex)
                {
                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, ex.ToString(), CONTENT_TYPE.EXCEPTION);
                }
            }
            else
            {
                string msg = "File not found : " + type.ToString();
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, msg, CONTENT_TYPE.WARNING);
                SaveSettings(type);
            }
        }
    }
}

Define/AxisDefine.cs
/* 
 * Copyright (C) Samsung Electronics Co., Ltd., Inc - All Rights Reserved
 * Unauthorized copying of this file, via any medium is strictly prohibited
 * Proprietary and confidential
 * 
 * Written by Donghyun Ko <dh79.ko@samsung.com>, June 2022
 * Written by Sanghyeon Lee <sirano06.lee@samsung.com>, June 2022
 * 
 */
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace Auto_Insert_Sim_Tray.Define
{
    [Serializable]
    public static class AxisDefine
    {
        public const decimal ACCEPTABLE_DISTANCE = 0.1m; //cm
        public const int AXIS_MOVE_DELAY = 100; // msec

        public enum AXIS_LIST
        {
            NONE = -1,

            X_AXIS_LD_SET,
            X_AXIS_ULD_SET,

            X_AXIS_ULD_TRAY,

            R_AXIS_RELOAD_SIM,

            X_AXIS_ROBOTXYZ,
            Y_AXIS_ROBOTXYZ,
            Z_AXIS_ROBOTXYZ,

            Z_AXIS_OUT_TRAY,

            
            MAX,
        }

        public enum X_LD_POSITION
        {
            NONE = -1,
            Wait,

            Input,
            Left_Jig,
            Right_Jig,
            //Max
        }
        public enum X_ULD_POSITION
        {
            NONE = -1,
            Wait,

            Output,
            NG,
            Left_Jig,
            Right_Jig,
            //Max
        }
        public enum XYZ_ROBOT_POSITION
        {
            NONE = -1,
            Wait,
            Wait_Unload_Tray,

            L_Wait_Check_Vision,
            L_Tray_Pick_Up_1,
            L_Tray_Pick_Up_2,
            L_Tray_Pick_Down_1,
            //L_Tray_Pick_Down_2,
            L_Jig_Insert_Up,
            L_Jig_Insert_Down_1,
            L_Jig_Insert_Down_2,

            R_Wait_Check_Vision,
            R_Tray_Pick_Up_1,
            R_Tray_Pick_Up_2,
            R_Tray_Pick_Down_1,
            //R_Tray_Pick_Down_2,
            R_Jig_Insert_Up,
            R_Jig_Insert_Down_1,
            R_Jig_Insert_Down_2,

            NG_Sim_Up,
            NG_Sim_Down,

            //Tọa độ trung gian khi gán từ vision
            
            
            L_Pos_1,
            L_Pos_2,
            L_Pos_3,
            L_Pos_4,
            L_Pos_5,
            L_Pos_6,

            R_Pos_1,
            R_Pos_2,
            R_Pos_3,
            R_Pos_4,
            R_Pos_5,
            R_Pos_6,


        }
        public enum X_ULD_TRAY_POSITION
        {
            NONE = -1,
            Wait,

            Left_Tray_Pick,

            Right_Tray_Pick,

            Place_Tray,

        }
        public enum Z_TF_OUTTRAY_POSITION
        {
            NONE = -1,
            Wait,

            Input_Tray,

            Output_Tray,

        }


        public enum LASER_POSITION
        {
            NONE = 1,
            READY,
            #region Module AC
            LASER_WORK_A,
            LASER_WORK_C,
            #endregion
            #region Module B
            LASER_WORK_B_0_DEGREE,
            LASER_WORK_B_90_DEGREE,
            LASER_WORK_B_180_DEGREE,
            LASER_WORK_B_270_DEGREE,
            #endregion
        }
    }
}

Define/ConfigDefine.cs
/* 
 * Copyright (C) Samsung Electronics Co., Ltd., Inc - All Rights Reserved
 * Unauthorized copying of this file, via any medium is strictly prohibited
 * Proprietary and confidential
 * 
 * Written by Donghyun Ko <dh79.ko@samsung.com>, June 2022
 * Written by Sanghyeon Lee <sirano06.lee@samsung.com>, June 2022
 * 
 */
using Auto_Insert_Sim_Tray.Configs;
using Auto_Insert_Sim_Tray.Configs.Model;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Auto_Insert_Sim_Tray.Define
{
    /**
     * @brief Config를 다루는데 필요한 상수들을 정의하는 클래스
     * @details 경로, 파일명 등의 저장이 가능함
     */
    public class ConfigDefine
    {
        public static string configRootPath = SystemDefine.rootPath + @"Json\";
        public static string axisPosDirectory = configRootPath + @"AxisPosition\";

        public static string logisticJson = configRootPath + @"Logistic.Json";
        public static string positionJson = configRootPath + @"Position.Json";
        public static string errorJson = configRootPath + @"ErrorCode.Json";
        public static string serialJson = configRootPath + @"SerialPort.Json";
        public static string productInfoJson = configRootPath + @"ProductInfo.Json";
        public static string axisParamJson = configRootPath + @"AxisParam.Json";
        public static string delayTimeJson = configRootPath + @"DelayTime.Json";
        public static string timeoutJson = configRootPath + @"Timeout.Json";
        public static string modelListJson = configRootPath + @"ModelList.Json";
        public static string modelJson = configRootPath + @"Model.Json";
        public static string axisPosJson = axisPosDirectory + JsonHelper.Instance.logisticModel.modelName + "_AxisPos.json";
        public static string metalLogisticsInfo = configRootPath + @"MetalLogisticsInfo.Json";
        public static string patternJson = configRootPath + @"Patterns.Json";
        //public static string offsetAxisJson = configRootPath + @"OffsetAxis.Json";
        public static string towerLampJson = configRootPath + @"Tower Lamp.Json";
        public static string config_MC = configRootPath + @"Config MC.Json";
        public static string vision = configRootPath + @"Vision.Json";
    }

    /**
     * @brief 물류 프로그램에서 다룰 Config 종류를 정의하는 enum
     * @details 기본적으로 물류, 모터, 검사결과, 에러코드, serial 설정들을 다룸
     * @todo 물류 프로그램에서 다룰 Config 종류의 추가가 필요하면 해당 enum에 추가해야 한다.
     */
    public enum CONFIG_TYPE
    {
        LOGISTIC = 0,
        AXIS,
        PRODUCT_INFO,
        ERROR,
        SERIAL_PORT,
        DELAY_TIME,
        TIMEOUT,
        MODEL_LIST,
        MODEL,
        AXIS_POS,
        PATTERNS,
        VISION,
        TOWER_LAMP,
        CONFIG_MC,
        
    }
}

Define/ConveyorDefine.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Auto_Insert_Sim_Tray.Define
{
    public enum CONVEYOR_LIST
    {
        NONE = -1,
        INPUT1,
        INPUT2,
        OUTPUT,
        MAX,
    }

    public class ConveyorData
    {
        public object runCW;
        public object runCCW;
        public object inSensor;
        public object middleSensor;
        public object outSensor;

        public ConveyorData(object runCW, object runCCW, object inSensor, object middleSensor, object outSensor)
        {
            this.runCW = runCW;
            this.runCCW = runCCW;
            this.inSensor = inSensor;
            this.middleSensor = middleSensor;
            this.outSensor = outSensor;
        }
    }
}

Define/IODefine.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Auto_Insert_Sim_Tray.Define
{
    /**
     * @brief 물류 프로그램에서 사용하는 IO를 define 하는 클래스
     * @details Input에 관한 DI와 output에 관한 DO가 있다
     */
    public static class IODefine
    {
        public enum DI
        {
            NONE = -1,

            #region MyRegion
            _10_EMG,
            _10_SS_DOOR,
            _10_BUTTON_START,
            _10_BUTTON_STOP,
            _10_BUTTON_RESET,
            _10_SS_LD_CLAMP_UP,
            _10_SS_LD_CLAMP_DOWN,
            _10_SS_LD_UP,
            _10_SS_LD_DOWN,
            _10_SS_LD_ROTATE_REAR,
            _10_SS_LD_ROTATE_FRONT,
            _10_SS_LD_ROTATE_MIDDLE,
            _10_SS_LD_CLAMP_OFF,
            _10_SS_LD_CLAMP_ON,
            _10_SS_ULD_UP,
            _10_SS_ULD_DOWN,

            _10_SS_ULD_ROTATE_REAR,
            _10_SS_ULD_ROTATE_FRONT,
            _10_SS_ULD_ROTATE_MIDDLE,
            _10_SS_ULD_CLAMP_OFF,
            _10_SS_ULD_CLAMP_ON,
            _10_SS_ULD_CLAMP_UP,
            _10_SS_ULD_CLAMP_DOWN,
            _10_SS_JIG_LEFT_POS_OUT,
            _10_SS_JIG_LEFT_POS_IN,
            _10_SS_JIG_LEFT_BW,
            _10_SS_JIG_LEFT_FW,
            _10_SS_JIG_LEFT_ALIGN_HOR_OFF,
            _10_SS_JIG_LEFT_ALIGN_HOR_ON,
            _10_SS_JIG_LEFT_ALIGN_VER_OFF,
            _10_SS_JIG_LEFT_ALIGN_VER_ON,
            _10_SS_JIG_LEFT_DETECT_SET,


            _11_SS_INTRAY_LEFT_HOLD_OFF,
            _11_SS_INTRAY_LEFT_HOLD_ON,
            _11_SS_INTRAY_LEFT_SEPERATE_OFF,
            _11_SS_INTRAY_LEFT_SEPERATE_ON,
            _11_SS_INTRAY_LEFT_ELEVATOR_1_BW,
            _11_SS_INTRAY_LEFT_ELEVATOR_1_FW,
            _11_SS_INTRAY_LEFT_ELEVATOR_2_BW,
            _11_SS_INTRAY_LEFT_ELEVATOR_2_FW,
            _11_SS_INTRAY_LEFT_STOPPER_1_DOWN,
            _11_SS_INTRAY_LEFT_STOPPER_1_UP,
            _11_SS_INTRAY_LEFT_STOPPER_2_DOWN,
            _11_SS_INTRAY_LEFT_STOPPER_2_UP,
            _11_SS_INTRAY_LEFT_REMOVE_DOWN,
            _11_SS_INTRAY_LEFT_REMOVE_UP,
            _11_SS_INTRAY_LEFT_REMOVE_BW,
            _11_SS_INTRAY_LEFT_REMOVE_FW,

            _11_SS_INTRAY_LEFT_ALIGN_OFF,
            _11_SS_INTRAY_LEFT_ALIGN_ON,
            _11_SS_INTRAY_LEFT_ALIGN_TOP_ON,
            _11_SS_INTRAY_LEFT_DETECT_1,
            _11_SS_INTRAY_LEFT_DETECT_2,
            _11_SS_INTRAY_LEFT_DETECT_3,
            _11_SS_INTRAY_LEFT_DETECT_4,
            _11_SS_JIG_RIGHT_POS_OUT,
            _11_SS_JIG_RIGHT_POS_IN,
            _11_SS_JIG_RIGHT_BW,
            _11_SS_JIG_RIGHT_FW,
            _11_SS_JIG_RIGHT_ALIGN_HOR_OFF,
            _11_SS_JIG_RIGHT_ALIGN_HOR_ON,
            _11_SS_JIG_RIGHT_ALIGN_VER_OFF,
            _11_SS_JIG_RIGHT_ALIGN_VER_ON,
            _11_SS_JIG_RIGHT_DETECT_SET,


            _12_SS_INTRAY_RIGHT_HOLD_OFF,
            _12_SS_INTRAY_RIGHT_HOLD_ON,
            _12_SS_INTRAY_RIGHT_SEPERATE_OFF,
            _12_SS_INTRAY_RIGHT_SEPERATE_ON,
            _12_SS_INTRAY_RIGHT_ELEVATOR_1_BW,
            _12_SS_INTRAY_RIGHT_ELEVATOR_1_FW,
            _12_SS_INTRAY_RIGHT_ELEVATOR_2_BW,
            _12_SS_INTRAY_RIGHT_ELEVATOR_2_FW,
            _12_SS_INTRAY_RIGHT_STOPPER_1_DOWN,
            _12_SS_INTRAY_RIGHT_STOPPER_1_UP,
            _12_SS_INTRAY_RIGHT_STOPPER_2_DOWN,
            _12_SS_INTRAY_RIGHT_STOPPER_2_UP,
            _12_SS_INTRAY_RIGHT_REMOVE_DOWN,
            _12_SS_INTRAY_RIGHT_REMOVE_UP,
            _12_SS_INTRAY_RIGHT_REMOVE_BW,
            _12_SS_INTRAY_RIGHT_REMOVE_FW,

            _12_SS_INTRAY_RIGHT_ALIGN_OFF,
            _12_SS_INTRAY_RIGHT_ALIGN_ON,
            _12_SS_INTRAY_RIGHT_ALIGN_TOP_ON,
            _12_SS_INTRAY_RIGHT_DETECT_1,
            _12_SS_INTRAY_RIGHT_DETECT_2,
            _12_SS_INTRAY_RIGHT_DETECT_3,
            _12_SS_INTRAY_RIGHT_DETECT_4,
            _12_SS_ULD_POS_OK,
            _12_SS_ULD_POS_NG,
            _12_SPARE2,
            _12_SS_NG_SHUTTER_DETECT_1,
            _12_SS_NG_SHUTTER_DETECT_2,
            _12_SS_NG_SHUTTER_DETECT_3,
            _12_SS_NG_SHUTTER_DETECT_4,
            _12_SS_NG_SHUTTER_BW,
            _12_SS_NG_SHUTTER_FW,
            

            _13_SS_TRAY_SIM_ROTATE_OFF,
            _13_SS_TRAY_SIM_ROTATE_ON,
            _13_SS_TRAY_SIM_TURN_OFF,
            _13_SS_TRAY_SIM_TURN_ON,
            _13_SS_TRAY_SIM_GRIP_OFF,
            _13_SS_TRAY_SIM_GRIP_ON,
            _13_SS_TRAY_SIM_PUSH_FRONT_UP,
            _13_SS_TRAY_SIM_PUSH_FRONT_DOWN,
            _13_SS_TRAY_SIM_PUSH_REAR_UP,
            _13_SS_TRAY_SIM_PUSH_REAR_DOWN,
            _13_SS_TRAY_SIM_GRIP_CHECK,
            _13_SS_UNLOAD_TRAY_UP,
            _13_SS_UNLOAD_TRAY_DOWN,
            _13_SS_UNLOAD_TRAY_CLAMP_OFF,
            _13_SS_UNLOAD_TRAY_CLAMP_ON,
            _13_SPARE0,

            _13_SS_OUTTRAY_LIFT_DETECT,
            _13_SS_OUTTRAY_TRANSFER_FRONT_BW,
            _13_SS_OUTTRAY_TRANSFER_FRONT_FW,
            _13_SS_OUTTRAY_TRANSFER_REAR_BW,
            _13_SS_OUTTRAY_TRANSFER_REAR_FW,
            _13_SS_OUTTRAY_REMOVE_BW,
            _13_SS_OUTTRAY_REMOVE_FW,
            _13_SS_OUTTRAY_PUSH_UP,
            _13_SS_OUTTRAY_PUSH_DOWN,
            _13_SS_OUTTRAY_TRANSFER_FRONT_DETECT,
            _13_SS_OUTTRAY_TRANSFER_REAR_DETECT,
            _13_SS_OUTTRAY_LEFT_DETECT_1,
            _13_SS_OUTTRAY_LEFT_DETECT_2,
            _13_SS_OUTTRAY_RIGHT_DETECT_1,
            _13_SS_OUTTRAY_RIGHT_DETECT_2,
            _13_SS_TRAY_SIM_CHECK_NG,


            _14_SS_OUTTRAY_STOPPER_TRANSFER_UP,
            _14_SS_OUTTRAY_STOPPER_TRANSFER_DOWN,
            _14_SS_OUTTRAY_LEFT_STOPPER_1_UP,
            _14_SS_OUTTRAY_LEFT_STOPPER_1_DOWN,
            _14_SS_OUTTRAY_LEFT_STOPPER_2_UP,
            _14_SS_OUTTRAY_LEFT_STOPPER_2_DOWN,
            _14_SS_OUTTRAY_RIGHT_STOPPER_1_UP,
            _14_SS_OUTTRAY_RIGHT_STOPPER_1_DOWN,
            _14_SS_OUTTRAY_RIGHT_STOPPER_2_UP,
            _14_SS_OUTTRAY_RIGHT_STOPPER_2_DOWN,
            _14_SS_JIG_LEFT_ALIGN_SIM_ON,
            _14_SS_JIG_LEFT_ALIGN_SIM_OFF,
            _14_SS_JIG_RIGHT_ALIGN_SIM_ON,
            _14_SS_JIG_RIGHT_ALIGN_SIM_OFF,
            _14_IN_AGV_1_1,
            _14_IN_AGV_1_2,


            _14_IN_AGV_1_3,
            _14_IN_AGV_1_4, // ON khi AGV bắt đầu transfer hàng sang Robot
            _14_IN_AGV_2_1,
            _14_IN_AGV_2_2,
            _14_IN_AGV_2_3,
            _14_IN_AGV_2_4, // ON khi AGV bắt đầu transfer hàng sang Robot
            _14_SS_CV_IN_DETECT_1,
            _14_SS_CV_IN_DETECT_2,
            _14_SS_CV_IN_DETECT_3,
            _14_SS_CV_OUT_DETECT_1,
            _14_SS_CV_OUT_DETECT_2,
            _14_SS_RELOAD_SIM_SAFETY,
            _14_SS_SAFETY_ZONE_INPUT,
            _14_SS_SAFETY_ZONE_OUTPUT,
            _14_IF_FRONT_READY,
            _14_IF_BEHIND_BUSY,
            #endregion

            IN_MAX,
            IN_MAX1,
        };

        public enum DO
        {
            NONE = -1,

            #region MyRegion
            _10_BUTTON_START_LAMP,
            _10_BUTTON_STOP_LAMP,
            _10_BUTTON_RESET_LAMP,
            _10_TOWERLAMP_GREEN,
            _10_TOWERLAMP_YELLOW,
            _10_TOWERLAMP_RED,
            _10_BUZZ,
            _10_SOL_LD_UP,
            _10_SOL_LD_DOWN,
            _10_SOL_LD_ROTATE_REAR,
            _10_SOL_LD_ROTATE_FRONT,
            _10_SOL_LD_CLAMP_ON,
            _10_SOL_LD_CLAMP_UP_DOWN,
            _10_SOL_ULD_UP,
            _10_SOL_ULD_DOWN,
            _10_SOL_ULD_ROTATE_REAR,

            _10_SOL_ULD_ROTATE_FRONT,
            _10_SOL_ULD_CLAMP_ON,
            _10_SOL_ULD_POS_OK,
            _10_SOL_ULD_POS_NG,
            _10_SOL_ULD_CLAMP_UP_DOWN,
            _10_OUT_AGV_1_2, // ON khi muốn AGV transfer hàng ở bên trái
            _10_OUT_AGV_1_1, // ON khi muốn AGV transfer hàng ở bên phải
            _10_OUT_AGV_1_4, // ON khi hoàn thành transfer giữa Robot với AGV
            _10_OUT_AGV_1_5, // ON khi băng tải ngoài cùng tầng trên trống
            _10_SOL_JIG_LEFT_POS_OUT,
            _10_SOL_JIG_LEFT_POS_IN,
            _10_SOL_JIG_LEFT_BW,
            _10_SOL_JIG_LEFT_FW,
            _10_SOL_JIG_LEFT_ALIGN_HOR,
            _10_SOL_JIG_LEFT_ALIGN_VER,
            _10_SOL_JIG_LEFT_ALIGN_SIM,


            _11_SOL_INTRAY_LEFT_HOLD_OFF,
            _11_SOL_INTRAY_LEFT_HOLD_ON,
            _11_SOL_INTRAY_LEFT_SEPERATE_OFF,
            _11_SOL_INTRAY_LEFT_SEPERATE_ON,
            _11_SOL_INTRAY_LEFT_ELEVATOR_1_BW,
            _11_SOL_INTRAY_LEFT_ELEVATOR_1_FW,
            _11_SOL_INTRAY_LEFT_ELEVATOR_2_BW,
            _11_SOL_INTRAY_LEFT_ELEVATOR_2_FW,
            _11_SOL_INTRAY_LEFT_STOPPER_1_DOWN,
            _11_SOL_INTRAY_LEFT_STOPPER_2_DOWN,
            _11_SOL_INTRAY_LEFT_REMOVE_DOWN,
            _11_SOL_INTRAY_LEFT_REMOVE_UP,
            _11_SOL_INTRAY_LEFT_REMOVE_BW,
            _11_SOL_INTRAY_LEFT_REMOVE_FW,
            _11_SOL_INTRAY_LEFT_ALIGN_OFF,
            _11_SOL_INTRAY_LEFT_ALIGN_TOP_OFF,


            _11_SOL_INTRAY_RIGHT_HOLD_OFF,
            _11_SOL_INTRAY_RIGHT_HOLD_ON,
            _11_SOL_INTRAY_RIGHT_SEPERATE_OFF,
            _11_SOL_INTRAY_RIGHT_SEPERATE_ON,
            _11_SOL_INTRAY_RIGHT_ELEVATOR_1_BW,
            _11_SOL_INTRAY_RIGHT_ELEVATOR_1_FW,
            _11_SOL_INTRAY_RIGHT_ELEVATOR_2_BW,
            _11_SOL_INTRAY_RIGHT_ELEVATOR_2_FW,
            _11_SOL_INTRAY_RIGHT_STOPPER_1_DOWN,
            _11_SOL_INTRAY_RIGHT_STOPPER_2_DOWN,
            _11_SOL_INTRAY_RIGHT_REMOVE_DOWN,
            _11_SOL_INTRAY_RIGHT_REMOVE_UP,
            _11_SOL_INTRAY_RIGHT_REMOVE_BW,
            _11_SOL_INTRAY_RIGHT_REMOVE_FW,
            _11_SOL_INTRAY_RIGHT_ALIGN_OFF,
            _11_SOL_INTRAY_RIGHT_ALIGN_TOP_OFF,


            _12_SOL_TRAY_SIM_ROTATE_OFF,
            _12_SOL_TRAY_SIM_ROTATE_ON,
            _12_SOL_TRAY_SIM_TURN,
            _12_SOL_TRAY_SIM_GRIP,
            _12_SOL_TRAY_SIM_PUSH_FRONT,
            _12_SOL_TRAY_SIM_PUSH_REAR,
            _12_SPARE0,
            _12_SOL_OUTTRAY_TRANSFER_FRONT_BW,
            _12_SOL_OUTTRAY_TRANSFER_FRONT_FW,
            _12_SOL_OUTTRAY_TRANSFER_REAR_BW,
            _12_SOL_OUTTRAY_TRANSFER_REAR_FW,
            _12_SOL_OUTTRAY_REMOVE_BW,
            _12_SOL_OUTTRAY_REMOVE_FW,
            _12_SOL_OUTTRAY_PUSH_UP,
            _12_SOL_OUTTRAY_PUSH_DOWN,
            _12_SOL_OUTTRAY_STOPPER_TRANSFER_DOWN,

            _12_SOL_OUTTRAY_STOPPER_LEFT_DOWN_1,
            _12_SOL_OUTTRAY_STOPPER_LEFT_DOWN_2,
            _12_SOL_OUTTRAY_STOPPER_RIGHT_DOWN_1,
            _12_SOL_OUTTRAY_STOPPER_RIGHT_DOWN_2,
            _12_SOL_UNLOAD_TRAY_UP,
            _12_SOL_UNLOAD_TRAY_DOWN,
            _12_SOL_UNLOAD_TRAY_CLAMP_OFF,
            _12_SOL_UNLOAD_TRAY_CLAMP_ON,
            _12_SPARE1,
            _12_SOL_JIG_RIGHT_POS_OUT,
            _12_SOL_JIG_RIGHT_POS_IN,
            _12_SOL_JIG_RIGHT_BW,
            _12_SOL_JIG_RIGHT_FW,
            _12_SOL_JIG_RIGHT_ALIGN_HOR,
            _12_SOL_JIG_RIGHT_ALIGN_VER,
            _12_SOL_JIG_RIGHT_ALIGN_SIM,


            _13_SOL_NG_SHUTTER_FW,
            _13_SOL_NG_SHUTTER_BW,
            _13_SOL_NG_SHUTTER_DOWN_1,
            _13_SOL_NG_SHUTTER_DOWN_2,
            _13_SOL_NG_SHUTTER_DOWN_3,
            _13_OUT_AGV_1_6, // ON khi băng tải ngoài cùng tầng dưới có tray trống
            _13_OUT_AGV_1_7,
            _13_OUT_AGV_1_8,
            _13_OUT_AGV_2_1, // ON khi muốn AGV transfer hàng ở bên trái
            _13_OUT_AGV_2_2, // ON khi muốn AGV transfer hàng ở bên phải
            _13_OUT_AGV_2_3, 
            _13_OUT_AGV_2_4,  // ON khi hoàn thành transfer giữa Robot với AGV
            _13_OUT_AGV_2_5,  // ON khi băng tải ngoài cùng tầng trên trống
            _13_OUT_AGV_2_6,  // ON khi băng tải ngoài cùng tầng dưới có tray trống
            _13_OUT_AGV_2_7,
            _13_OUT_AGV_2_8,

            _13_CV_INPUT,
            _13_CV_OUTPUT,
            _13_CV_INTRAY_LEFT_WORK,
            _13_CV_INTRAY_LEFT_INPUT_1,
            _13_CV_INTRAY_LEFT_INPUT_2,
            _13_CV_INTRAY_RIGHT_WORK,
            _13_CV_INTRAY_RIGHT_INPUT_1,
            _13_CV_INTRAY_RIGHT_INPUT_2,
            _13_CV_OUTTRAY_TRANSFER,
            _13_CV_OUTTRAY_LEFT_OUTPUT_1,
            _13_CV_OUTTRAY_LEFT_OUTPUT_2,
            _13_CV_OUTTRAY_RIGHT_OUTPUT_1,
            _13_CV_OUTTRAY_RIGHT_OUTPUT_2,
            _13_SPARE0,
            _13_IF_FRONT_BUSY,
            _13_IF_BEHIND_READY,
            #endregion

            OUT_MAX
        };
    }
}

Define/SystemDefine.cs
using Auto_Insert_Sim_Tray.Configs;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Auto_Insert_Sim_Tray.Define
{
    /**
     * @brief 물류 프로그램에서 정의하고자 하는 상수를 정의하는 클래스
     */
    public static class SystemDefine
    {
        // System define

        // TODO : Machine 이름 포함 경로로 수정 필요
        public static string systemEquipmentName = "INSERT SIM TRAY"; //MES, GEIM 등에 보낼 설비 명
        public static string rootPath = @"C:\FA\" + systemEquipmentName + @"\";
        public static string modelTag = "Model : ";
        //public static string pgmVersion = $"V 1.0_B {System.Diagnostics.FileVersionInfo.GetVersionInfo(System.Reflection.Assembly.GetExecutingAssembly().Location).ProductVersion}";
        public static string pgmVersion = "20252301.03";
        //public static string pgmTittle = System.Reflection.Assembly.GetExecutingAssembly().FullName.Split(',')[0];
        public static string groupName = "Automation Group";

        public const bool TEST_NONE_HW = false;
        public const int UI_TIMER_INTERVAL = 1000; //ms
        public const int MAX_DISPLAY_LOGLINE = 20;

        public const int MAX_QUEUE_TO_CALCULATION_TACKTIME = 100;

        //Màn hình chuẩn khi thiết kế trên laptop
        public static System.Drawing.Size monitorDesign = new System.Drawing.Size(1280, 768);

        public const int DELAY_TIME_SYSTEM_HW_MANAGER_THREAD_RUN = 20; //ms
        public const int DELAY_TIME_DEFAULT_PROC_THREAD_RUN = 20; //ms
        public const int DELAY_TIME_FOR_DRYRUN_THREAD_RUN = 200; //ms
        public const bool IsRunWithMachine = true;
        public static bool IsLoadingFinish = false;
        public static bool IsRun_No_PC_Test = false;

        // System 에러코드 
        #region system error code
        /*
         * System define error code : 수정가능
         */
        public const int ERROR_NOT_ALLOCATE = 0;
        public const int ERRCODE_NO_ERROR = -1000;
        public const int ERRCODE_STOP_YELLOW = 39578;

        public const int ERRCODE_EMO_PRESS = ((int)SystemEnum.ECODE.EMERGENCY_STOP);
        public const int ERRCODE_LIGHT_CURTAIN_ABOVE = ((int)SystemEnum.ECODE.LIGHT_CURTAIN_ABOVE);
        public const int ERRCODE_LIGHT_CURTAIN_BELOW = ((int)SystemEnum.ECODE.LIGHT_CURTAIN_BELOW);
        public const int ERRCODE_DOOR_OPEN = ((int)SystemEnum.ECODE.DOOR_OPEN);
        //public const int ERRCODE_DOOR_MC1_OPEN = ((int)SystemEnum.ECODE.DOOR_MC1_OPEN);
        //public const int ERRCODE_DOOR_MC2_OPEN = ((int)SystemEnum.ECODE.DOOR_MC2_OPEN);

        /*
         * System define error code : 삭제하지 말 것 
         * Json의 error code와 code 중복 사용하지 말 것
         */
        #endregion
        public const int ERRCODE_ETHERCAT_MASTER_NOT_FOUND = 30000;
        public const int ERRCODE_ETHERCAT_INIT_FAIL = 30001;
        public static int BUZZER_TIMEOUT = (int)(JsonHelper.Instance.delayTime.OnBuzzerTime * 1000); //ms - default 3sec
        public const int CHECK_IDLE_TIME = 60000; //ms - default 60sec
        public const int CHECK_OOS_TIME = 15000; //ms - default 15sec

        public enum MACHINE_TYPE
        {
            B,
            AC2,
            AC1
        }

        public enum HAND_NUM
        {
            NONE = -1,
            HAND1,
            HAND2,
            MAX,
        }
    }
}

Define/SystemEnum.cs
/* 
 * Copyright (C) Samsung Electronics Co., Ltd., Inc - All Rights Reserved
 * Unauthorized copying of this file, via any medium is strictly prohibited
 * Proprietary and confidential
 * 
 * Written by Donghyun Ko <dh79.ko@samsung.com>, June 2022
 * Written by Sanghyeon Lee <sirano06.lee@samsung.com>, June 2022
 * 
 */
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Auto_Insert_Sim_Tray.Define
{
    /**
     * @brief 물류 프로그램에서 정의하고자 하는 enum 들의 정의 클래스
     */
    public static class SystemEnum
    {
        /* 
         * @brief Operation의 mode
         * @todo 제어상의 mode는 설비의 컨셉과 동작에 맞게 수정하여 진행한다
         */
        public enum OP_MODE
        {
            NONE = -1,
            READY,
            INIT,
            RUN,
            RESET,
            STOP,
            E_STOP,
            SEMI_RUN,
            ORG_RUN,
            OPP,
        }

        /* 
         * @brief 설비 구동 mode
         */
        public enum RUN_MODE
        {
            NONE = -1,
            AUTO_RUN,
            DRY_RUN, //SET 없이 
            BY_PASS,
            MAX
        };

        public enum UNIT_TYPE
        {
            NONE = -1,
            TF_LD_SET,
            TF_ULD_SET,
            JIG_LEFT,
            JIG_RIGHT,
            INTRAY_LEFT,
            INTRAY_RIGHT,
            OUTTRAY_LEFT,
            OUTTRAY_RIGHT,
            ULD_TRAY_SIM,
            TF_OUTTRAY,
            ROBOT_XYZ,
            IN_CV,
            OUT_CV,
            NG_BUFFER,
            LEFT_INTRAY_CV,
            RIGHT_INTRAY_CV,
            LEFT_OUTTRAY_CV,
            RIGHT_OUTTRAY_CV,
            RELOAD_SIMTRAY

        }
        public enum SET_STATUS
        {
            None,
            OK,
            NG,
            Wait,
            NoBarCode,
            DifferinModel,
            Max
        }
        public enum SEMI_OPTION
        {
            NONE = -1,
            MOVE_TOP,
            MOVE_ON_JIG
        }
        public enum MAINFORM_EVENT
        {
            NONE = -1,
            EXIT_EVENT,
            HIDE_EVENT,
            RESIZE_EVENT,
        }

        public enum COM_LIST
        {
            NONE = 0,
            PC1,
            PC2,
            PC3,
            PC4,
            PC5,
            PC6,
        }
        public enum LIST_ETHERNET
        {
            NONE = -1,
            VISION_1,
            VISION_2,
        }
        //public enum BUFF_STATE
        //{
        //    NONE = -1,

        //    ATTACH_NG,
        //    ATTACH_OK,
        //    WAIT_PLACE,
        //    WAIT_ATTACH,
        //    DONE_ATTACH,
        //}

        public enum REQUEST_ACTION
        {
            NONE = -1,

            PICK,
            PLACE,
        }
        public enum TEST_RESULT
        {
            NONE = -1,
            TESTING,
            TEST_OK,
            TEST_NG,
            RF_INSERT_FAIL,
            RETEST,
        }

        /* 
        * Khai báo slot các Jig có trong máy
        */
       public enum Jig_Index
        {
            NONE = 0,
            JIG_LEFT,
            JIG_RIGHT,
        }
        /* 
         * @brief TactTime 계산용 enum
         */
        public enum TT_TYPE
        {
            NONE = -1,
            IN,
            OUT
        }

        /* 
         * @brief 검사 결과 enum
         */

        public enum COMPARE_RESULT
        {
            None,
            Khác,
            Nhỏ_Hơn,
            Bằng,
            Lớn_Hơn,
        }
        public enum ECODE
        {
            NONE = -1,
            WORK_SUCCESS,
            WORK_FAIL,

            RUN_WITHOUT_MACHINE,
            ACTION_DENIED,

            SERVO_NOT_CONNECTED,
            SERVO_OFF,
            SERVO_CHECK_ERROR_ALARM,
            SERVO_ORIGIN_NOT_DONE,
            SERVO_MOVING_NOW,
            COMPARE_POSITION_FAIL,
            SERVO_MOVING_INTERPOLATION_ERROR,
            Kiểm_Tra_Tín_Hiệu_Limit,


            #region System Part
            EMERGENCY_STOP = 1000,
            DOOR_OPEN,
            ORG_MODE_RUN_TIMEOUT,
            INITIALIZE_MODE_RUN_TIMEOUT,
            SEMI_MODE_RUN_TIMEOUT,
            LIGHT_CURTAIN_ABOVE,
            LIGHT_CURTAIN_BELOW,
            SENSOR_SAFETY_RELOAD_SIM_TRAY,
            TRAY_SIM_LEFT_REVERSE,
            TRAY_SIM_RIGHT_REVERSE,
            LD_SET_DROP_SET,
            ULD_SET_DROP_SET,
            LD_SET_AXIS_X_OFF,
            LD_SET_AXIS_X_ERRROR,
            ULD_SET_AXIS_X_OFF,
            ULD_SET_AXIS_X_ERRROR,
            ULD_TRAY_AXIS_X_OFF,
            ULD_TRAY_AXIS_X_ERRROR,
            ROBOT_XYZ_AXIS_X_OFF,
            ROBOT_XYZ_AXIS_X_ERRROR,
            ROBOT_XYZ_AXIS_Y_OFF,
            ROBOT_XYZ_AXIS_Y_ERRROR,
            ROBOT_XYZ_AXIS_Z_OFF,
            ROBOT_XYZ_AXIS_Z_ERRROR,
            TF_TRAYOUT_AXIS_Z_OFF,
            TF_TRAYOUT_AXIS_Z_ERRROR,

            #endregion

            #region LD SET
            LD_SET_SOL_UP_DOWN_ERROR = 2000,
            LD_SET_SOL_ROTATE_ERROR,
            LD_SET_SOL_GRIP_ERROR,
            LD_SET_X_AXIS_MOVE_TIMEOUT,
            LD_SET_X_AXIS_DANGEROUS,
            LD_SET_SOL_GRIP_UP_DOWN_ERROR,

            #endregion

            #region ULD SET
            ULD_SET_SOL_UP_DOWN_ERROR = 3000,
            ULD_SET_SOL_ROTATE_ERROR,
            ULD_SET_SOL_GRIP_ERROR,
            ULD_SET_SOL_NG_ERROR,
            ULD_SET_X_AXIS_MOVE_TIMEOUT,
            ULD_SET_X_AXIS_DANGEROUS,
            ULD_SET_SOL_GRIP_UP_DOWN_ERROR,
            #endregion

            #region JIG LEFT
            JIG_LEFT_SOL_IN_OUT_ERROR = 4000,
            JIG_LEFT_SOL_FLIP_ERROR,
            JIG_LEFT_SOL_ALIGN_HORIZONTAL_ERROR,
            JIG_LEFT_SOL_ALIGN_VERTICAL_ERROR,
            JIG_LEFT_SOL_ALIGN_SIM_ERROR,
            JIG_LEFT_DANGEROUS_TO_MOVE,
            #endregion

            #region JIG RIGHT
            JIG_RIGHT_SOL_IN_OUT_ERROR = 5000,
            JIG_RIGHT_SOL_FLIP_ERROR,
            JIG_RIGHT_SOL_ALIGN_HORIZONTAL_ERROR,
            JIG_RIGHT_SOL_ALIGN_VERTICAL_ERROR,
            JIG_RIGHT_SOL_ALIGN_SIM_ERROR,
            JIG_RIGHT_DANGEROUS_TO_MOVE,
            #endregion

            #region INTRAY LEFT
            INTRAY_LEFT_SOL_HOLD_ERROR = 6000,
            INTRAY_LEFT_SOL_SEPERATE_ERROR,
            INTRAY_LEFT_SOL_ELEVATOR_1_ERROR,
            INTRAY_LEFT_SOL_ELEVATOR_2_ERROR,
            INTRAY_LEFT_SOL_STOPPER_1_ERROR,
            INTRAY_LEFT_SOL_STOPPER_2_ERROR,
            INTRAY_LEFT_SOL_REMOVE_UP_DOWN_ERROR,
            INTRAY_LEFT_SOL_REMOVE_BW_FW_ERROR,
            INTRAY_LEFT_SOL_ALIGN_ERROR,
            INTRAY_LEFT_SOL_ALIGN_TOP_ERROR,
            #endregion

            #region INTRAY RIGHT
            INTRAY_RIGHT_SOL_HOLD_ERROR = 7000,
            INTRAY_RIGHT_SOL_SEPERATE_ERROR,
            INTRAY_RIGHT_SOL_ELEVATOR_1_ERROR,
            INTRAY_RIGHT_SOL_ELEVATOR_2_ERROR,
            INTRAY_RIGHT_SOL_STOPPER_1_ERROR,
            INTRAY_RIGHT_SOL_STOPPER_2_ERROR,
            INTRAY_RIGHT_SOL_REMOVE_UP_DOWN_ERROR,
            INTRAY_RIGHT_SOL_REMOVE_BW_FW_ERROR,
            INTRAY_RIGHT_SOL_ALIGN_ERROR,
            INTRAY_RIGHT_SOL_ALIGN_TOP_ERROR,
            #endregion

            #region ROBOT XYZ
            ROBOTXYZ_SOL_ROTATE_ERROR = 8000,
            ROBOTXYZ_SOL_TURN_ERROR,
            ROBOTXYZ_SOL_GRIP_ERROR,
            ROBOTXYZ_SOL_PUSH_FRONT_ERROR,
            ROBOTXYZ_SOL_PUSH_REAR_ERROR,
            ROBOTXYZ_SOL_CHECK_NG_ERROR,
            ROBOTXYZ_SOL_CHECK_GRIP_ERROR,
            ROBOTXYZ_X_AXIS_MOVE_TIMEOUT,
            ROBOTXYZ_Y_AXIS_MOVE_TIMEOUT,
            ROBOTXYZ_Z_AXIS_MOVE_TIMEOUT,
            INSERT_TRAY_SIM_FAIL_JIG_LEFT,
            INSERT_TRAY_SIM_FAIL_JIG_RIGHT,
            ROBOTXYZ_GRIP_TRAY_SIM_FAIL,
            #endregion

            #region OUT TRAY
            OUT_TRAY_SOL_TRANSFER_FRONT_ERROR = 9000,
            OUT_TRAY_SOL_TRANSFER_REAR_ERROR,
            OUT_TRAY_SOL_REMOVE_ERROR,
            OUT_TRAY_SOL_PUSH_ERROR,
            OUT_TRAY_SOL_TRANSFER_STOPPER_ERROR,
            OUT_TRAY_SOL_LEFT_STOPPER_1_ERROR,
            OUT_TRAY_SOL_LEFT_STOPPER_2_ERROR,
            OUT_TRAY_SOL_RIGHT_STOPPER_1_ERROR,
            OUT_TRAY_SOL_RIGHT_STOPPER_2_ERROR,
            OUT_TRAY_Z_AXIS_MOVE_TIMEOUT,
            #endregion

            #region ULD TRAY + NG SHUTTLE + RELOAD
            NG_SHUTTLE_SOL_FW_BW_ERROR = 10000,
            RELOAD_SIM_R_AXIS_ERROR,
            UNLOAD_TRAY_SOL_UP_DOWN_ERROR,
            UNLOAD_TRAY_SOL_GRIP_ERROR,
            UNLOAD_TRAY_X_AXIS_MOVE_TIMEOUT,
            #endregion
        }

        //public enum NOTICECODE
        //{
        //    NONE,

        //    #region Transfer
        //    Servo_X_TRANSFER_Chưa_On,
        //    Servo_X_TRANSFER_Bị_Lỗi,
        //    Kiểm_Tra_Xy_Lanh_LD_Cylinder_Down,
        //    Kiểm_Tra_Xy_Lanh_ULD_Cylinder_Down,
        //    #endregion

        //    #region MC1
        //    Servo_Y_MC1_JIG1_Chưa_On,
        //    Servo_Y_MC1_JIG1_Bị_Lỗi,
        //    Servo_Y_MC1_JIG2_Chưa_On,
        //    Servo_Y_MC1_JIG2_Bị_Lỗi,
        //    Servo_R_MC1_Chưa_On,
        //    Servo_R_MC1_Bị_Lỗi,
        //    Kiểm_Tra_Xy_Lanh_JIG1,
        //    Kiểm_Tra_Xy_Lanh_JIG2,
        //    #endregion

        //    #region MC2
        //    Servo_Y_MC2_JIG1_Chưa_On,
        //    Servo_Y_MC2_JIG1_Bị_Lỗi,
        //    Servo_Y_MC2_JIG2_Chưa_On,
        //    Servo_Y_MC2_JIG2_Bị_Lỗi,
        //    Servo_R_MC2_Chưa_On,
        //    Servo_R_MC2_Bị_Lỗi,
        //    #endregion
        //}

        //public enum ORG_X_Step
        //{
        //    _1_Check,
        //    _2_SOL_Up,
        //    _3_Org_X_SOL_return,
        //    _4_Finish,
        //}
        //public enum ORG_Y_Step
        //{
        //    _1_Check,
        //    _2_J1_Up_J2_Down,
        //    _3_Up_Vinyl,
        //    _4_Org_Y_Unalign,
        //    _5_Finish,
        //}
        //public enum ORG_NG_Step
        //{
        //    _1_Check,
        //    _2_SOL_Down,
        //    _3_SOL_FW,
        //    _4_Finish,
        //}

        //public enum Initial_X_Step
        //{
        //    _1_Check,
        //    _2_SOL_Up,
        //    _3_Org_X_SOL_return,
        //    _4_Finish,
        //}
        //public enum Initial_Y_Step
        //{
        //    _1_Check,
        //    _2_J1_Up_J2_Down,
        //    _3_Up_Vinyl,
        //    _4_Move_Y,
        //    _5_J1_Up_J2_Down,
        //    _6_Finish
        //}
        //public enum Initial_NG_Step
        //{
        //    _1_Check,
        //    _2_SOL_Down,
        //    _3_SOL_FW,
        //    _4_Finish,
        //}

        //public enum Semi_X_Step
        //{
        //    _1_Check,
        //    _2_SOL_Up,
        //    _3_Move_X_SOL,
        //    _4_SOL_turn_return,
        //    _5_SOL_Down,
        //    _6_Finish,
        //}
        //public enum Semi_Lifter_Step
        //{
        //    _1_Check,
        //    _2_Move_Z,
        //    _3_Finish,
        //}
        //public enum Semi_Z_NG_Step
        //{
        //    _1_Check,
        //    _2_Move_Z,
        //    _3_Finish,
        //}

        //public enum Auto_Transfer_X
        //{
        //    _1_Check,

        //    _2_MoveX_SOL_Turn_Return_Ungrip,
        //    _3_Wait_Done_Handle,
        //    _4_Reset,

        //}
        //public enum Auto_Handle
        //{
        //    _1_Check,

        //    _2_Pick,
        //    _2_1_SOL_Down,
        //    _2_2_SOL_Grip,
        //    _2_3_SOL_Up,
        //    _2_4_Done_Pick,

        //    _3_Place,
        //    _3_1_SOL_Down,
        //    _3_2_SOL_Ungrip,
        //    _3_3_SOL_Up,
        //    _3_4_Done_Place,
        //}
        //public enum Auto_Jig_Attach
        //{
        //    _1_Check,

        //    _2_Swap_Jig,
        //    _2_1_Move_Y_Clean_End,
        //    _2_2_Jig_Down,
        //    _2_3_Move_Y_Ld_Uld,
        //    _2_4_Done_Swap_Jig,

        //    _3_Attach,
        //    _3_1_Align,
        //    _3_2_Move_Y_Clean_Start,
        //    _3_3_Clean_Down,
        //    _3_4_Move_Y_Clean_End,
        //    _3_5_Move_Y_Attach_Start,
        //    _3_6_Attach_Down,
        //    _3_7_Move_Y_R_Attach_End,
        //    _3_8_Jig_Down_All_SOL_Up,
        //    _3_9_Move_Y_Ld_Uld,
        //    _3_10_Done_Attach,

        //    _4_Unload,
        //    _4_1_Jig_Up_Unalign,
        //    _4_2_Done_Unload,
        //}
        //public enum Auto_R_Attach
        //{
        //    _1_Check,
        //    _2_Detect_Hole,
        //    _3_Detect_Vinyl,
        //    _4_Move_R_Attach_Start,
        //    _5_Wait_R_Attach_End,
        //    _6_Reset,
        //}
        //public enum Auto_Z_NG_Step
        //{
        //    _1_Check,

        //    _2_MoveZ_To_CV_Offset,
        //    _3_MoveZ_To_CV_OnVC,
        //    _4_MoveZ_To_Buff_NG_Offset,
        //    _5_SOL_FW,
        //    _6_MoveZ_To_Buff_NG_OffVC,
        //    _7_MoveZ_To_Wait_SOL_BW,

        //    _8_Reset,

        //}
        public enum Auto_In_CV_Step
        {
            Check,

            CV_Run_To_SS_Mid,
            CV_Run_To_SS_Out,
            CV_Stop_Take_Barcode,

            CV_Stop,
        }
        public enum Auto_Out_CV_Step
        {
            Check,
            Check_MC_Behind,
            CV_Run_To_SS_Out,
            CV_Run_To_MC_Behind,
            CV_Stop,
        }
        public enum ORG_Input_CV_Left
        {
            _1_Check,
            _2_Sol_Down,
            _3_Finish,
        }
        public enum Initial_Input_CV_Left
        {
            _1_Check,
            _2_Sol_Down,
            _3_Finish,
        }
        public enum Auto_Input_CV_Left
        {
            _1_1_Check_CV_1,
            _1_2_Sol_Stopper_1_Up,
            _1_3_Sol_Stopper_1_Down,
            _1_4_Run_Input_CV_1,
            _1_5_Stop_Input_CV_1,

            _2_1_Check_CV_2,
            _2_2_Sol_Stopper_2_Up,
            _2_3_Sol_Stopper_2_Down,
            _2_4_Run_Input_CV_2,
            _2_5_Stop_Input_CV_2,
        }
        public enum ORG_Input_CV_Right
        {
            _1_Check,
            _2_Sol_Down,
            _3_Finish,
        }
        public enum Initial_Input_CV_Right
        {
            _1_Check,
            _2_Sol_Down,
            _3_Finish,
        }
        public enum Auto_Input_CV_Right
        {
            _1_1_Check_CV_1,
            _1_2_Sol_Stopper_1_Up,
            _1_3_Sol_Stopper_1_Down,
            _1_4_Run_Input_CV_1,
            _1_5_Stop_Input_CV_1,

            _2_1_Check_CV_2,
            _2_2_Sol_Stopper_2_Up,
            _2_3_Sol_Stopper_2_Down,
            _2_4_Run_Input_CV_2,
            _2_5_Stop_Input_CV_2,
        }
        public enum ORG_Outtray_CV_Left
        {
            _1_Check,
            _2_Sol_Down,
            _3_Finish,
        }
        public enum Initial_Outtray_CV_Left
        {
            _1_Check,
            _2_Sol_Down,
            _3_Finish,
        }
        public enum Auto_Outtray_CV_Left
        {
            _1_1_Check_CV_1,
            _1_2_Sol_Stopper_1_Up,
            _1_3_Sol_Stopper_1_Down,
            _1_4_Run_Outtray_CV_1,
            _1_5_Stop_Outtray_CV_1,

            _2_1_Check_CV_2,
            _2_2_Sol_Stopper_2_Up,
            _2_3_Sol_Stopper_2_Down,
            _2_4_Run_Outtray_CV_2,
            _2_5_Stop_Outtray_CV_2,
        }
        public enum ORG_Outtray_CV_Right
        {
            _1_Check,
            _2_Sol_Down,
            _3_Finish,
        }
        public enum Initial_Outtray_CV_Right
        {
            _1_Check,
            _2_Sol_Down,
            _3_Finish,
        }
        public enum Auto_Outtray_CV_Right
        {
            _1_1_Check_CV_1,
            _1_2_Sol_Stopper_1_Up,
            _1_3_Sol_Stopper_1_Down,
            _1_4_Run_Outtray_CV_1,
            _1_5_Stop_Outtray_CV_1,

            _2_1_Check_CV_2,
            _2_2_Sol_Stopper_2_Up,
            _2_3_Sol_Stopper_2_Down,
            _2_4_Run_Outtray_CV_2,
            _2_5_Stop_Outtray_CV_2,
        }

        public enum ORG_TF_LD_SET
        {
            _1_Check,
            _2_Sol_Up,
            _3_Move_X,
            _4_Rotate_Middle,
            _5_Finish,
        }
        public enum Initial_TF_LD_SET
        {
            _1_Check,
            _2_Sol_Up,
            _3_Move_X,
            _4_Rotate_Middle,
            _5_Finish,
        }
        public enum Auto_TF_LD_SET
        {
            _1_Check,
            _1_2_Check_Pos_Pick,
            _1_3_Pick,
            _1_4_Check_Pos_Place,
            _1_5_Place,
            _1_6_Reset,

            _2_Pick_In_CV,
            _2_1_MoveX_Input,
            _2_2_Rotate_Middle,
            _2_3_Sol_Down,
            _2_4_Sol_Down_Clamp,
            _2_5_Sol_Clamp_On,
            _2_6_Sol_Up_Clamp,
            _2_7_Sol_Up,
            _2_8_Sol_Rotate_Auto,
            _2_9_MoveX_Wait,
            _2_10_Return,

            _3_Place_In_Jig,
            _3_2_MoveX_Jig_Left_And_Rotate,
            _3_3_MoveX_Jig_Right_And_Rotate,
            _3_4_Sol_Down_Clamp,
            _3_5_Sol_Clamp_Off,
            _3_6_Sol_Up_Clamp,
            _3_7_MoveX_Wait_And_Rotate,
            _3_8_Return,
        }
        public enum Semi_TF_LD_SET
        {
            _1_Check,
            _2_Sol_Clamp_On,
            _3_Sol_Up,
            _4_Move_X,
            _5_Finish,

        }

        public enum ORG_TF_ULD_SET
        {
            _1_Check,
            _2_Sol_Up,
            _3_Sol_NG_Pos_OK,
            _4_Move_X,
            _5_Rotate_Middle,
            _6_Finish,
        }
        public enum Initial_TF_ULD_SET
        {
            _1_Check,
            _2_Sol_Up,
            _3_Sol_NG_Pos_OK,
            _4_Move_X,
            _5_Rotate_Middle,
            _6_Finish,
        }
        public enum Auto_TF_ULD_SET
        {
            _1_Check,
            _1_2_Check_Pos_Pick,
            _1_3_Pick,
            _1_4_Check_Pos_Place,
            _1_5_Place,
            _1_6_Reset,

            _2_Pick_In_Jig,
            _2_2_MoveX_Jig_Left_And_Rotate,
            _2_3_MoveX_Jig_Right_And_Rotate,
            _2_4_Sol_Down_Clamp,
            _2_5_Sol_Clamp_On,
            _2_6_Sol_Up_Clamp,
            _2_7_MoveX_Wait_And_Rotate,
            _2_8_Return,

            _3_Place,
            _3_2_MoveX_CV_Out,
            _3_3_MoveX_NG,
            _3_4_Sol_NG_Pos_NG,
            _3_5_Sol_Down,
            _3_6_Sol_Down_Clamp,
            _3_7_Sol_Clamp_Off,
            _3_8_Sol_Up_Clamp,
            _3_9_Sol_Up,
            _3_10_Sol_NG_Pos_OK,
            _3_11_MoveX_Wait,
            _3_12_Return,

        }
        public enum Semi_TF_ULD_SET
        {
            _1_Check,
            _2_Sol_Clamp_On,
            _3_Sol_Up,
            _4_Sol_NG_Pos_OK,
            _5_Move_X,
            _6_Finish,

        }

        public enum ORG_Jig_Left
        {
            _1_Check,
            _2_Sol_Flip_Up,
            _3_Sol_Pos_Out,
            _4_Finish,
        }
        public enum Initial_Jig_Left
        {
            _1_Check,
            _2_Sol_Flip_Up,
            _3_Sol_Pos_Out,
            _4_UnAlign,
            _5_Finish,
        }
        public enum Auto_Jig_Left
        {
            _1_Check,
            _1_2_SET_OK,
            _1_3_SET_NG,

            _2_Insert_Sim_Tray,
            _2_2_Sol_Align_Hor_1,
            _2_3_Sol_Align_Ver,
            _2_4_Sol_Align_Hor_Sim,
            _2_5_Sol_Move_In,
            _2_6_Sol_Unalign_Sim,
            _2_7_Sol_Move_Out,
            _2_8_Sol_Unalign_Hor_Ver,
            _2_9_Finish,

            _3_SET_NG_Or_By_Pass,
            _3_2_Sol_Align_Hor_1,
            _3_3_Sol_Align_Ver,
            _3_4_Sol_Align_Hor,
            _3_5_Sol_Unalign_Hor_Ver,
            _3_6_Finish,

        }

        public enum ORG_Jig_Right
        {
            _1_Check,
            _2_Sol_Flip_Up,
            _3_Sol_Pos_Out,
            _4_Finish,
        }
        public enum Initial_Jig_Right
        {
            _1_Check,
            _2_Sol_Flip_Up,
            _3_Sol_Pos_Out,
            _4_UnAlign,
            _5_Finish,
        }
        public enum Auto_Jig_Right
        {
            _1_Check,
            _1_2_SET_OK,
            _1_3_SET_NG,

            _2_Insert_Sim_Tray,
            _2_2_Sol_Align_Hor_1,
            _2_3_Sol_Align_Ver,
            _2_4_Sol_Align_Hor_Sim,
            _2_5_Sol_Move_In,
            _2_6_Sol_Unalign_Sim,
            _2_7_Sol_Move_Out,
            _2_8_Sol_Unalign_Hor_Ver,
            _2_9_Finish,

            _3_SET_NG_Or_By_Pass,
            _3_2_Sol_Align_Hor_1,
            _3_3_Sol_Align_Ver,
            _3_4_Sol_Align_Hor,
            _3_5_Sol_Unalign_Hor_Ver,
            _3_6_Finish,

        }

        public enum Initial_Intray_Left
        {
            _1_Check,
            _2_Sol_Unalign_Tray,
            _3_Sol_Remove_Down,
            _4_Sol_Remove_BW,
            _5_Sol_Elevator_2_FW,
            _6_Sol_Separate_Off,
            _7_Sol_Hold_Off,
            _8_Sol_Elevator_1_FW,
            _9_Sol_Separate_Off_2,
            _10_Finish,
        }
        public enum Auto_Intray_Left
        {
            _1_Check_Intray,
            _1_2_Split_Tray,
            _1_3_Transfer_Tray_To_Work,
            _1_4_Transfer_Tray_To_Align,

            _2_Transfer_Tray_To_Work,
            _2_2_Check_Tray,
            _2_3_Run_CV_Work,
            _2_4_Stop_CV_Work,
            _2_5_Finish,

            _3_Transfer_Tray_To_Align,
            _3_2_Sol_Hold_On,
            _3_3_Sol_Elevator_2_BW,
            _3_4_Sol_Separate_On,
            _3_5_Sol_Elevator_1_BW,
            _3_6_Sol_Hold_Off,
            _3_7_Sol_Remove_Up,
            _3_8_Sol_Remove_FW,
            _3_9_Sol_Elevator_1_FW,
            _3_10_Sol_Elevator_2_FW,
            _3_11_Sol_Separate_Off,
            _3_12_Finish,

            _4_Check_Align,
            _4_2_Sol_Align,
            _4_2_1_Sol_Unalign,
            _4_2_2_Sol_Align,
            _4_3_Sol_Unalign,
            _4_4_Sol_Remove_Down,
            _4_5_Sol_Remove_BW,
            _4_6_Finish,

        }

        public enum Initial_Intray_Right
        {
            _1_Check,
            _2_Sol_Unalign_Tray,
            _3_Sol_Remove_Down,
            _4_Sol_Remove_BW,
            _5_Sol_Elevator_2_FW,
            _6_Sol_Separate_Off,
            _7_Sol_Hold_Off,
            _8_Sol_Elevator_1_FW,
            _9_Sol_Separate_Off_2,
            _10_Finish,
        }
        public enum Auto_Intray_Right
        {
            _1_Check_Intray,
            _1_2_Split_Tray,
            _1_3_Transfer_Tray_To_Work,
            _1_4_Transfer_Tray_To_Align,

            _2_Transfer_Tray_To_Work,
            _2_2_Check_Tray,
            _2_3_Run_CV_Work,
            _2_4_Stop_CV_Work,
            _2_5_Finish,

            _3_Transfer_Tray_To_Align,
            _3_2_Sol_Hold_On,
            _3_3_Sol_Elevator_2_BW,
            _3_4_Sol_Separate_On,
            _3_5_Sol_Elevator_1_BW,
            _3_6_Sol_Hold_Off,
            _3_7_Sol_Remove_Up,
            _3_8_Sol_Remove_FW,
            _3_9_Sol_Elevator_1_FW,
            _3_10_Sol_Elevator_2_FW,
            _3_11_Sol_Separate_Off,
            _3_12_Finish,

            _4_Check_Align,
            _4_2_Sol_Align,
            _4_2_1_Sol_Unalign,
            _4_2_2_Sol_Align,
            _4_3_Sol_Unalign,
            _4_4_Sol_Remove_Down,
            _4_5_Sol_Remove_BW,
            _4_6_Finish,

        }

        public enum ORG_ULD_Tray
        {
            _1_Check,
            _2_Sol_Up,
            _3_Move_X,
            _4_Finish,
        }
        public enum Initial_ULD_Tray
        {
            _1_Check,
            _2_Sol_Up,
            _3_MoveX_Wait,
            _4_Finish,
        }
        public enum Auto_ULD_Tray
        {
            _1_Check,
            _1_2_Check_Pos_Pick,
            _1_3_Pick,
            _1_4_Check_Pos_Place,
            _1_5_Place,

            _2_Pick_Tray,
            _2_2_Pick_Tray_Left,
            _2_3_Pick_Tray_Right,
            _2_4_Sol_Down,
            _2_5_Sol_Clamp_On,
            _2_6_Sol_Up,
            _2_7_Finish,

            _3_MoveX_Place_Tray,
            _3_2_Sol_Down,
            _3_3_Sol_Clamp_Off,
            _3_4_Sol_Up,
            _3_5_MoveX_Wait,
            _3_6_Finish,

        }
        public enum Semi_ULD_Tray
        {
            _1_Check,
            _2_Sol_Up,
            _3_Move_X,
            _4_Finish,
        }
        public enum ORG_TF_OutTray
        {
            _1_Check,
            _2_Move_Z,
            _3_Finish,
        }
        public enum Initial_TF_OutTray
        {
            _1_Check,
            _2_Sol_Remove_BW,
            _3_Sol_Push_Down,
            _4_MoveZ_Input_Tray,
            _5_Sol_Transfer_FW,
            _6_Finish,
        }
        public enum Auto_TF_OutTray
        {
            #region Lifter
            _1_Check_Axix_Z,
            _1_2_Off_Set_Input,
            _1_3_MoveZ_Input,
            _1_4_MoveZ_Output,
            _1_5_MoveZ_Wait,
            #endregion

            #region Transfer
            _2_Check_Transfer,
            _2_2_Sol_Transfer_Fornt_BW,
            _2_3_Sol_Push_Up,
            _2_4_Sol_Remove_FW,
            _2_5_Sol_Remove_BW,
            _2_6_Sol_Push_Down,
            _2_7_Sol_Transfer_Front_FW,
            _2_8_Finish,
            #endregion

            #region CV
            _3_Check_CV,
            _3_2_Sol_Transfer_Rear_FW,
            _3_3_Sol_Transfer_Rear_BW,
            _3_4_Sol_Stopper_Up,
            _3_5_Sol_Stopper_Down,
            _3_6_CV_Run,
            _3_7_CV_Stop,
            #endregion

        }
        public enum Semi_TF_OutTray
        {
            _1_Check,
            _2_Move_Z,
            _3_Finish,
        }

        public enum Initial_NG_Shuttle
        {
            _1_Check,
            _2_Sol_Down,
            _3_Sol_FW,
            _4_Finish,
        }
        public enum Auto_NG_Shuttle
        {
            _1_Check,
            _1_2_Run_NG_Shuttle,
            _1_3_Sol_Up,
            _1_4_Sol_BW,
            _1_5_Sol_Down,
            _1_6_Sol_FW,
            _1_7_Fisnish,
        }

        public enum ORG_RobotXYZ
        {
            _1_Check,
            _2_Sol_Push_Up,
            _3_MoveZ,
            _4_MoveY,
            _5_MoveX,
            _6_Finish,
        }
        public enum Initial_RobotXYZ
        {
            _1_Check,
            _2_Sol_Push_Up,
            _3_MoveZ_Wait,
            _4_MoveY_MoveX_Wait ,
            _5_MoveX_Wait,
            _6_Finish,
        }
        public enum Auto_RobotXYZ
        {
            _1_Check,
            _1_2_Check_Pick_Sim_Tray,
            _1_3_Pick_Sim_Tray,
            _1_4_Check_Insert_Sim_Tray,
            _1_5_Insert_Sim_Tray,
            _1_6_Check_Vision,
            _1_7_Vision,

            _2_Pick,
            _2_2_Move_Pick_Up,
            _2_3_Sol_Rotate_Off_and_Turn_On, // khong dung
            _2_4_Move_Pick_Down,
            _2_5_Sol_Grip_On,
            _2_6_MoveZ_Pick_Up,
            _2_7_Sol_Turn_Off,
            _2_8_Move_Wait,
            _2_9_Finish,

            _3_Place,
            _3_2_Move_Place_Up,
            _3_3_Sol_Rotate_Off,
            _3_4_Move_Place_Down_1,
            _3_5_Sol_Push_Down_Rear,
            _3_6_Sol_Push_Up_Rear_and_Grip_Off,
            _3_6_1_Sol_Push_Up_Rear_NG,
            _3_7_Move_Place_Down_2,
            _3_8_Sol_Push_Down_Front,
            _3_9_Sol_Push_Up_Front,
            _3_10_MoveZ_Jig_Insert_Up,
            _3_11_Move_Wait,
            _3_12_Finish,

            _4_Vision,
            _4_2_Move_Wait_Check_Vision_Left,
            _4_3_Grab_Vision_Left,
            _4_4_Move_Wait_Check_Vision_Right,
            _4_5_Grab_Vision_Right,
            _4_6_Move_Wait,
            _4_7_Finish,

            _5_NG,
            _5_1_Move_NG_Up,
            _5_2_Move_NG_Down,
            _5_3_Move_NG_Up,
            _5_4_Move_Wait,
            _5_5_Finish,

        }
        public enum Semi_RobotXYZ
        {
            _1_Check,
            _2_Sol_Push_Up,
            _3_MoveZ_Wait,
            _4_MoveY_MoveX,
            _4_1_MoveZ,
            _5_Finish,
        }
    }
}

HW/BarcodeReader/BarcodeReader.cs
using Auto_Insert_Sim_Tray.Communication;
using Auto_Insert_Sim_Tray.Configs;
using Auto_Insert_Sim_Tray.Configs.Model;
using Auto_Insert_Sim_Tray.Utils;
using HControlCSharp.Utils;
using System;
using System.Diagnostics;
using System.Text;
using System.Threading;
using System.Windows.Forms;

namespace Auto_Insert_Sim_Tray.HW.BarcodeReader
{
    public class BarcodeReader : Serial
    {
        private uint _dataLength = 10;
        private bool _isScanning = false;
        private string _strReceive = String.Empty;
        private bool _isReadFail = false;
        private string _readCommand = String.Empty;
        private uint _curRetry = 0;
        private string _newLine = "\r\n";
        protected byte ETX = 0;
        protected byte STX = 0;

        public BarcodeReaderConfig BarcodeReaderConfig;


        private readonly object _lockObject = new object();/*
        private EventHandler<SerialDataEventArgs> SerialReceivedHandler = null;
        public event EventHandler DataUpdated;*/

        private bool _isConnected { get; set; }
        public uint DataLength { get => _dataLength; private set => _dataLength = value; }
        public bool IsScanning { get => _isScanning; private set => _isScanning = value; }
        public string DataReceive
        {
            get
            {
                return _strReceive;
            }
            private set => _strReceive = value;
        }
        public bool IsReadFail { get => _isReadFail; private set => _isReadFail = value; }
        public uint RetryRead => BarcodeReaderConfig.RetryRead;
        public uint TimeoutRead => (uint)BarcodeReaderConfig.serialPortModel.ReadTimeout;
        public string ReadCommand { get => _readCommand; set => _readCommand = value; }
        public bool IsConnected => _isConnected;
        //public BarcodeReader(SerialPortModel serialPortModel, BarcodeReaderConfig config) : base(serialPortModel)
        //{

        //    if (!ValidationDataConfi(config))
        //        MessageBox.Show("Barcode config not vaild? ", "Barcode Notice", MessageBoxButtons.OKCancel, MessageBoxIcon.Warning, MessageBoxDefaultButton.Button1/*, MessageBoxOptions.DefaultDesktopOnly*/) == DialogResult.Cancel
        //        //DisplayUtil.ShowNotice("Barcode config not vaild", UI.Popup.NoticeBox.Query.Warning);

        //    DataLength = config.DataLength;
        //    //TimeoutRead = (uint)config.serialPortModel.ReadTimeout;
        //    ReadCommand = config.ReadCommand;
        //    //RetryRead = config.RetryRead;

        //    Connect();
        //    SerialReceivedHandler = new EventHandler<SerialDataEventArgs>(Serial_DataRecieved);
        //    SerialDataRecieved += SerialReceivedHandler;
        //}
        public BarcodeReader(BarcodeReaderConfig config) : base(config.serialPortModel)
        {
            BarcodeReaderConfig = config;
            if (!ValidationDataConfi(BarcodeReaderConfig))
                //DisplayUtil.ShowNotice("Barcode config not vaild", UI.Popup.NoticeBox.Query.Warning);

            DataLength = BarcodeReaderConfig.DataLength;
            //TimeoutRead = (uint)config.serialPortModel.ReadTimeout;
            ReadCommand = BarcodeReaderConfig.ReadCommand;
            //RetryRead = BarcodeReaderConfig.RetryRead;

            Connect();
            SerialReceivedHandler = new EventHandler<SerialDataEventArgs>(Serial_DataRecieved);
            SerialDataRecieved += SerialReceivedHandler;
        }
        private bool ValidationDataConfi(BarcodeReaderConfig config)
        {
            if (config.serialPortModel is null)
                return false;
            if (config.DataLength <= 0)
                return false;
            /*if (config.serialPortModel.ReadTimeout <= 0)
                return false;*/
            if (config.RetryRead <= 0)
                return false;
            if (String.IsNullOrWhiteSpace(config.ReadCommand))
                return false;
            return true;
        }
        private bool ValidationDataReceive(string data)
        {
            if (String.IsNullOrWhiteSpace(data))
                return false;
            if (!data.EndsWith("\n")) return false;
            data = data.Substring(0, data.IndexOf("\n"));
            if (DataLength > 0)
            {
                if (data.Length != DataLength) return false;
            }
            return true;

        }
        private void Serial_DataRecieved(object sender, SerialDataEventArgs e)
        {
            DataReceive += Encoding.ASCII.GetString(e._data);
            //DataUpdated?.Invoke(this, null);
            base.DataUpdate(this, e);
        }
        public bool Connect()
        {
            _isConnected = base.Open();
            return _isConnected;
        }
        public bool Disconnect()
        {
            _isConnected = !base.Close();
            return _isConnected;
        }
        private void Write()
        {
            _curRetry++;
            DataReceive = null;
            Send(ReadCommand/* + _newLine*/);
        }
        //private void Write(string data)
        //{
        //    _curRetry++;
        //    DataReceive = null;
        //    ReadCommand = data;
        //    Send(data + _newLine);
        //}
        public void Trigger()
        {
            lock (this)
            {
                if (!IsOpen)
                {
                    //DisplayUtil.ShowNotice($"Port {mSerialPortData.PortName} not connect", UI.Popup.NoticeBox.Query.Warning);
                    //if (MessageBox.Show("Scanner Barcode not connect ", "Scanner", MessageBoxButtons.OKCancel, MessageBoxIcon.Warning) == DialogResult.Cancel)
                    if (MessageBox.Show("Scanner Barcode not connect ", "Scanner", MessageBoxButtons.OKCancel, MessageBoxIcon.Warning) == DialogResult.Cancel)
                    {
                        return;
                    }
                }
                if (!_isConnected)
                {
                    //DisplayUtil.ShowNotice($"Port {mSerialPortData.PortName} not connect", UI.Popup.NoticeBox.Query.Warning);
                    if (MessageBox.Show("Scanner Barcode not connect ", "Scanner", MessageBoxButtons.OKCancel, MessageBoxIcon.Warning) == DialogResult.Cancel)
                    {
                        return;
                    }
                }
                if (IsScanning)
                {
                    return;
                }
                DataReceive = null;
                IsScanning = true;
                IsReadFail = false;
                _curRetry = 0;
                Thread th = new Thread(() =>
                {
                Loop:
                    Stopwatch watch = Stopwatch.StartNew();
                    Write();
                    bool check = false;
                    while (!check
                            && watch.ElapsedMilliseconds < TimeoutRead)
                    {
                        check = ValidationDataReceive(DataReceive);
                        Thread.Sleep(100);
                        continue;
                    }
                    if (_curRetry < RetryRead && !check)
                        goto Loop;
                    if (!check) IsReadFail = true;
                    else
                        IsReadFail = false;
                    IsScanning = false;
                });
                th.Start();
            }
        }
        public new void Dispose()
        {
            SerialDataRecieved -= SerialReceivedHandler;
            SerialReceivedHandler = null;

            base.Dispose();
        }
    }

    public class BarcodeReaderConfig
    {
        public uint DataLength { set; get; } = 10;
        public string ReadCommand { get; set; } = "T";
        public uint RetryRead { get; set; } = 3;
        public string NewLine { get; set; } = "\r\n";

        public SerialPortModel serialPortModel = new SerialPortModel();
    }
    public enum Baurate : int
    {
        None = -1,
        N9600 = 9600,
        N115200 = 115200
    }
}

HW/Common/TowerLamp.cs
using Auto_Insert_Sim_Tray.Define;
using Auto_Insert_Sim_Tray.HW.Interface;
using Auto_Insert_Sim_Tray.Manager;
using Auto_Insert_Sim_Tray.Utils;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using static Auto_Insert_Sim_Tray.Define.IODefine;
using static Auto_Insert_Sim_Tray.Define.LogDefine;
using static Auto_Insert_Sim_Tray.Define.SystemEnum;
using Timer = System.Timers.Timer;

namespace Auto_Insert_Sim_Tray.HW.Common
{
    /**
     * @brief Tower Lamp 색상 종류
     */
    public enum TOWERLAMP_MODE
    {
        MANUAL,
        AUTO,
        ERROR,
        OPP,
        OP_CALL,
        IDLE
    }
    public enum TOWERLAMP_ELEMENT
    {
        NONE = 0,
        G_R_Y,
        G,
        R,
        Y,
        G_R,
        G_Y,
        R_Y,

        NONE_B = 10,
        G_R_Y_B,
        G_B,
        R_B,
        Y_B,
        G_R_B,
        G_Y_B,
        R_Y_B
    }
    /**
     * @brief Tower Lamp 데이터 클래스
     * @details Tower Lamp에 연결되어 있는 IO의 데이터 클래스
     */
    public class TowerLampData
    {
        public object outG { get; set; }
        public object outY { get; set; }
        public object outR { get; set; }
        public object outBuzzer { get; set; }

        /**
         * @brief Tower Lamp 데이터 클래스 생성자
         * @param[in] green 녹색등에 연결된 IO
         * @param[in] yellow 황색등에 연결된 IO
         * @param[in] red 적색등에 연결된 IO
         * @param[in] buzzer buzzer에 연결된 IO
         */
        public TowerLampData(object green, object yellow, object red, object buzzer)
        {
            outG = green;
            outY = yellow;
            outR = red;
            outBuzzer = buzzer;
        }
    }

    /**
     * @brief TowerLamp 동작 제공 클래스
     */
    public class TowerLamp
    {
        private IIO iIO;
        private TowerLampData towerData;
        public Timer elapsedTimer;

        /**
         * @brief TowerLamp 클래스 생성자
         * @param[in] io IO interface
         * @param[in] data TowerLamp에 연결된 IO를 가진 data 클래스
         */
        public TowerLamp(IIO io, TowerLampData data)
        {
            InitializeVariable(io, data);
        }

        /**
         * @brief 변수 초기화 함수
         * @param[in] io IO interface
         * @param[in] data TowerLamp에 연결된 IO를 가진 data 클래스
         */
        private void InitializeVariable(IIO io, TowerLampData data)
        {
            iIO = io;
            towerData = data;
            elapsedTimer = new Timer();
            elapsedTimer.Interval = SystemDefine.BUZZER_TIMEOUT;
            elapsedTimer.AutoReset = false;
            elapsedTimer.Elapsed += ElapsedTimer_Elapsed;
        }

        /**
         * @brief TowerLamp 색상 출력
         * @param[in] element TOWERLAMP_ELEMT로, TOWER LAMP 색상에 관한 정의
         */
        public void SetTowerLampColor(TOWERLAMP_ELEMENT element)
        {
            if (towerData?.outG == null || towerData?.outR == null || towerData?.outY == null)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, "Please check tower lamp IO assign", CONTENT_TYPE.ERROR);
                return;
            }

            if (iIO == null)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, "Please assign IO interface", CONTENT_TYPE.ERROR);
                return;
            }

            switch (element)
            {
                case TOWERLAMP_ELEMENT.G:
                case TOWERLAMP_ELEMENT.G_B:
                    iIO.On(towerData?.outG);
                    iIO.Off(towerData?.outR);
                    iIO.Off(towerData?.outY);
                    break;
                case TOWERLAMP_ELEMENT.R:
                case TOWERLAMP_ELEMENT.R_B:
                    iIO.Off(towerData?.outG);
                    iIO.On(towerData?.outR);
                    iIO.Off(towerData?.outY);
                    break;
                case TOWERLAMP_ELEMENT.Y:
                case TOWERLAMP_ELEMENT.Y_B:
                    iIO.Off(towerData?.outG);
                    iIO.Off(towerData?.outR);
                    iIO.On(towerData?.outY);
                    break;
                case TOWERLAMP_ELEMENT.G_Y:
                case TOWERLAMP_ELEMENT.G_Y_B:
                    iIO.On(towerData?.outG);
                    iIO.Off(towerData?.outR);
                    iIO.On(towerData?.outY);
                    break;
                case TOWERLAMP_ELEMENT.G_R:
                case TOWERLAMP_ELEMENT.G_R_B:
                    iIO.On(towerData?.outG);
                    iIO.On(towerData?.outR);
                    iIO.Off(towerData?.outY);
                    break;
                case TOWERLAMP_ELEMENT.R_Y:
                case TOWERLAMP_ELEMENT.R_Y_B:
                    iIO.Off(towerData?.outG);
                    iIO.On(towerData?.outR);
                    iIO.On(towerData?.outY);
                    break;
                case TOWERLAMP_ELEMENT.NONE:
                case TOWERLAMP_ELEMENT.NONE_B:
                    iIO.Off(towerData?.outG);
                    iIO.Off(towerData?.outR);
                    iIO.Off(towerData?.outY);
                    break;
                case TOWERLAMP_ELEMENT.G_R_Y:
                case TOWERLAMP_ELEMENT.G_R_Y_B:
                    iIO.On(towerData?.outG);
                    iIO.On(towerData?.outR);
                    iIO.On(towerData?.outY);
                    break;
                default:
                    break;
            }
        }

        /**
         * @brief Buzzer timeout 핸들링 함수
         * @param[in] sender invoke 시킨 주체
         * @param[in] e invoke 시키면서 전달된 매개변수
         */
        private void ElapsedTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
        {
            ForceBuzzerOff();
            elapsedTimer.Stop();
        }

        /**
         * @brief Buzzer 컨트롤을 위한 함수
         * @details buzzer에 대한 IO 체크 후 등록된 IO가 있다면 buzzer IO를 켜고 타이머를 시작
         */
        public void BuzzerControl()
        {
            if (towerData?.outBuzzer != null)
            {
                iIO.On(towerData?.outBuzzer);

                elapsedTimer.Interval = SystemDefine.BUZZER_TIMEOUT;
                elapsedTimer.Start();
            }
        }
        public void BuzzerControl(TOWERLAMP_ELEMENT element)
        {
            if (towerData?.outBuzzer != null)
            {
                if (element <= TOWERLAMP_ELEMENT.R_Y)
                {
                    iIO.Off(towerData?.outBuzzer);
                }
                else if (element > TOWERLAMP_ELEMENT.R_Y)
                {
                    iIO.On(towerData?.outBuzzer);
                }

                elapsedTimer.Interval = SystemDefine.BUZZER_TIMEOUT;
                elapsedTimer.Start();
            }
        }
        /**
         * @brief Buzzer 컨트롤을 위한 함수
         * @details buzzer에 대한 IO 체크 후 등록된 IO가 있다면 buzzer를 켠다.
         */
        public void BuzzerOnInfinitely()
        {
            if (towerData?.outBuzzer != null && iIO != null)
            {
                elapsedTimer.Stop();
                iIO.On(towerData?.outBuzzer);
            }
        }
        public void BuzzerOnInfinitely(TOWERLAMP_ELEMENT element)
        {
            if (towerData?.outBuzzer != null && iIO != null)
            {
                elapsedTimer.Stop();
                if (element <= TOWERLAMP_ELEMENT.R_Y)
                {
                    iIO.Off(towerData?.outBuzzer);
                }
                else if (element > TOWERLAMP_ELEMENT.R_Y)
                {
                    iIO.On(towerData?.outBuzzer);
                }
            }
        }

        /**
         * @brief Buzzer 컨트롤을 위한 함수
         * @details buzzer에 대한 IO 체크 후 등록된 IO가 있다면 buzzer IO를 끔
         */
        public void ForceBuzzerOff()
        {
            if (towerData?.outBuzzer != null && iIO != null)
            {
                iIO.Off(towerData?.outBuzzer);
            }
        }
    }
}

Vendor/Fastech/Data.cs
/* 
 * Copyright (C) Samsung Electronics Co., Ltd., Inc - All Rights Reserved
 * Unauthorized copying of this file, via any medium is strictly prohibited
 * Proprietary and confidential
 * 
 * Written by Donghyun Ko <dh79.ko@samsung.com>, June 2022
 * Written by Sanghyeon Lee <sirano06.lee@samsung.com>, June 2022
 * 
 */
using Auto_Insert_Sim_Tray.Configs;
using Auto_Insert_Sim_Tray.Configs.Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static Auto_Insert_Sim_Tray.Define.IODefine;
using static Auto_Insert_Sim_Tray.HW.Vendor.Fastech.Lib.EZI_COMM_DEFINE;

namespace Auto_Insert_Sim_Tray.HW.Vendor.Fastech.Data
{
    public enum FASTECH_OBJECT_TYPE
    {
        NONE = 0x00,
        AXIS = 0x01,
        IO = 0x02,
        AXIS_IO = 0x03,
    }

    public enum FASTECH_CONNECTION_TYPE
    {
        NONE = 0,
        SERIAL,
        ETHERNET
    }

    public enum FASTECH_AXIS_TYPE
    {
        NONE = 0,
        EZI_SERVO_PLUS_R_V6,
        EZI_SERVO_PLUS_R_V8,
        EZI_SERVO_PLUS_E_V6,
        EZI_MOTION_LINK_PLUS_R_V6,
        EZI_MOTION_LINK_PLUS_R_V8,
        EZI_MOTION_LINK_PLUS_E_V6,
    }

    public enum FASTECH_IO_BOARD_TYPE
    {
        NONE = -1,
        EZI_PLUS_I6O9,
        EZI_PLUS_I9O9,
        EZI_IO_I16 = 150,
        EZI_IO_I32 = 151,
        EZI_IO_I8O8 = 155,
        EZI_IO_I16O16 = 156,
        EZI_IO_O16 = 160,
        EZI_IO_O32 = 161,
        EZI_PLUS_I12O9, //Ezi IO giống I9O9 (có thêm tín hiệu Limit, Home
    }

    public enum LEVEL_SPEED
    {
        SLOW,
        NORMAL,
        HIGH,
    }

    public class FastechObject
    {
        // AXIS, IO , AXIS|IO
        public FASTECH_OBJECT_TYPE objectType { get; }
        // Serail의 경우 SlaveID, Ethernet의 경우 Board ID
        public byte ID { get; }
        // 연결 방법
        public FASTECH_CONNECTION_TYPE connectionType { get; }
        // SerialPortModel or IPAddress
        public object connectionInfo { get; }
        // IO Board type
        public FASTECH_IO_BOARD_TYPE boardType { get; }
        // Axis Type
        public FASTECH_AXIS_TYPE axisType { get; }

        // 현재 Fastech 제품의 모든 상태를 업데이트한다.
        public FastechStatus fastechStatus { get; set; }

        // IO Board를 위해 사용한다.
        public uint inputValue;
        public uint outputValue;

        public FastechObject(FASTECH_OBJECT_TYPE objectType, byte ID, FASTECH_CONNECTION_TYPE connectionType, object connectionInfo, FASTECH_IO_BOARD_TYPE boardType, FASTECH_AXIS_TYPE axisType)
        {
            this.objectType = objectType;
            this.ID = ID;
            this.connectionType = connectionType;
            this.connectionInfo = connectionInfo;
            this.boardType = boardType;
            this.axisType = axisType;

            fastechStatus = new FastechStatus();
            inputValue = 0x00;
            outputValue = 0x00;
        }
    }

    // Fastech제품 상태를 지속적으로 Update하여 저장하여야 한다.
    public class FastechStatus
    {
        public uint inStatus;
        public ulong inStatusV8;
        public uint outStatus;
        public uint axisStatus;
        public int targetPos;
        public int currentPos;
        public int posError;
        public int velocity;
        public ushort posTableItemNo;

        public FastechStatus()
        {
            inStatus = 0;
            inStatusV8 = 0;
            outStatus = 0;
            axisStatus = 0;
            targetPos = 0;
            currentPos = 0;
            posError = 0;
            velocity = 0;
            posTableItemNo = 0;
        }
    }
}

Vendor/Lib/Fastech.cs
/* 
 * Copyright (C) Samsung Electronics Co., Ltd., Inc - All Rights Reserved
 * Unauthorized copying of this file, via any medium is strictly prohibited
 * Proprietary and confidential
 * 
 * Written by Donghyun Ko <dh79.ko@samsung.com>, June 2022
 * Written by Sanghyeon Lee <sirano06.lee@samsung.com>, June 2022
 * 
 */

using Auto_Insert_Sim_Tray.Configs.Model;
using Auto_Insert_Sim_Tray.Define;
using Auto_Insert_Sim_Tray.HW.Interface;
using Auto_Insert_Sim_Tray.HW.Vendor.Fastech.Data;
using Auto_Insert_Sim_Tray.HW.Vendor.Fastech.Lib;
using Auto_Insert_Sim_Tray.Utils;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using static Auto_Insert_Sim_Tray.Define.AxisDefine;
using static Auto_Insert_Sim_Tray.Define.IODefine;
using static Auto_Insert_Sim_Tray.Define.LogDefine;
using static Auto_Insert_Sim_Tray.HW.Vendor.Fastech.Lib.EZI_COMM_DEFINE;
using static Auto_Insert_Sim_Tray.HW.Vendor.Fastech.Lib.EziMOTIONPlusELib;
using static Auto_Insert_Sim_Tray.HW.Vendor.Fastech.Lib.EziMOTIONPlusRLib;
using static Auto_Insert_Sim_Tray.HW.Vendor.Fastech.Lib.EziMOTIONPlusRV8Lib;

namespace Auto_Insert_Sim_Tray.HW.Vendor.Fastech
{
    class Fastech : IAxis, IIO, NV_UI_2_0.UserIIO
    {
        private const bool ON = true;
        private const bool OFF = false;
        private const int TRUE = 1;
        private const int FALSE = 0;

        private int portCount = 0;
        private int ethernetCount = 0;
        private int maxPortValue = 0;
        private int maxEthernetID = 0;
        private int countRetryConnect = 0;

        private bool[] isPortConnected = null;
        private bool[] isEthernetConnected = null;

        // 연결되어 있는 fastech 제품들의 list
        // Serial의 경우 같은 Port를 사용하는 제품들로 하나의 list를 구성해야 한다.
        private List<FastechObject[]> listFastechObjects;
        private AxisParamData[] axisParamData;

        private Dictionary<AXIS_LIST, FastechObject> axisList;
        private List<FastechObject> ioList;

        private SafeThread axisThread;
        private SafeThread inputThread;
        private SafeThread outputThread;
        private object axisStatusLock;
        private object inputStatusLock;
        private object outputStatusLock;

        public Fastech(List<FastechObject[]> listFastechObjects)
        {
            axisStatusLock = new object();
            inputStatusLock = new object();
            outputStatusLock = new object();

            this.listFastechObjects = listFastechObjects;
            GetConnectNum(ref portCount, ref maxPortValue, ref ethernetCount, ref maxEthernetID);
            if (maxPortValue != 0)
            {
                isPortConnected = new bool[maxPortValue + 1];
            }

            if (maxEthernetID != 0)
            {
                isEthernetConnected = new bool[maxEthernetID + 1];
            }

            InitFastechObjectList();
            axisParamData = new AxisParamData[Convert.ToInt32(AXIS_LIST.MAX)];

            // 모든 Fastech object를 연결한다.
            Connect();

            axisThread = new SafeThread(new ThreadStart(UpdateAllStatus), 50);
            axisThread.StartThread();

            inputThread = new SafeThread(new ThreadStart(UpdateInputStatus), 50);
            inputThread.StartThread();

            outputThread = new SafeThread(new ThreadStart(UpdateOutputStatus), 50);
            outputThread.StartThread();
        }

        /*
         * @brief Axis와 IO만 분리하여 List 구성하며, 현재 상태 값을 저장하도록 한다.
         */
        private void InitFastechObjectList()
        {
            int axixIdx = 0;

            axisList = new Dictionary<AXIS_LIST, FastechObject>();
            ioList = new List<FastechObject>();

            foreach (var fastechObjects in listFastechObjects)
            {
                foreach (var fastech in fastechObjects)
                {
                    if ((fastech.objectType & FASTECH_OBJECT_TYPE.AXIS) != FASTECH_OBJECT_TYPE.NONE)
                    {
                        axisList.Add((AXIS_LIST)axixIdx, fastech);
                        axixIdx++;
                    }

                    if ((fastech.objectType & FASTECH_OBJECT_TYPE.IO) != FASTECH_OBJECT_TYPE.NONE)
                    {
                        ioList.Add(fastech);
                    }
                }
            }
        }

        private void GetConnectNum(ref int portCount, ref int maxPortValue, ref int ethernetCount, ref int maxEthernetID)
        {
            foreach (var fastechObjects in listFastechObjects)
            {
                foreach (var fastech in fastechObjects)
                {
                    if (fastech.connectionType == FASTECH_CONNECTION_TYPE.SERIAL)
                    {
                        SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                        string strPort = GetPortString(serial.PortName);
                        byte bytePort = byte.Parse(strPort);

                        if (bytePort > maxPortValue)
                        {
                            maxPortValue = bytePort;
                        }
                        portCount++;
                        break;
                    }
                    else if (fastech.connectionType == FASTECH_CONNECTION_TYPE.ETHERNET)
                    {
                        if (fastech.ID > maxEthernetID)
                        {
                            maxEthernetID = fastech.ID;
                        }
                        ethernetCount++;
                    }
                }
            }

            LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"GetConnectNum - Port : {portCount}, {maxPortValue}", CONTENT_TYPE.DEBUG);
            LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"GetConnectNum - Ethernet : {ethernetCount}, {maxEthernetID}", CONTENT_TYPE.DEBUG);
        }

        /**
         * @brief Port number를 반환하는 함수
         * @param[in] port Serial port name
         * @return Port string에 COM 제외한 포트 number를 리턴
         */
        private string GetPortString(string port)
        {
            if (port.Contains("COM"))
            {
                port = port.Remove(0, 3);
            }
            return port;
        }

        /**
         * @brief 원하는 Motor status를 반환하는 함수
         * @param[in] axisIdx AXIS_LIST 번호
         * @param[in] checkFlag 체크하고자 하는 축의 flag
         * @return 체크하고자 하는 상태인지 여부
         */
        private bool CheckAxisStatus(object axisIdx, uint checkFlag)
        {
            try
            {
                bool ret = false;
                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];

                if (!IsConnected(axisIdx))
                {
                    //LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"{(AXIS_LIST)axisIdx} didn't connected!", CONTENT_TYPE.EXCEPTION);
                    return ret;
                }

                if ((fastech.fastechStatus.axisStatus & checkFlag) != 0)
                {
                    ret = true;
                }

                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }

        /**
         * @brief motor status를 업데이트하는 함수
         * @details 모든 slave의 motor driver의 status를 업데이트
         */
        public void UpdateAllStatus()
        {
            try
            {
                int libRet = FMM_OK;

                foreach (KeyValuePair<AXIS_LIST, FastechObject> var in axisList)
                {
                    FastechObject fastech = var.Value;
                    FastechStatus fastechStatus = new FastechStatus();

                    if (!IsConnected(var.Key))
                    {
                        Reconnect(fastech);
                        continue;
                    }

                    switch (fastech.connectionType)
                    {
                        case FASTECH_CONNECTION_TYPE.SERIAL:
                            SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                            string strPort = GetPortString(serial.PortName);
                            byte bytePort = byte.Parse(strPort);

                            switch (fastech.axisType)
                            {
                                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                    libRet = EziMOTIONPlusRV8Lib.FAS_GetAllStatus(
                                        bytePort,
                                        fastech.ID,
                                        ref fastechStatus.inStatusV8,
                                        ref fastechStatus.outStatus,
                                        ref fastechStatus.axisStatus,
                                        ref fastechStatus.targetPos,
                                        ref fastechStatus.currentPos,
                                        ref fastechStatus.posError,
                                        ref fastechStatus.velocity,
                                        ref fastechStatus.posTableItemNo);
                                    break;

                                default:
                                    libRet = EziMOTIONPlusRLib.FAS_GetAllStatus(
                                        bytePort,
                                        fastech.ID,
                                        ref fastechStatus.inStatus,
                                        ref fastechStatus.outStatus,
                                        ref fastechStatus.axisStatus,
                                        ref fastechStatus.targetPos,
                                        ref fastechStatus.currentPos,
                                        ref fastechStatus.posError,
                                        ref fastechStatus.velocity,
                                        ref fastechStatus.posTableItemNo);
                                    break;
                            }
                            break;

                        case FASTECH_CONNECTION_TYPE.ETHERNET:
                            libRet = EziMOTIONPlusELib.FAS_GetAllStatus(
                                fastech.ID,
                                ref fastechStatus.inStatus,
                                ref fastechStatus.outStatus,
                                ref fastechStatus.axisStatus,
                                ref fastechStatus.targetPos,
                                ref fastechStatus.currentPos,
                                ref fastechStatus.posError,
                                ref fastechStatus.velocity,
                                ref fastechStatus.posTableItemNo);
                            break;
                    }

                    lock (axisStatusLock)
                    {
                        if (libRet == FMM_OK)
                        {
                            fastech.fastechStatus = fastechStatus;
                        }
                    }

                    if (libRet != FMM_OK)
                    {
                        if (libRet == FMM_NOT_OPEN)
                        {
                            UpdateConnectionStatus(fastech);
                        }
                        LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, "Fastech update status error with return value : " + libRet.ToString(), CONTENT_TYPE.ERROR);
                    }
                }
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
            }
        }

        private void Reconnect(FastechObject fastech)
        {
            Close(fastech);
            Util.Delay(100);
            Connect(fastech);
        }
        private void UpdateConnectionStatus(FastechObject fastech)
        {
            switch (fastech.connectionType)
            {
                case FASTECH_CONNECTION_TYPE.NONE:
                    break;
                case FASTECH_CONNECTION_TYPE.SERIAL:
                    SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                    string strPort = GetPortString(serial.PortName);
                    byte bytePort = byte.Parse(strPort);
                    isPortConnected[bytePort] = false;
                    break;
                case FASTECH_CONNECTION_TYPE.ETHERNET:
                    isEthernetConnected[fastech.ID] = false;
                    break;
                default:
                    break;
            }
        }

        /**
         * @brief Input Value를 업데이트하는 함수
         * @details 모든 slave의 Input 값을 업데이트
         */
        public void UpdateInputStatus()
        {
            try
            {
                int libRet = FMM_OK;
                byte boardType = 0;
                string version = "";
                uint inputValue = 0;
                uint latch = 0;
                FastechStatus fastechStatus = new FastechStatus();

                foreach (FastechObject fastech in ioList)
                {
                    boardType = 0;
                    version = "";
                    inputValue = 0;
                    latch = 0;

                    switch (fastech.connectionType)
                    {
                        case FASTECH_CONNECTION_TYPE.SERIAL:
                            SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                            string strPort = GetPortString(serial.PortName);
                            byte bytePort = byte.Parse(strPort);

                            if (!isPortConnected[bytePort])
                            {
                                Reconnect(fastech);
                                continue;
                            }

                            // Motor에 IO가 달려있는 경우에는 UpdateAllStatus 함수에서 업데이트한다.
                            // 오직 IO Board type 에서만 해당 값을 업데이트 한다.
                            if (((fastech.objectType & FASTECH_OBJECT_TYPE.IO) != FASTECH_OBJECT_TYPE.NONE)
                                && ((fastech.objectType & FASTECH_OBJECT_TYPE.AXIS) == FASTECH_OBJECT_TYPE.NONE))
                            {
                                libRet = EziMOTIONPlusRLib.FAS_GetSlaveInfo(bytePort, fastech.ID, ref boardType, ref version);
                                if (libRet == FMM_OK)
                                {
                                    switch ((FASTECH_IO_BOARD_TYPE)boardType)
                                    {
                                        case FASTECH_IO_BOARD_TYPE.EZI_IO_I16:
                                        case FASTECH_IO_BOARD_TYPE.EZI_IO_I16O16:
                                        case FASTECH_IO_BOARD_TYPE.EZI_IO_I32:
                                            libRet = EziMOTIONPlusRLib.FAS_GetInput(bytePort, fastech.ID, ref inputValue, ref latch);
                                            break;
                                    }
                                }
                            }
                            break;

                        case FASTECH_CONNECTION_TYPE.ETHERNET:
                            if (!isEthernetConnected[fastech.ID])
                            {
                                Reconnect(fastech);
                                continue;
                            }

                            libRet = EziMOTIONPlusELib.FAS_GetSlaveInfo(fastech.ID, ref boardType, ref version);
                            if (libRet == FMM_OK)
                            {
                                switch ((FASTECH_IO_BOARD_TYPE)boardType)
                                {
                                    case FASTECH_IO_BOARD_TYPE.EZI_IO_I16:
                                    case FASTECH_IO_BOARD_TYPE.EZI_IO_I16O16:
                                    case FASTECH_IO_BOARD_TYPE.EZI_IO_I32:
                                        libRet = EziMOTIONPlusELib.FAS_GetInput(fastech.ID, ref inputValue, ref latch);
                                        break;
                                }
                            }
                            break;
                    }

                    lock (inputStatusLock)
                    {
                        if (libRet == FMM_OK)
                        {
                            fastech.inputValue = inputValue;
                        }
                    }

                    if (libRet != FMM_OK)
                    {
                        if (libRet == FMM_NOT_OPEN)
                        {
                            UpdateConnectionStatus(fastech);
                        }
                        LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Fastech output status error with return value : {libRet.ToString()}", CONTENT_TYPE.ERROR);
                    }
                }
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
            }
        }

        /**
         * @brief Output Value를 업데이트하는 함수
         * @details 모든 slave의 Output 값을 업데이트
         */
        public void UpdateOutputStatus()
        {
            try
            {
                int libRet = FMM_OK;
                byte boardType = 0;
                string version = "";
                uint outputValue = 0;
                uint latch = 0;
                FastechStatus fastechStatus = new FastechStatus();

                foreach (FastechObject fastech in ioList)
                {
                    boardType = 0;
                    version = "";
                    outputValue = 0;
                    latch = 0;

                    switch (fastech.connectionType)
                    {
                        case FASTECH_CONNECTION_TYPE.SERIAL:
                            SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                            string strPort = GetPortString(serial.PortName);
                            byte bytePort = byte.Parse(strPort);

                            if (!isPortConnected[bytePort])
                            {
                                Reconnect(fastech);
                                continue;
                            }

                            // Motor에 IO가 달려있는 경우에는 UpdateAllStatus 함수에서 업데이트한다.
                            // 오직 IO Board type 에서만 해당 값을 업데이트 한다.
                            if (((fastech.objectType & FASTECH_OBJECT_TYPE.IO) != FASTECH_OBJECT_TYPE.NONE)
                                && ((fastech.objectType & FASTECH_OBJECT_TYPE.AXIS) == FASTECH_OBJECT_TYPE.NONE))
                            {
                                libRet = EziMOTIONPlusRLib.FAS_GetSlaveInfo(bytePort, fastech.ID, ref boardType, ref version);
                                if (libRet == FMM_OK)
                                {
                                    switch ((FASTECH_IO_BOARD_TYPE)boardType)
                                    {
                                        case FASTECH_IO_BOARD_TYPE.EZI_IO_O16:
                                        case FASTECH_IO_BOARD_TYPE.EZI_IO_I16O16:
                                        case FASTECH_IO_BOARD_TYPE.EZI_IO_O32:
                                            libRet = EziMOTIONPlusRLib.FAS_GetOutput(bytePort, fastech.ID, ref outputValue, ref latch);
                                            break;
                                    }
                                }
                            }
                            break;

                        case FASTECH_CONNECTION_TYPE.ETHERNET:
                            if (!isEthernetConnected[fastech.ID])
                            {
                                Reconnect(fastech);
                                continue;
                            }

                            libRet = EziMOTIONPlusELib.FAS_GetSlaveInfo(fastech.ID, ref boardType, ref version);
                            if (libRet == FMM_OK)
                            {
                                switch ((FASTECH_IO_BOARD_TYPE)boardType)
                                {
                                    case FASTECH_IO_BOARD_TYPE.EZI_IO_O16:
                                    case FASTECH_IO_BOARD_TYPE.EZI_IO_I16O16:
                                    case FASTECH_IO_BOARD_TYPE.EZI_IO_O32:
                                        libRet = EziMOTIONPlusELib.FAS_GetOutput(fastech.ID, ref outputValue, ref latch);
                                        break;
                                }
                            }
                            break;
                    }

                    lock (outputStatusLock)
                    {
                        if (libRet == FMM_OK)
                        {
                            fastech.outputValue = outputValue;
                        }
                    }

                    if (libRet != FMM_OK)
                    {
                        if (libRet == FMM_NOT_OPEN)
                        {
                            UpdateConnectionStatus(fastech);
                        }
                        LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Fastech output status error with return value : {libRet.ToString()}", CONTENT_TYPE.ERROR);
                    }
                }
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
            }
        }

        private void GetBoardIOSize(FASTECH_IO_BOARD_TYPE type, ref int inputSize, ref int outputSize)
        {
            inputSize = 0;
            outputSize = 0;

            switch (type)
            {
                case FASTECH_IO_BOARD_TYPE.EZI_PLUS_I6O9:
                    inputSize = 6;
                    outputSize = 9;
                    break;

                case FASTECH_IO_BOARD_TYPE.EZI_PLUS_I9O9:
                    inputSize = 9;
                    outputSize = 9;
                    break;

                case FASTECH_IO_BOARD_TYPE.EZI_IO_I16:
                    inputSize = 16;
                    outputSize = 0;
                    break;

                case FASTECH_IO_BOARD_TYPE.EZI_IO_I32:
                    inputSize = 32;
                    outputSize = 0;
                    break;

                case FASTECH_IO_BOARD_TYPE.EZI_IO_I8O8:
                    inputSize = 8;
                    outputSize = 8;
                    break;

                case FASTECH_IO_BOARD_TYPE.EZI_IO_I16O16:
                    inputSize = 16;
                    outputSize = 16;
                    break;

                case FASTECH_IO_BOARD_TYPE.EZI_IO_O16:
                    inputSize = 0;
                    outputSize = 16;
                    break;

                case FASTECH_IO_BOARD_TYPE.EZI_IO_O32:
                    inputSize = 0;
                    outputSize = 32;
                    break;
            }
        }

        private UInt64 GetInputLogic(FastechObject fastech, int ioValue)
        {
            UInt64 inputLogic = 0x00;

            switch (fastech.axisType)
            {
                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V6:
                    switch (ioValue)
                    {
                        case 0:
                            inputLogic = (uint)EZISERVO_INLOGIC_LIST.SERVO_IN_LOGIC_USERIN0;
                            break;
                        case 1:
                            inputLogic = (uint)EZISERVO_INLOGIC_LIST.SERVO_IN_LOGIC_USERIN1;
                            break;
                        case 2:
                            inputLogic = (uint)EZISERVO_INLOGIC_LIST.SERVO_IN_LOGIC_USERIN2;
                            break;
                        case 3:
                            inputLogic = (uint)EZISERVO_INLOGIC_LIST.SERVO_IN_LOGIC_USERIN3;
                            break;
                        case 4:
                            inputLogic = (uint)EZISERVO_INLOGIC_LIST.SERVO_IN_LOGIC_USERIN4;
                            break;
                        case 5:
                            inputLogic = (uint)EZISERVO_INLOGIC_LIST.SERVO_IN_LOGIC_USERIN5;
                            break;
                    }
                    break;

                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                    switch (ioValue)
                    {
                        case 0:
                            inputLogic = (UInt64)EZISERVOV8_INLOGIC_LIST.SERVO_IN_LOGIC_USERIN0;
                            break;
                        case 1:
                            inputLogic = (UInt64)EZISERVOV8_INLOGIC_LIST.SERVO_IN_LOGIC_USERIN1;
                            break;
                        case 2:
                            inputLogic = (UInt64)EZISERVOV8_INLOGIC_LIST.SERVO_IN_LOGIC_USERIN2;
                            break;
                        case 3:
                            inputLogic = (UInt64)EZISERVOV8_INLOGIC_LIST.SERVO_IN_LOGIC_USERIN3;
                            break;
                        case 4:
                            inputLogic = (UInt64)EZISERVOV8_INLOGIC_LIST.SERVO_IN_LOGIC_USERIN4;
                            break;
                        case 5:
                            inputLogic = (UInt64)EZISERVOV8_INLOGIC_LIST.SERVO_IN_LOGIC_USERIN5;
                            break;
                        case 6:
                            inputLogic = (UInt64)EZISERVOV8_INLOGIC_LIST.SERVO_IN_LOGIC_USERIN6;
                            break;
                        case 7:
                            inputLogic = (UInt64)EZISERVOV8_INLOGIC_LIST.SERVO_IN_LOGIC_USERIN7;
                            break;
                        case 8:
                            inputLogic = (UInt64)EZISERVOV8_INLOGIC_LIST.SERVO_IN_LOGIC_USERIN8;
                            break;
                    }
                    break;

                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_E_V6:
                    switch (ioValue)
                    {
                        case 0:
                            inputLogic = (uint)EZISERVO2_INLOGIC_LIST.SERVO2_IN_LOGIC_USERIN0;
                            break;
                        case 1:
                            inputLogic = (uint)EZISERVO2_INLOGIC_LIST.SERVO2_IN_LOGIC_USERIN1;
                            break;
                        case 2:
                            inputLogic = (uint)EZISERVO2_INLOGIC_LIST.SERVO2_IN_LOGIC_USERIN2;
                            break;
                        case 3:
                            inputLogic = (uint)EZISERVO2_INLOGIC_LIST.SERVO2_IN_LOGIC_USERIN3;
                            break;
                        case 4:
                            inputLogic = (uint)EZISERVO2_INLOGIC_LIST.SERVO2_IN_LOGIC_USERIN4;
                            break;
                        case 5:
                            inputLogic = (uint)EZISERVO2_INLOGIC_LIST.SERVO2_IN_LOGIC_USERIN5;
                            break;
                        case 6:
                            inputLogic = (uint)EZISERVO2_INLOGIC_LIST.SERVO2_IN_LOGIC_USERIN6;
                            break;
                        case 7:
                            inputLogic = (uint)EZISERVO2_INLOGIC_LIST.SERVO2_IN_LOGIC_USERIN7;
                            break;
                        case 8:
                            inputLogic = (uint)EZISERVO2_INLOGIC_LIST.SERVO2_IN_LOGIC_USERIN8;
                            break;
                    }
                    break;

                    /*
                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V6:
                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                    switch (ioValue)
                    {
                        case 0:
                            inputLogic = (uint)EZIMOTIONLINK_INLOGIC_LIST.MOTIONLINK_IN_LOGIC_USERIN0;
                            break;
                        case 1:
                            inputLogic = (uint)EZIMOTIONLINK_INLOGIC_LIST.MOTIONLINK_IN_LOGIC_USERIN1;
                            break;
                        case 2:
                            inputLogic = (uint)EZIMOTIONLINK_INLOGIC_LIST.MOTIONLINK_IN_LOGIC_USERIN2;
                            break;
                        case 3:
                            inputLogic = (uint)EZIMOTIONLINK_INLOGIC_LIST.MOTIONLINK_IN_LOGIC_USERIN3;
                            break;
                        case 4:
                            inputLogic = (uint)EZIMOTIONLINK_INLOGIC_LIST.MOTIONLINK_IN_LOGIC_USERIN4;
                            break;
                    }
                    break;

                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_E_V6:
                    switch (ioValue)
                    {
                        case 0:
                            inputLogic = (uint)EZIMOTIONLINK2_INLOGIC_LIST.MOTIONLINK2_IN_LOGIC_USERIN0;
                            break;
                    }
                    break;
                    */
            }

            return inputLogic;
        }

        private UInt64 GetOutputLogic(FastechObject fastech, int ioValue)
        {
            UInt64 outputLogic = 0x00;

            switch (fastech.axisType)
            {
                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V6:
                    switch (ioValue)
                    {
                        case 0:
                            outputLogic = (uint)EZISERVO_OUTLOGIC_LIST.SERVO_OUT_LOGIC_USEROUT0;
                            break;
                        case 1:
                            outputLogic = (uint)EZISERVO_OUTLOGIC_LIST.SERVO_OUT_LOGIC_USEROUT1;
                            break;
                        case 2:
                            outputLogic = (uint)EZISERVO_OUTLOGIC_LIST.SERVO_OUT_LOGIC_USEROUT2;
                            break;
                        case 3:
                            outputLogic = (uint)EZISERVO_OUTLOGIC_LIST.SERVO_OUT_LOGIC_USEROUT3;
                            break;
                        case 4:
                            outputLogic = (uint)EZISERVO_OUTLOGIC_LIST.SERVO_OUT_LOGIC_USEROUT4;
                            break;
                        case 5:
                            outputLogic = (uint)EZISERVO_OUTLOGIC_LIST.SERVO_OUT_LOGIC_USEROUT5;
                            break;
                    }
                    break;

                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                    switch (ioValue)
                    {
                        case 0:
                            outputLogic = (UInt64)EZISERVOV8_OUTLOGIC_LIST.SERVO_OUT_LOGIC_USEROUT0;
                            break;
                        case 1:
                            outputLogic = (UInt64)EZISERVOV8_OUTLOGIC_LIST.SERVO_OUT_LOGIC_USEROUT1;
                            break;
                        case 2:
                            outputLogic = (UInt64)EZISERVOV8_OUTLOGIC_LIST.SERVO_OUT_LOGIC_USEROUT2;
                            break;
                        case 3:
                            outputLogic = (UInt64)EZISERVOV8_OUTLOGIC_LIST.SERVO_OUT_LOGIC_USEROUT3;
                            break;
                        case 4:
                            outputLogic = (UInt64)EZISERVOV8_OUTLOGIC_LIST.SERVO_OUT_LOGIC_USEROUT4;
                            break;
                        case 5:
                            outputLogic = (UInt64)EZISERVOV8_OUTLOGIC_LIST.SERVO_OUT_LOGIC_USEROUT5;
                            break;
                        case 6:
                            outputLogic = (UInt64)EZISERVOV8_OUTLOGIC_LIST.SERVO_OUT_LOGIC_USEROUT6;
                            break;
                        case 7:
                            outputLogic = (UInt64)EZISERVOV8_OUTLOGIC_LIST.SERVO_OUT_LOGIC_USEROUT7;
                            break;
                        case 8:
                            outputLogic = (UInt64)EZISERVOV8_OUTLOGIC_LIST.SERVO_OUT_LOGIC_USEROUT8;
                            break;
                    }
                    break;

                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_E_V6:
                    switch (ioValue)
                    {
                        case 0:
                            outputLogic = (uint)EZISERVO2_OUTLOGIC_LIST.SERVO2_OUT_LOGIC_USEROUT0;
                            break;
                        case 1:
                            outputLogic = (uint)EZISERVO2_OUTLOGIC_LIST.SERVO2_OUT_LOGIC_USEROUT1;
                            break;
                        case 2:
                            outputLogic = (uint)EZISERVO2_OUTLOGIC_LIST.SERVO2_OUT_LOGIC_USEROUT2;
                            break;
                        case 3:
                            outputLogic = (uint)EZISERVO2_OUTLOGIC_LIST.SERVO2_OUT_LOGIC_USEROUT3;
                            break;
                        case 4:
                            outputLogic = (uint)EZISERVO2_OUTLOGIC_LIST.SERVO2_OUT_LOGIC_USEROUT4;
                            break;
                        case 5:
                            outputLogic = (uint)EZISERVO2_OUTLOGIC_LIST.SERVO2_OUT_LOGIC_USEROUT5;
                            break;
                        case 6:
                            outputLogic = (uint)EZISERVO2_OUTLOGIC_LIST.SERVO2_OUT_LOGIC_USEROUT6;
                            break;
                        case 7:
                            outputLogic = (uint)EZISERVO2_OUTLOGIC_LIST.SERVO2_OUT_LOGIC_USEROUT7;
                            break;
                        case 8:
                            outputLogic = (uint)EZISERVO2_OUTLOGIC_LIST.SERVO2_OUT_LOGIC_USEROUT8;
                            break;
                    }
                    break;

                    /*
                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V6:
                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                    switch (ioValue)
                    {
                        case 0:
                            outputLogic = (uint)EZIMOTIONLINK_OUTLOGIC_LIST.MOTIONLINK_OUT_LOGIC_USEROUT0;
                            break;
                        case 1:
                            outputLogic = (uint)EZIMOTIONLINK_OUTLOGIC_LIST.MOTIONLINK_OUT_LOGIC_USEROUT1;
                            break;
                        case 2:
                            outputLogic = (uint)EZIMOTIONLINK_OUTLOGIC_LIST.MOTIONLINK_OUT_LOGIC_USEROUT2;
                            break;
                    }
                    break;

                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_E_V6:
                    switch (ioValue)
                    {
                        case 0:
                            outputLogic = (uint)EZIMOTIONLINK2_OUTLOGIC_LIST.MOTIONLINK2_OUT_LOGIC_USEROUT0;
                            break;
                    }
                    break;
                    */
            }

            return outputLogic;
        }

        /**
         * @brief IO가 켜져 있는지 확인하는 함수
         * @param[in] io DIGITAL INPUT/OUTPUT
         * @return IO 켜져 있는지 여부
         */
        public bool IsOn(object io)
        {
            try
            {
                int ioValue = Convert.ToInt32(io);
                int inputSize = 0;
                int outputSize = 0;
                bool data = false;

                foreach (var fastech in ioList)
                {
                    GetBoardIOSize(fastech.boardType, ref inputSize, ref outputSize);
                    if (io.GetType() == typeof(DI))
                    {
                        if (ioValue >= inputSize)
                        {
                            ioValue -= inputSize;
                        }
                        else
                        {
                            // Motor 내장형
                            if (((fastech.objectType & FASTECH_OBJECT_TYPE.IO) != FASTECH_OBJECT_TYPE.NONE)
                                && ((fastech.objectType & FASTECH_OBJECT_TYPE.AXIS) != FASTECH_OBJECT_TYPE.NONE))
                            {
                                lock (axisStatusLock)
                                {
                                    switch (fastech.axisType)
                                    {
                                        case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V6:
                                        case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_E_V6:
                                            data = ((fastech.fastechStatus.inStatus & GetInputLogic(fastech, ioValue)) != 0);
                                            break;
                                        case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                                            data = ((fastech.fastechStatus.inStatusV8 & GetInputLogic(fastech, ioValue)) != 0);
                                            break;
                                            // Motion link는 일단 보류
                                            /*
                                        case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V6:
                                        case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                        case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_E_V6:
                                            break;
                                            */
                                    }
                                }
                            }
                            else
                            {
                                lock (inputStatusLock)
                                {
                                    data = ((fastech.inputValue & (0x01 << (int)ioValue)) != 0);
                                }
                            }
                            break;
                        }
                    }
                    else if (io.GetType() == typeof(DO))
                    {
                        if (ioValue >= outputSize)
                        {
                            ioValue -= outputSize;
                        }
                        else
                        {
                            // Motor 내장형
                            if (((fastech.objectType & FASTECH_OBJECT_TYPE.IO) != FASTECH_OBJECT_TYPE.NONE)
                                && ((fastech.objectType & FASTECH_OBJECT_TYPE.AXIS) != FASTECH_OBJECT_TYPE.NONE))
                            {
                                lock (axisStatusLock)
                                {
                                    data = ((fastech.fastechStatus.outStatus & GetOutputLogic(fastech, ioValue)) != 0);
                                }
                            }
                            else
                            {
                                lock (outputStatusLock)
                                {
                                    if (fastech.boardType == FASTECH_IO_BOARD_TYPE.EZI_IO_I16O16)
                                    {
                                        data = ((fastech.outputValue & (0x01 << (int)(ioValue + 16))) != 0);
                                    }
                                    else
                                    {
                                        data = ((fastech.outputValue & (0x01 << (int)ioValue)) != 0);
                                    }
                                }
                            }
                            break;
                        }
                    }
                }

                return data;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }

        /**
         * @brief IO가 꺼져 있는지 확인하는 함수
         * @param[in] io DIGITAL INPUT/OUTPUT
         * @return IO 꺼져 있는지 여부
         */
        public bool IsOff(object io)
        {
            try
            {
                bool data = false;
                data = IsOn(io);

                return !data;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return true;
            }
        }

        /**
         * @brief IO 끄는 함수
         * @param[in] io DIGITAL INPUT/OUTPUT
         */
        public void Off(object io)
        {
            try
            {
                int ioValue = Convert.ToInt32(io);
                int inputSize = 0;
                int outputSize = 0;
                bool isConnected = false;
                byte bytePort = 0;
                uint setMask = 0x00;
                uint clrMask = 0x01;

                if (io.GetType() != typeof(DO))
                {
                    return;
                }

                foreach (var fastech in ioList)
                {
                    GetBoardIOSize(fastech.boardType, ref inputSize, ref outputSize);
                    if (ioValue >= outputSize)
                    {
                        ioValue -= outputSize;
                    }
                    else
                    {
                        switch (fastech.connectionType)
                        {
                            case FASTECH_CONNECTION_TYPE.SERIAL:
                                SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                                string strPort = GetPortString(serial.PortName);
                                bytePort = byte.Parse(strPort);
                                uint baudRate = Convert.ToUInt32(serial.BaudRate);

                                isConnected = isPortConnected[bytePort];
                                break;

                            case FASTECH_CONNECTION_TYPE.ETHERNET:
                                IPAddress ip = (IPAddress)fastech.connectionInfo;
                                isConnected = isEthernetConnected[fastech.ID];
                                break;
                        }

                        if (!isConnected)
                        {
                            return;
                        }

                        // Motor 내장형
                        if (((fastech.objectType & FASTECH_OBJECT_TYPE.IO) != FASTECH_OBJECT_TYPE.NONE)
                            && ((fastech.objectType & FASTECH_OBJECT_TYPE.AXIS) != FASTECH_OBJECT_TYPE.NONE))
                        {
                            switch (fastech.axisType)
                            {
                                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V6:
                                    EziMOTIONPlusRLib.FAS_SetIOOutput(bytePort, fastech.ID, setMask, (uint)GetOutputLogic(fastech, ioValue));
                                    break;

                                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                                    EziMOTIONPlusRV8Lib.FAS_SetIOOutput(bytePort, fastech.ID, setMask, (uint)GetOutputLogic(fastech, ioValue));
                                    break;

                                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_E_V6:
                                    EziMOTIONPlusELib.FAS_SetIOOutput(fastech.ID, setMask, (uint)GetOutputLogic(fastech, ioValue));
                                    break;

                                    // Motion link는 일단 보류
                                    /*
                                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V6:
                                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_E_V6:
                                    break;
                                    */
                            }
                        }
                        else
                        {
                            clrMask = clrMask << ioValue;
                            if (fastech.boardType == FASTECH_IO_BOARD_TYPE.EZI_IO_I16O16)
                            {
                                setMask = setMask << 16;
                                clrMask = clrMask << 16;
                            }

                            switch (fastech.connectionType)
                            {
                                case FASTECH_CONNECTION_TYPE.SERIAL:
                                    EziMOTIONPlusRLib.FAS_SetOutput(bytePort, fastech.ID, setMask, clrMask);
                                    break;

                                case FASTECH_CONNECTION_TYPE.ETHERNET:
                                    EziMOTIONPlusELib.FAS_SetOutput(fastech.ID, setMask, clrMask);
                                    break;
                            }
                        }
                        break;
                    }
                }
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
            }
        }

        /**
         * @brief IO 켜는 함수
         * @param[in] io DIGITAL INPUT/OUTPUT
         */
        public void On(object io)
        {
            try
            {
                int ioValue = Convert.ToInt32(io);
                int inputSize = 0;
                int outputSize = 0;
                bool isConnected = false;
                byte bytePort = 0;
                uint setMask = 0x01;
                uint clrMask = 0x00;

                if (io.GetType() != typeof(DO))
                {
                    return;
                }

                foreach (var fastech in ioList)
                {
                    GetBoardIOSize(fastech.boardType, ref inputSize, ref outputSize);
                    if (ioValue >= outputSize)
                    {
                        ioValue -= outputSize;
                    }
                    else
                    {
                        switch (fastech.connectionType)
                        {
                            case FASTECH_CONNECTION_TYPE.SERIAL:
                                SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                                string strPort = GetPortString(serial.PortName);
                                bytePort = byte.Parse(strPort);
                                uint baudRate = Convert.ToUInt32(serial.BaudRate);

                                isConnected = isPortConnected[bytePort];
                                break;

                            case FASTECH_CONNECTION_TYPE.ETHERNET:
                                IPAddress ip = (IPAddress)fastech.connectionInfo;
                                isConnected = isEthernetConnected[fastech.ID];
                                break;
                        }

                        if (!isConnected)
                        {
                            return;
                        }

                        // Motor 내장형
                        if (((fastech.objectType & FASTECH_OBJECT_TYPE.IO) != FASTECH_OBJECT_TYPE.NONE)
                            && ((fastech.objectType & FASTECH_OBJECT_TYPE.AXIS) != FASTECH_OBJECT_TYPE.NONE))
                        {
                            switch (fastech.axisType)
                            {
                                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V6:
                                    EziMOTIONPlusRLib.FAS_SetIOOutput(bytePort, fastech.ID, (uint)GetOutputLogic(fastech, ioValue), clrMask);
                                    break;

                                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                                    EziMOTIONPlusRV8Lib.FAS_SetIOOutput(bytePort, fastech.ID, (uint)GetOutputLogic(fastech, ioValue), clrMask);
                                    break;

                                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_E_V6:
                                    EziMOTIONPlusELib.FAS_SetIOOutput(fastech.ID, (uint)GetOutputLogic(fastech, ioValue), clrMask);
                                    break;

                                    // Motion link는 일단 보류
                                    /*
                                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V6:
                                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_E_V6:
                                    break;
                                    */
                            }
                        }
                        else
                        {
                            setMask = setMask << ioValue;

                            if (fastech.boardType == FASTECH_IO_BOARD_TYPE.EZI_IO_I16O16)
                            {
                                setMask = setMask << 16;
                                clrMask = clrMask << 16;
                            }

                            switch (fastech.connectionType)
                            {
                                case FASTECH_CONNECTION_TYPE.SERIAL:
                                    EziMOTIONPlusRLib.FAS_SetOutput(bytePort, fastech.ID, setMask, clrMask);
                                    break;

                                case FASTECH_CONNECTION_TYPE.ETHERNET:
                                    EziMOTIONPlusELib.FAS_SetOutput(fastech.ID, setMask, clrMask);
                                    break;
                            }
                        }
                        break;
                    }
                }
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
            }
        }

        public bool IsConnected()
        {
            try
            {
                bool ret = true;

                foreach (var fastechObjects in listFastechObjects)
                {
                    foreach (var fastech in fastechObjects)
                    {
                        if (fastech.connectionType == FASTECH_CONNECTION_TYPE.SERIAL)
                        {
                            SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                            string strPort = GetPortString(serial.PortName);
                            byte bytePort = byte.Parse(strPort);
                            uint baudRate = Convert.ToUInt32(serial.BaudRate);

                            ret &= isPortConnected[bytePort];
                            break;
                        }
                        else if (fastech.connectionType == FASTECH_CONNECTION_TYPE.ETHERNET)
                        {
                            IPAddress ip = (IPAddress)fastech.connectionInfo;
                            ret &= isEthernetConnected[fastech.ID];
                        }
                    }
                }

                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }

        /**
         * @brief 연결 되어 있는지 확인하는 함수
         * @param[in] axisIdx AXIS_LIST 번호
         * @return 연결 되어 있는지 여부
         */
        public bool IsConnected(object axisIdx)
        {
            try
            {
                bool isConnected = false;
                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];

                switch (fastech.connectionType)
                {
                    case FASTECH_CONNECTION_TYPE.SERIAL:
                        SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                        string strPort = GetPortString(serial.PortName);
                        byte bytePort = byte.Parse(strPort);

                        isConnected = isPortConnected[bytePort];
                        break;

                    case FASTECH_CONNECTION_TYPE.ETHERNET:
                        isConnected = isEthernetConnected[fastech.ID];
                        break;
                }

                return isConnected;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }

        /**
        * @brief Servo close 명령 함수
        * @param[in] axisIdx AXIS_LIST 번호
        */
        public void Close(object axisIdx)
        {
            try
            {
                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
                Close(fastech);
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
            }
        }

        /**
         * @brief fastech 연결을 끊는 함수(Serial은 같이 연결된 모든 제품이 다 같이 연결이 끊어진다.)
         * @parm[in] fastech 연결을 종료할 FastechObject
         */
        public void Close(FastechObject fastech)
        {
            try
            {
                switch (fastech.connectionType)
                {
                    case FASTECH_CONNECTION_TYPE.SERIAL:
                        SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                        string strPort = GetPortString(serial.PortName);
                        byte bytePort = byte.Parse(strPort);
                        uint baudRate = Convert.ToUInt32(serial.BaudRate);

                        isPortConnected[bytePort] = false;
                        switch (fastech.axisType)
                        {
                            case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                            case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                EziMOTIONPlusRV8Lib.FAS_Close(bytePort);
                                break;

                            default:
                                EziMOTIONPlusRLib.FAS_Close(bytePort);
                                break;
                        }
                        LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Serial connection close : {serial.PortName}", CONTENT_TYPE.DEBUG);
                        break;

                    case FASTECH_CONNECTION_TYPE.ETHERNET:
                        IPAddress ip = (IPAddress)fastech.connectionInfo;

                        isEthernetConnected[fastech.ID] = false;
                        EziMOTIONPlusELib.FAS_Close(fastech.ID);
                        LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Ethernet connection close : {ip.ToString()}", CONTENT_TYPE.DEBUG);
                        break;
                }
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
            }
        }

        /**
         * @brief fastech 연결을 끊는 함수
         * @parm[in] fastech 연결을 종료할 FastechObjects
         */
        public void Close(FastechObject[] fastechObjects)
        {
            try
            {
                foreach (var fastech in fastechObjects)
                {
                    switch (fastech.connectionType)
                    {
                        case FASTECH_CONNECTION_TYPE.SERIAL:
                            SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                            string strPort = GetPortString(serial.PortName);
                            byte bytePort = byte.Parse(strPort);
                            uint baudRate = Convert.ToUInt32(serial.BaudRate);

                            isPortConnected[bytePort] = false;
                            switch (fastech.axisType)
                            {
                                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                    EziMOTIONPlusRV8Lib.FAS_Close(bytePort);
                                    break;

                                default:
                                    EziMOTIONPlusRLib.FAS_Close(bytePort);
                                    break;
                            }
                            LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Serial connection close : {serial.PortName}", CONTENT_TYPE.DEBUG);
                            break;
                        case FASTECH_CONNECTION_TYPE.ETHERNET:
                            IPAddress ip = (IPAddress)fastech.connectionInfo;

                            isEthernetConnected[fastech.ID] = false;
                            EziMOTIONPlusELib.FAS_Close(fastech.ID);
                            LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Ethernet connection close : {ip.ToString()}", CONTENT_TYPE.DEBUG);
                            break;
                    }

                    // Serial은 Port 하나에 대해서만 수행하면 된다.
                    if (fastech.connectionType == FASTECH_CONNECTION_TYPE.SERIAL)
                    {
                        break;
                    }
                }
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
            }
        }

        /**
         * @brief 모든 fastech 연결을 끊는 함수
         */
        public void Close()
        {
            try
            {
                foreach (var fastechObjects in listFastechObjects)
                {
                    foreach (var fastech in fastechObjects)
                    {
                        switch (fastech.connectionType)
                        {
                            case FASTECH_CONNECTION_TYPE.SERIAL:
                                SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                                string strPort = GetPortString(serial.PortName);
                                byte bytePort = byte.Parse(strPort);
                                uint baudRate = Convert.ToUInt32(serial.BaudRate);

                                isPortConnected[bytePort] = false;
                                switch (fastech.axisType)
                                {
                                    case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                                    case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                        EziMOTIONPlusRV8Lib.FAS_Close(bytePort);
                                        break;

                                    default:
                                        EziMOTIONPlusRLib.FAS_Close(bytePort);
                                        break;
                                }
                                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Serial connection close : {serial.PortName}", CONTENT_TYPE.DEBUG);
                                break;

                            case FASTECH_CONNECTION_TYPE.ETHERNET:
                                IPAddress ip = (IPAddress)fastech.connectionInfo;

                                isEthernetConnected[fastech.ID] = false;
                                EziMOTIONPlusELib.FAS_Close(fastech.ID);
                                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Ethernet connection close : {ip.ToString()}", CONTENT_TYPE.DEBUG);
                                break;
                        }

                        // Serial은 Port 하나에 대해서만 수행하면 된다.
                        if (fastech.connectionType == FASTECH_CONNECTION_TYPE.SERIAL)
                        {
                            break;
                        }
                    }
                }
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
            }
        }

        /**
        * @brief FastechObject에 연결하는 함수
        * @param[in] axisIdx AXIS_LIST 번호
        */
        public bool Connect(object axisIdx)
        {
            try
            {
                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
                return Connect(fastech);
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }

        /**
         * @brief FastechObject에 연결하는 함수
         * @details FastechData에 정의해두었던 port 정보 또는 IPAddress를 기반으로 연결 시도
         * @param[in] 연결을 시도할 fastech(Serial은 같이 연결된 모든 제품이 다 같이 연결된다.)
         */
        public bool Connect(FastechObject fastech)
        {
            try
            {
                bool ret = true;
                int connectRet = TRUE;
                bool bConnectRet = true;

                switch (fastech.connectionType)
                {
                    case FASTECH_CONNECTION_TYPE.SERIAL:
                        SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                        string strPort = GetPortString(serial.PortName);
                        byte bytePort = byte.Parse(strPort);
                        uint baudRate = Convert.ToUInt32(serial.BaudRate);

                        switch (fastech.axisType)
                        {
                            case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                            case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                if (!isPortConnected[bytePort])
                                {
                                    connectRet = EziMOTIONPlusRV8Lib.FAS_Connect(bytePort, baudRate);
                                }

                                if (connectRet != FALSE)
                                {
                                    connectRet = EziMOTIONPlusRV8Lib.FAS_IsSlaveExist(bytePort, fastech.ID);
                                }
                                break;

                            default:
                                if (!isPortConnected[bytePort])
                                {
                                    connectRet = EziMOTIONPlusRLib.FAS_Connect(bytePort, baudRate);
                                }

                                if (connectRet != FALSE)
                                {
                                    connectRet = EziMOTIONPlusRLib.FAS_IsSlaveExist(bytePort, fastech.ID);
                                }
                                break;
                        }

                        if (connectRet != FALSE)
                        {
                            countRetryConnect = 0;
                            isPortConnected[bytePort] = true;
                            LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Serial connection success : {serial.PortName}", CONTENT_TYPE.DEBUG);
                            ret = true;
                        }
                        else
                        {
                            countRetryConnect++;
                            isPortConnected[bytePort] = false;
                            if (countRetryConnect <= 20)
                            {
                                LogUtil.Instance.Log(LOG_TYPE.INFO, $"Serial connection fail : {serial.PortName}", CONTENT_TYPE.DEBUG);
                            }
                            ret = false;
                        }
                        break;

                    case FASTECH_CONNECTION_TYPE.ETHERNET:
                        IPAddress ip = (IPAddress)fastech.connectionInfo;

                        bConnectRet = EziMOTIONPlusELib.FAS_ConnectTCP(ip, fastech.ID);
                        if (bConnectRet != false)
                        {
                            connectRet = EziMOTIONPlusELib.FAS_IsSlaveExist(fastech.ID);
                        }

                        if ((bConnectRet != false) && (connectRet != FALSE))
                        {
                            countRetryConnect = 0;
                            isEthernetConnected[fastech.ID] = true;
                            LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Ethernet connection success : {ip.ToString()}", CONTENT_TYPE.DEBUG);
                            ret = true;
                        }
                        else
                        {
                            countRetryConnect++;
                            isEthernetConnected[fastech.ID] = false;
                            if (countRetryConnect <= 20)
                            {
                                LogUtil.Instance.Log(LOG_TYPE.INFO, $"Ethernet connection fail : {ip.ToString()}", CONTENT_TYPE.DEBUG);
                            }
                            ret = false;
                        }
                        break;
                }

                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }

        /**
         * @brief FastechObject에 연결하는 함수
         * @details FastechData에 정의해두었던 port 정보 또는 IPAddress를 기반으로 연결 시도
         * @param[in] 연결을 시도할 fastechObjects
         */
        public bool Connect(FastechObject[] fastechObjects)
        {
            try
            {
                bool ret = true;
                int connectRet = TRUE;
                bool bConnectRet = true;

                foreach (var fastech in fastechObjects)
                {
                    switch (fastech.connectionType)
                    {
                        case FASTECH_CONNECTION_TYPE.SERIAL:
                            SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                            string strPort = GetPortString(serial.PortName);
                            byte bytePort = byte.Parse(strPort);
                            uint baudRate = Convert.ToUInt32(serial.BaudRate);

                            switch (fastech.axisType)
                            {
                                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                    if (!isPortConnected[bytePort])
                                    {
                                        connectRet = EziMOTIONPlusRV8Lib.FAS_Connect(bytePort, baudRate);
                                    }

                                    if (connectRet != FALSE)
                                    {
                                        connectRet = EziMOTIONPlusRV8Lib.FAS_IsSlaveExist(bytePort, fastech.ID);
                                    }
                                    break;

                                default:
                                    if (!isPortConnected[bytePort])
                                    {
                                        connectRet = EziMOTIONPlusRLib.FAS_Connect(bytePort, baudRate);
                                    }

                                    if (connectRet != FALSE)
                                    {
                                        connectRet = EziMOTIONPlusRLib.FAS_IsSlaveExist(bytePort, fastech.ID);
                                    }
                                    break;
                            }

                            if (connectRet != FALSE)
                            {
                                isPortConnected[bytePort] = true;
                                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Serial connection success : {serial.PortName}", CONTENT_TYPE.DEBUG);
                                ret &= true;
                            }
                            else
                            {
                                isPortConnected[bytePort] = false;
                                LogUtil.Instance.Log(LOG_TYPE.INFO, $"Serial connection fail : {serial.PortName}", CONTENT_TYPE.DEBUG);
                                ret &= false;
                            }
                            break;

                        case FASTECH_CONNECTION_TYPE.ETHERNET:
                            IPAddress ip = (IPAddress)fastech.connectionInfo;

                            bConnectRet = EziMOTIONPlusELib.FAS_ConnectTCP(ip, fastech.ID);
                            if (bConnectRet != false)
                            {
                                connectRet = EziMOTIONPlusELib.FAS_IsSlaveExist(fastech.ID);
                            }

                            if ((bConnectRet != false) && (connectRet != FALSE))
                            {
                                isEthernetConnected[fastech.ID] = true;
                                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Ethernet connection success : {ip.ToString()}", CONTENT_TYPE.DEBUG);
                                ret &= true;
                            }
                            else
                            {
                                isEthernetConnected[fastech.ID] = false;
                                LogUtil.Instance.Log(LOG_TYPE.INFO, $"Ethernet connection fail : {ip.ToString()}", CONTENT_TYPE.DEBUG);
                                ret &= false;
                            }
                            break;
                    }
                }

                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }

        /**
         * @brief 모든 FastechObject에 연결하는 함수
         * @details FastechData에 정의해두었던 port 정보 또는 IPAddress를 기반으로 연결 시도
         */
        public bool Connect()
        {
            try
            {
                bool ret = true;
                int connectRet = TRUE;
                bool bConnectRet = true;

                foreach (var fastechObjects in listFastechObjects)
                {
                    foreach (var fastech in fastechObjects)
                    {
                        switch (fastech.connectionType)
                        {
                            case FASTECH_CONNECTION_TYPE.SERIAL:
                                SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                                string strPort = GetPortString(serial.PortName);
                                byte bytePort = byte.Parse(strPort);
                                uint baudRate = Convert.ToUInt32(serial.BaudRate);

                                switch (fastech.axisType)
                                {
                                    case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                                    case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                        if (!isPortConnected[bytePort])
                                        {
                                            connectRet = EziMOTIONPlusRV8Lib.FAS_Connect(bytePort, baudRate);
                                        }

                                        if (connectRet != FALSE)
                                        {
                                            connectRet = EziMOTIONPlusRV8Lib.FAS_IsSlaveExist(bytePort, fastech.ID);
                                        }
                                        break;

                                    default:
                                        if (!isPortConnected[bytePort])
                                        {
                                            connectRet = EziMOTIONPlusRLib.FAS_Connect(bytePort, baudRate);
                                        }

                                        if (connectRet != FALSE)
                                        {
                                            connectRet = EziMOTIONPlusRLib.FAS_IsSlaveExist(bytePort, fastech.ID);
                                        }
                                        break;
                                }

                                if (connectRet != FALSE)
                                {
                                    isPortConnected[bytePort] = true;
                                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Serial connection success : {serial.PortName}", CONTENT_TYPE.DEBUG);
                                    ret &= true;
                                }
                                else
                                {
                                    isPortConnected[bytePort] = false;
                                    LogUtil.Instance.Log(LOG_TYPE.INFO, $"Serial connection fail : {serial.PortName}", CONTENT_TYPE.DEBUG);
                                    ret &= false;
                                }
                                break;

                            case FASTECH_CONNECTION_TYPE.ETHERNET:
                                IPAddress ip = (IPAddress)fastech.connectionInfo;

                                bConnectRet = EziMOTIONPlusELib.FAS_ConnectTCP(ip, fastech.ID);
                                if (bConnectRet != false)
                                {
                                    connectRet = EziMOTIONPlusELib.FAS_IsSlaveExist(fastech.ID);
                                }

                                if ((bConnectRet != false) && (connectRet != FALSE))
                                {
                                    isEthernetConnected[fastech.ID] = true;
                                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Ethernet connection success : {ip.ToString()}", CONTENT_TYPE.DEBUG);
                                    ret &= true;
                                }
                                else
                                {
                                    isEthernetConnected[fastech.ID] = false;
                                    LogUtil.Instance.Log(LOG_TYPE.INFO, $"Ethernet connection fail : {ip.ToString()}", CONTENT_TYPE.DEBUG);
                                    ret &= false;
                                }
                                break;
                        }
                    }
                }

                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }

        /**
         * @brief 현재 축의 위치를 리턴하는 함수
         * @param[out] type slave 수 만큼 현재 포지션 정보를 할당 받을 인자
         * @return 정상적으로 수행 되었는 여부
         */
        public bool GetCurrentPos(ref object[] type)
        {
            try
            {
                foreach (KeyValuePair<AXIS_LIST, FastechObject> var in axisList)
                {
                    FastechObject fastech = var.Value;
                    if (!IsConnected(var.Key))
                    {
                        continue;
                    }

                    decimal scale = Convert.ToDecimal(axisParamData[(int)var.Key].resolution) / Convert.ToDecimal(axisParamData[(int)var.Key].distance);
                    type[(uint)var.Key] = Convert.ToDecimal(fastech.fastechStatus.currentPos) * Convert.ToDecimal(((decimal)1 / scale));
                }

                return true;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }

        }

        /**
         * @brief 현재 축의 위치를 리턴하는 함수
         * @param[in] axisIdx AXIS_LIST 번호
         * @param[out] currentPos 인자로 넘어온 slave의 현재 축의 위치 mm
         * @return 정상적으로 수행 되었는 여부
         */
        public bool GetCurrentPos(object axisIdx, ref object currentPos)
        {
            try
            {
                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
                if (!IsConnected(axisIdx))
                {
                    return false;
                }

                decimal scale = Convert.ToDecimal(axisParamData[(int)axisIdx].resolution) / Convert.ToDecimal(axisParamData[(int)axisIdx].distance);
                //currentPos = Convert.ToDecimal(fastech.fastechStatus.currentPos) * Convert.ToDecimal(((decimal)1 / scale));

                /*
                 * Fix by hung96.tran
                 */
                //Nếu sv on thì Get số xung PGM phát ra, nếu SV off thì Get số xung Encoder phản hồi về.
                //Sử dụng trong trường hợp teaching bằng cách off sv kéo trục
                if (IsServoOn(axisIdx))
                {
                    currentPos = Convert.ToDecimal(fastech.fastechStatus.targetPos) * Convert.ToDecimal(((decimal)1 / scale));
                }
                else
                {
                    currentPos = Convert.ToDecimal(fastech.fastechStatus.currentPos) * Convert.ToDecimal(((decimal)1 / scale));
                }

                return true;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }

        /*
         * Add by hung96.tran
         */
        public decimal ScalePos(object axisIdx)
        {
            try
            {
                return Convert.ToDecimal(axisParamData[(int)axisIdx].resolution) / Convert.ToDecimal(axisParamData[(int)axisIdx].distance);
            }
            catch (Exception)
            {
                return 1;
            }

        }

        /**
         * @brief 현재 축의 위치를 리턴하는 함수
         * @param[in] axisIdx AXIS_LIST 번호
         * @param[out] currentPulse 인자로 넘어온 slave의 현재 축의 위치 pulse
         * @return 정상적으로 수행 되었는 여부
         */
        public bool GetCurrentPulse(object axisIdx, ref object currentPulse)
        {
            //try
            //{
            //    FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
            //    if (!IsConnected(axisIdx))
            //    {
            //        return false;
            //    }
            //    currentPulse = Convert.ToDouble(fastech.fastechStatus.currentPos);

            //    return true;
            //}
            //catch (Exception e)
            //{
            //    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
            //    return false;
            //}

            /*
             * Fix by hung96.tran
             */
            try
            {
                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
                if (!IsConnected(axisIdx))
                {
                    return false;
                }
                //Nếu sv on thì Get số xung PGM phát ra, nếu SV off thì Get số xung Encoder phản hồi về.
                //Sử dụng trong trường hợp teaching bằng cách off sv kéo trục
                if (IsServoOn(axisIdx))
                {
                    currentPulse = Convert.ToDecimal(fastech.fastechStatus.targetPos);
                }
                else
                {
                    currentPulse = Convert.ToDecimal(fastech.fastechStatus.currentPos);
                }


                return true;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }

        /**
         * @brief 축의 파라미터 값 읽어오는 함수
         * @param[in] servoParamFlag Fastech의 parameter flag 
         * @param[out] 모든 slave의 해당 flag의 축 파마리터 정보를 저장하는 매개변수
         * @return 정상적으로 수행 되었는 여부
         */
        public bool GetParameter(object servoParamFlag, ref object[] setValue)
        {
            try
            {
                byte flag = Convert.ToByte(servoParamFlag);
                int getValue = 0;
                bool ret = true;
                int libRet = FMM_OK;

                foreach (KeyValuePair<AXIS_LIST, FastechObject> var in axisList)
                {
                    FastechObject fastech = var.Value;
                    if (!IsConnected(var.Key))
                    {
                        ret &= false;
                        continue;
                    }

                    switch (fastech.connectionType)
                    {
                        case FASTECH_CONNECTION_TYPE.SERIAL:
                            SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                            string strPort = GetPortString(serial.PortName);
                            byte bytePort = byte.Parse(strPort);

                            switch (fastech.axisType)
                            {
                                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                    libRet = EziMOTIONPlusRV8Lib.FAS_GetParameter(bytePort, fastech.ID, flag, ref getValue);
                                    break;

                                default:
                                    libRet = EziMOTIONPlusRLib.FAS_GetParameter(bytePort, fastech.ID, flag, ref getValue);
                                    break;
                            }

                            if (libRet == FMM_OK)
                            {
                                setValue[(uint)var.Key] = (object)getValue;
                                ret &= true;
                            }
                            else
                            {
                                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"{var.Key} can't get parameter because of {libRet.ToString()}", CONTENT_TYPE.DEBUG);
                                ret &= false;
                            }
                            break;

                        case FASTECH_CONNECTION_TYPE.ETHERNET:
                            libRet = EziMOTIONPlusELib.FAS_GetParameter(fastech.ID, flag, ref getValue);
                            if (libRet == FMM_OK)
                            {
                                setValue[(uint)var.Key] = (object)getValue;
                                ret &= true;
                            }
                            else
                            {
                                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"{var.Key} can't get parameter because of {libRet.ToString()}", CONTENT_TYPE.DEBUG);
                                ret &= false;
                            }
                            break;
                    }
                }

                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }

        /**
         * @brief Fastech driver에서 사용하지 않음
         */
        public bool InitAxis()
        {
            throw new NotImplementedException();
        }

        /**
         * @brief Alarm 발생 체크 함수
         * @param[in] axisIdx AXIS_LIST 번호
         */
        public bool IsAlarmCheck(object axisIdx)
        {
            try
            {
                bool ret = false;
                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];

                if ((fastech.objectType & FASTECH_OBJECT_TYPE.AXIS) != FASTECH_OBJECT_TYPE.NONE)
                {
                    if (!CheckAxisStatus(axisIdx, (uint)AXISSTATUS.FFLAG_ERRORALL))
                    {
                        ret = true;
                    }
                }

                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }

        /**
         * @brief Fastech driver에서 사용하지 않음
         */
        public bool IsInitAxis()
        {
            throw new NotImplementedException();
        }

        /**
         * @brief Fastech driver에서 사용하지 않음
         */
        public bool IsMoveDone()
        {
            throw new NotImplementedException();
        }

        /**
         * @brief 이동이 완료 되었는지 확인하는 함수
         * @param[in] axisIdx AXIS_LIST 번호
         * @return 해당 slave가 이동 완료 상태인지 여부
         */
        public bool IsMoveDone(object axisIdx)
        {
            try
            {
                bool ret = false;
                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];

                /*if ((fastech.objectType & FASTECH_OBJECT_TYPE.AXIS) != FASTECH_OBJECT_TYPE.NONE)
                {
                    ret = (!CheckAxisStatus(axisIdx, (uint)AXISSTATUS.FFLAG_MOTIONING) && !CheckAxisStatus(axisIdx, (uint)AXISSTATUS.FFLAG_MOTIONACCEL)
                            && !CheckAxisStatus(axisIdx, (uint)AXISSTATUS.FFLAG_MOTIONCONST) && !CheckAxisStatus(axisIdx, (uint)AXISSTATUS.FFLAG_MOTIONDECEL));
                }*/
                if ((fastech.objectType & FASTECH_OBJECT_TYPE.AXIS) != FASTECH_OBJECT_TYPE.NONE)
                {
                    ret = (!CheckAxisStatus(axisIdx, (uint)AXISSTATUS.FFLAG_MOTIONING) && !CheckAxisStatus(axisIdx, (uint)AXISSTATUS.FFLAG_MOTIONACCEL)
                            && !CheckAxisStatus(axisIdx, (uint)AXISSTATUS.FFLAG_MOTIONCONST) && !CheckAxisStatus(axisIdx, (uint)AXISSTATUS.FFLAG_MOTIONDECEL)
                            && (axisParamData[(int)axisIdx].inpositionFlag ? CheckAxisStatus(axisIdx, (uint)AXISSTATUS.FFLAG_INPOSITION) : true));
                }

                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }

        /**
         * @brief 이동이 완료 되었는지 확인하는 함수
         * @param[out] ret 모든 AXIS_LIST에 대해 이동 완료 상태인지 확인 후 저장할 매개변수
         * @return 이동 완료 체크가 정상 수행되었는지 여부
         */
        public bool IsMoveDone(ref bool[] ret)
        {
            try
            {
                if (ret.Length == 0)
                {
                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, "Return parameter have to size bigger than 0", CONTENT_TYPE.DEBUG);
                    return false;
                }

                foreach (KeyValuePair<AXIS_LIST, FastechObject> var in axisList)
                {
                    FastechObject fastech = axisList[(AXIS_LIST)var.Key];
                    if ((fastech.objectType & FASTECH_OBJECT_TYPE.AXIS) != FASTECH_OBJECT_TYPE.NONE)
                    {
                        ret[(uint)var.Key] = (!CheckAxisStatus(var.Key, (uint)AXISSTATUS.FFLAG_MOTIONING) && !CheckAxisStatus(var.Key, (uint)AXISSTATUS.FFLAG_MOTIONACCEL)
                                    && !CheckAxisStatus(var.Key, (uint)AXISSTATUS.FFLAG_MOTIONCONST) && !CheckAxisStatus(var.Key, (uint)AXISSTATUS.FFLAG_MOTIONDECEL)
                                    && (axisParamData[(int)var.Key].inpositionFlag ? CheckAxisStatus(var.Key, (uint)AXISSTATUS.FFLAG_INPOSITION) : true));
                    }
                }
                return true;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }

        /**
         * @brief origin이 수행되었는지 확인하는 함수
         * @param[in] axisIdx AXIS_LIST 번호
         * @return origin 완료 여부
         */
        public bool IsOriginDone(object axisIdx)
        {
            try
            {
                bool ret = false;
                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];

                if ((fastech.objectType & FASTECH_OBJECT_TYPE.AXIS) != FASTECH_OBJECT_TYPE.NONE)
                {
                    ret = CheckAxisStatus(axisIdx, (uint)AXISSTATUS.FFLAG_ORIGINRETOK);
                }

                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }

        /**
         * @brief Fastech driver에서 사용하지 않음
         */
        public bool IsOriginDone()
        {
            throw new NotImplementedException();
        }

        /**
         * @brief Servo가 켜져 있는지 확인하는 함수
         * @param[in] arg AXIS_LIST 번호
         * @return Servo 켜져 있는지 여부
         */
        public bool IsServoOn(object axisIdx)
        {
            try
            {
                bool ret = false;
                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];

                if ((fastech.objectType & FASTECH_OBJECT_TYPE.AXIS) != FASTECH_OBJECT_TYPE.NONE)
                {
                    ret = CheckAxisStatus(axisIdx, (uint)AXISSTATUS.FFLAG_SERVOON);
                }

                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }

        /**
         * @brief 티칭용으로 조금씩 이동하는 명령을 수행하는 함수
         * @param[in] args [0] : AXIS_LIST 번호, [1] : direction
         * @return Jog Move 명령 정상 수행 여부
         */
        public bool JogMove(params object[] args)
        {
            try
            {
                bool ret = false;
                int libRet = FMM_OK;

                int axisIdx = Convert.ToInt32(args[(int)PARMS_ARG.SLAVE_NO]);
                double scale = Convert.ToDouble(axisParamData[(int)axisIdx].resolution) / Convert.ToDouble(axisParamData[(int)axisIdx].distance);
                bool direction = Convert.ToBoolean(args[(int)PARMS_ARG.FLAG]);
                uint vel = 0;
                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];

                if (!IsConnected(axisIdx))
                {
                    return false;
                }
                if (args.Length == 3)
                {
                    LEVEL_SPEED speed = LEVEL_SPEED.SLOW;
                    //string speed = args[(int)PARMS_ARG.VALUE].ToString();
                    decimal nVel = 0;

                    if (decimal.TryParse(args[(int)PARMS_ARG.VALUE].ToString(), out nVel))
                    {
                        vel = (uint)nVel * (uint)scale;
                    }
                    else if (Enum.TryParse(args[(int)PARMS_ARG.VALUE].ToString().ToUpper(), out speed))
                    {
                        switch (speed)
                        {
                            case LEVEL_SPEED.SLOW:
                                vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_low);
                                break;
                            case LEVEL_SPEED.NORMAL:
                                vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_medium);
                                break;
                            case LEVEL_SPEED.HIGH:
                                vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                                break;
                            default:
                                vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                                break;
                        }
                    }
                    else
                    {
                        vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                    }

                }
                else
                {
                    vel = Convert.ToUInt32(axisParamData[(int)axisIdx].jogVel);
                }

                switch (fastech.connectionType)
                {
                    case FASTECH_CONNECTION_TYPE.SERIAL:
                        SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                        string strPort = GetPortString(serial.PortName);
                        byte bytePort = byte.Parse(strPort);

                        switch (fastech.axisType)
                        {
                            case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                            case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                libRet = EziMOTIONPlusRV8Lib.FAS_MoveVelocity(bytePort, fastech.ID, vel, (direction ? 1 : 0));
                                break;

                            default:
                                libRet = EziMOTIONPlusRLib.FAS_MoveVelocity(bytePort, fastech.ID, vel, (direction ? 1 : 0));
                                break;
                        }
                        break;

                    case FASTECH_CONNECTION_TYPE.ETHERNET:
                        libRet = EziMOTIONPlusELib.FAS_MoveVelocity(fastech.ID, vel, (direction ? 1 : 0));
                        break;
                }

                if (libRet == FMM_OK)
                {
                    ret = true;
                }
                else
                {
                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"(AXIS_LIST)axisIdx Can't move with jog control", CONTENT_TYPE.DEBUG);
                    ret = false;
                }

                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }

        /**
         * @brief 이동 정지 함수
         * @param[in] axisIdx AXIS_LIST 번호
         * @return 정상 수행 여부
         */
        public bool MoveStop(object axisIdx)
        {
            try
            {
                bool ret = false;
                int libRet = FMM_OK;
                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];

                if (!IsConnected(axisIdx))
                {
                    return false;
                }

                switch (fastech.connectionType)
                {
                    case FASTECH_CONNECTION_TYPE.SERIAL:
                        SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                        string strPort = GetPortString(serial.PortName);
                        byte bytePort = byte.Parse(strPort);

                        switch (fastech.axisType)
                        {
                            case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                            case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                libRet = EziMOTIONPlusRV8Lib.FAS_MoveStop(bytePort, fastech.ID);
                                break;

                            default:
                                libRet = EziMOTIONPlusRLib.FAS_MoveStop(bytePort, fastech.ID);
                                break;
                        }
                        break;

                    case FASTECH_CONNECTION_TYPE.ETHERNET:
                        libRet = EziMOTIONPlusELib.FAS_MoveStop(fastech.ID);
                        break;
                }

                if (libRet == FMM_OK)
                {
                    ret = true;
                }
                else
                {
                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"{(AXIS_LIST)axisIdx} can't stop", CONTENT_TYPE.DEBUG);
                    ret = false;
                }

                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }

        /**
         * @brief AXIS_LIST에 등록 된 모든 축이동 정지 명령 함수
         * @return 정지명령 정상 수행 여부
         */
        public bool MoveStop()
        {
            try
            {
                bool ret = true;
                int libRet = FMM_OK;

                foreach (KeyValuePair<AXIS_LIST, FastechObject> var in axisList)
                {
                    FastechObject fastech = var.Value;
                    if (!IsConnected(var.Key))
                    {
                        ret &= false;
                        continue;
                    }

                    switch (fastech.connectionType)
                    {
                        case FASTECH_CONNECTION_TYPE.SERIAL:
                            SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                            string strPort = GetPortString(serial.PortName);
                            byte bytePort = byte.Parse(strPort);

                            switch (fastech.axisType)
                            {
                                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                    libRet = EziMOTIONPlusRV8Lib.FAS_MoveStop(bytePort, fastech.ID);
                                    break;

                                default:
                                    libRet = EziMOTIONPlusRLib.FAS_MoveStop(bytePort, fastech.ID);
                                    break;
                            }
                            break;

                        case FASTECH_CONNECTION_TYPE.ETHERNET:
                            libRet = EziMOTIONPlusELib.FAS_MoveStop(fastech.ID);
                            break;
                    }

                    if (libRet == FMM_OK)
                    {
                        ret &= true;
                    }
                    else
                    {
                        LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"{(AXIS_LIST)var.Key} can't stop", CONTENT_TYPE.DEBUG);
                        ret &= false;
                    }
                }

                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }

        /**
         * @brief 원하는 목적지로 이동 명령 함수
         * @param[in] args [0] : AXIS_LIST 번호, [1] : target position, [2] : velocity (optional)
         * @return 정지명령 정상 수행 여부
         */
        public bool MoveTargetPos(params object[] args)
        {
            #region Old Code
            //try
            //{
            //    bool ret = true;
            //    int libRet = FMM_OK;
            //    uint vel = 0;

            //    int axisIdx = Convert.ToInt32(args[(int)PARMS_ARG.SLAVE_NO]);
            //    double scale = Convert.ToDouble(axisParamData[(int)axisIdx].resolution) / Convert.ToDouble(axisParamData[(int)axisIdx].distance);
            //    int targetPos = Convert.ToInt32(Convert.ToDouble(args[(int)PARMS_ARG.FLAG]) * scale);

            //    if (args.Length == 3)
            //    {
            //        vel = Convert.ToUInt32(Convert.ToDouble(args[(int)PARMS_ARG.VALUE]) * scale);
            //    }
            //    else
            //    {
            //        vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel);
            //    }

            //    FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
            //    if (!IsConnected(axisIdx))
            //    {
            //        return false;
            //    }

            //    switch (fastech.connectionType)
            //    {
            //        case FASTECH_CONNECTION_TYPE.SERIAL:
            //            SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
            //            string strPort = GetPortString(serial.PortName);
            //            byte bytePort = byte.Parse(strPort);

            //            switch (fastech.axisType)
            //            {
            //                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
            //                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
            //                    libRet = EziMOTIONPlusRV8Lib.FAS_MoveSingleAxisAbsPos(bytePort, fastech.ID, targetPos, vel);
            //                    break;

            //                default:
            //                    libRet = EziMOTIONPlusRLib.FAS_MoveSingleAxisAbsPos(bytePort, fastech.ID, targetPos, vel);
            //                    break;
            //            }
            //            break;

            //        case FASTECH_CONNECTION_TYPE.ETHERNET:
            //            libRet = EziMOTIONPlusELib.FAS_MoveSingleAxisAbsPos(fastech.ID, targetPos, vel);
            //            break;
            //    }

            //    if (libRet == FMM_OK)
            //    {
            //        ret = true;
            //    }
            //    else
            //    {
            //        LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Fail to move {axisIdx} to {targetPos} because of {ret.ToString()}", CONTENT_TYPE.DEBUG);
            //        ret = false;
            //    }

            //    return ret;
            //}
            //catch (Exception e)
            //{
            //    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
            //    return false;
            //}
            #endregion

            try
            {
                bool ret = true;
                int libRet = FMM_OK;
                uint vel = 0;

                int axisIdx = Convert.ToInt32(args[(int)PARMS_ARG.SLAVE_NO]);
                double scale = Convert.ToDouble(axisParamData[(int)axisIdx].resolution) / Convert.ToDouble(axisParamData[(int)axisIdx].distance);
                int targetPos = Convert.ToInt32(Convert.ToDouble(args[(int)PARMS_ARG.FLAG]) * scale);

                if (args.Length == 3)
                {
                    LEVEL_SPEED speed = LEVEL_SPEED.SLOW;
                    //string speed = args[(int)PARMS_ARG.VALUE].ToString();
                    decimal nVel = 0;

                    if (decimal.TryParse(args[(int)PARMS_ARG.VALUE].ToString(), out nVel))
                    {
                        vel = (uint)(nVel * (decimal)scale);
                    }
                    else if (Enum.TryParse(args[(int)PARMS_ARG.VALUE].ToString().ToUpper(), out speed))
                    {
                        switch (speed)
                        {
                            case LEVEL_SPEED.SLOW:
                                vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_low);
                                break;
                            case LEVEL_SPEED.NORMAL:
                                vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_medium);
                                break;
                            case LEVEL_SPEED.HIGH:
                                vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                                break;
                            default:
                                vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                                break;
                        }
                    }
                    else
                    {
                        vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                    }

                }
                else
                {
                    vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                }

                //if (args.Length == 3)
                //{
                //    vel = Convert.ToUInt32(Convert.ToDouble(args[(int)PARMS_ARG.VALUE]) * scale);
                //}
                //else
                //{
                //    vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel);
                //}

                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
                if (!IsConnected(axisIdx))
                {
                    return false;
                }

                switch (fastech.connectionType)
                {
                    case FASTECH_CONNECTION_TYPE.SERIAL:
                        SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                        string strPort = GetPortString(serial.PortName);
                        byte bytePort = byte.Parse(strPort);

                        switch (fastech.axisType)
                        {
                            case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                            case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                libRet = EziMOTIONPlusRV8Lib.FAS_MoveSingleAxisAbsPos(bytePort, fastech.ID, targetPos, vel);
                                break;

                            default:
                                libRet = EziMOTIONPlusRLib.FAS_MoveSingleAxisAbsPos(bytePort, fastech.ID, targetPos, vel);
                                break;
                        }
                        break;

                    case FASTECH_CONNECTION_TYPE.ETHERNET:
                        libRet = EziMOTIONPlusELib.FAS_MoveSingleAxisAbsPos(fastech.ID, targetPos, vel);
                        break;
                }

                if (libRet == FMM_OK)
                {
                    ret = true;
                }
                else
                {
                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Fail to move {axisIdx} to {targetPos} because of {ret.ToString()}", CONTENT_TYPE.DEBUG);
                    ret = false;
                }

                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }
        public bool MoveTargetPosInc(params object[] args)
        {
            #region Old Code
            //try
            //{
            //    bool ret = true;
            //    int libRet = FMM_OK;
            //    uint vel = 0;

            //    int axisIdx = Convert.ToInt32(args[(int)PARMS_ARG.SLAVE_NO]);
            //    double scale = Convert.ToDouble(axisParamData[(int)axisIdx].resolution) / Convert.ToDouble(axisParamData[(int)axisIdx].distance);
            //    int targetPos = Convert.ToInt32(Convert.ToDouble(args[(int)PARMS_ARG.FLAG]) * scale);

            //    if (args.Length == 3)
            //    {
            //        vel = Convert.ToUInt32(Convert.ToDouble(args[(int)PARMS_ARG.VALUE]) * scale);
            //    }
            //    else
            //    {
            //        vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel);
            //    }

            //    FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
            //    if (!IsConnected(axisIdx))
            //    {
            //        return false;
            //    }

            //    switch (fastech.connectionType)
            //    {
            //        case FASTECH_CONNECTION_TYPE.SERIAL:
            //            SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
            //            string strPort = GetPortString(serial.PortName);
            //            byte bytePort = byte.Parse(strPort);

            //            switch (fastech.axisType)
            //            {
            //                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
            //                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
            //                    libRet = EziMOTIONPlusRV8Lib.FAS_MoveSingleAxisAbsPos(bytePort, fastech.ID, targetPos, vel);
            //                    break;

            //                default:
            //                    libRet = EziMOTIONPlusRLib.FAS_MoveSingleAxisAbsPos(bytePort, fastech.ID, targetPos, vel);
            //                    break;
            //            }
            //            break;

            //        case FASTECH_CONNECTION_TYPE.ETHERNET:
            //            libRet = EziMOTIONPlusELib.FAS_MoveSingleAxisAbsPos(fastech.ID, targetPos, vel);
            //            break;
            //    }

            //    if (libRet == FMM_OK)
            //    {
            //        ret = true;
            //    }
            //    else
            //    {
            //        LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Fail to move {axisIdx} to {targetPos} because of {ret.ToString()}", CONTENT_TYPE.DEBUG);
            //        ret = false;
            //    }

            //    return ret;
            //}
            //catch (Exception e)
            //{
            //    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
            //    return false;
            //}
            #endregion

            try
            {
                bool ret = true;
                int libRet = FMM_OK;
                uint vel = 0;

                int axisIdx = Convert.ToInt32(args[(int)PARMS_ARG.SLAVE_NO]);
                double scale = Convert.ToDouble(axisParamData[(int)axisIdx].resolution) / Convert.ToDouble(axisParamData[(int)axisIdx].distance);
                int targetPos = Convert.ToInt32(Convert.ToDouble(args[(int)PARMS_ARG.FLAG]) * scale);

                if (args.Length == 3)
                {
                    LEVEL_SPEED speed = LEVEL_SPEED.SLOW;
                    //string speed = args[(int)PARMS_ARG.VALUE].ToString();
                    decimal nVel = 0;

                    if (decimal.TryParse(args[(int)PARMS_ARG.VALUE].ToString(), out nVel))
                    {
                        vel = (uint)nVel * (uint)scale;
                    }
                    else if (Enum.TryParse(args[(int)PARMS_ARG.VALUE].ToString().ToUpper(), out speed))
                    {
                        switch (speed)
                        {
                            case LEVEL_SPEED.SLOW:
                                vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_low);
                                break;
                            case LEVEL_SPEED.NORMAL:
                                vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_medium);
                                break;
                            case LEVEL_SPEED.HIGH:
                                vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                                break;
                            default:
                                vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                                break;
                        }
                    }
                    else
                    {
                        vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                    }

                }
                else
                {
                    vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                }

                //if (args.Length == 3)
                //{
                //    vel = Convert.ToUInt32(Convert.ToDouble(args[(int)PARMS_ARG.VALUE]) * scale);
                //}
                //else
                //{
                //    vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel);
                //}

                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
                if (!IsConnected(axisIdx))
                {
                    return false;
                }

                switch (fastech.connectionType)
                {
                    //case FASTECH_CONNECTION_TYPE.SERIAL:
                    //    SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                    //    string strPort = GetPortString(serial.PortName);
                    //    byte bytePort = byte.Parse(strPort);

                    //    switch (fastech.axisType)
                    //    {
                    //        case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                    //        case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                    //            libRet = EziMOTIONPlusRV8Lib.FAS_MoveSingleAxisAbsPos(bytePort, fastech.ID, targetPos, vel);
                    //            break;

                    //        default:
                    //            libRet = EziMOTIONPlusRLib.FAS_MoveSingleAxisAbsPos(bytePort, fastech.ID, targetPos, vel);
                    //            break;
                    //    }
                    //    break;

                    case FASTECH_CONNECTION_TYPE.ETHERNET:
                        libRet = EziMOTIONPlusELib.FAS_MoveSingleAxisIncPos(fastech.ID, targetPos, vel);
                        break;
                }

                if (libRet == FMM_OK)
                {
                    ret = true;
                }
                else
                {
                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Fail to move {axisIdx} to {targetPos} because of {ret.ToString()}", CONTENT_TYPE.DEBUG);
                    ret = false;
                }

                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }

        public bool MoveTargetPos_Interpolation(object[] axisLinear, decimal[] lplAbsPos, params object[] args)
        {
            try
            {
                if (axisLinear is null || lplAbsPos is null) return false;
                if (axisLinear.Length < 2 || lplAbsPos.Length < 2) return false;

                bool ret = true;
                int libRet = FMM_OK;
                uint vel = 0;

                int axisIdx = Convert.ToInt32(axisLinear[0]);
                double scale = Convert.ToDouble(axisParamData[(int)axisIdx].resolution) / Convert.ToDouble(axisParamData[(int)axisIdx].distance);
                int[] targetPos = new int[lplAbsPos.Length];
                for (int i = 0; i < targetPos.Length; i++)
                {
                    double scaleIdx = Convert.ToDouble(axisParamData[Convert.ToInt32(axisLinear[i])].resolution) / Convert.ToDouble(axisParamData[Convert.ToInt32(axisLinear[i])].distance);
                    targetPos[i] = Convert.ToInt32(Convert.ToDouble(lplAbsPos[i]) * scaleIdx);
                }

                if (args.Length == 3)
                {
                    LEVEL_SPEED speed = LEVEL_SPEED.SLOW;
                    //string speed = args[(int)PARMS_ARG.VALUE].ToString();
                    decimal nVel = 0;

                    if (decimal.TryParse(args[(int)PARMS_ARG.VALUE].ToString(), out nVel))
                    {
                        vel = (uint)nVel * (uint)scale;
                    }
                    else if (Enum.TryParse(args[(int)PARMS_ARG.VALUE].ToString().ToUpper(), out speed))
                    {
                        switch (speed)
                        {
                            case LEVEL_SPEED.SLOW:
                                vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_low);
                                break;
                            case LEVEL_SPEED.NORMAL:
                                vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_medium);
                                break;
                            case LEVEL_SPEED.HIGH:
                                vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                                break;
                            default:
                                vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                                break;
                        }
                    }
                    else
                    {
                        vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                    }

                }
                else
                {
                    vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                }

                //if (args.Length == 3)
                //{
                //    vel = Convert.ToUInt32(Convert.ToDouble(args[(int)PARMS_ARG.VALUE]) * scale);
                //}
                //else
                //{
                //    vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel);
                //}

                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
                if (!IsConnected(axisIdx))
                {
                    return false;
                }

                switch (fastech.connectionType)
                {
                    case FASTECH_CONNECTION_TYPE.SERIAL:
                        SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                        string strPort = GetPortString(serial.PortName);
                        byte bytePort = byte.Parse(strPort);
                        byte[] iID_R = new byte[axisLinear.Length];
                        for (int i = 0; i < axisLinear.Length; i++)
                        {
                            iID_R[i] = (byte)axisList[(AXIS_LIST)(int.Parse(axisLinear[i].ToString()))].ID;
                        }
                        switch (fastech.axisType)
                        {
                            case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                            case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                libRet = EziMOTIONPlusRV8Lib.FAS_MoveLinearAbsPos(bytePort, (byte)iID_R.Length, iID_R, targetPos, vel, ushort.Parse(axisParamData[(int)axisIdx].acc.ToString()));
                                break;

                            default:
                                libRet = EziMOTIONPlusRV8Lib.FAS_MoveLinearAbsPos(bytePort, (byte)iID_R.Length, iID_R, targetPos, vel, ushort.Parse(axisParamData[(int)axisIdx].acc.ToString()));
                                break;
                        }
                        break;

                    case FASTECH_CONNECTION_TYPE.ETHERNET:
                        int[] iID_E = new int[axisLinear.Length];
                        for (int i = 0; i < axisLinear.Length; i++)
                        {
                            int idx = Convert.ToInt32(axisLinear[i]);
                            iID_E[i] = (int)axisList[(AXIS_LIST)(idx)].ID;
                        }
                        libRet = EziMOTIONPlusELib.FAS_MoveLinearAbsPos2((byte)iID_E.Length, iID_E, targetPos, vel, ushort.Parse(axisParamData[(int)axisIdx].acc.ToString()));
                        break;
                }

                if (libRet == FMM_OK)
                {
                    ret = true;
                }
                else
                {
                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Fail to move {axisIdx} to {targetPos} because of {ret.ToString()}", CONTENT_TYPE.DEBUG);
                    ret = false;
                }

                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }

        public bool MoveTargetPosInc_Interpolation(object[] axisLinear, decimal[] lplIncPos, params object[] args)
        {
            try
            {
                if (axisLinear is null || lplIncPos is null) return false;
                if (axisLinear.Length < 2 || lplIncPos.Length < 2) return false;

                bool ret = true;
                int libRet = FMM_OK;
                uint vel = 0;

                int axisIdx = Convert.ToInt32(axisLinear[0]);
                double scale = Convert.ToDouble(axisParamData[(int)axisIdx].resolution) / Convert.ToDouble(axisParamData[(int)axisIdx].distance);
                int[] targetPos = new int[lplIncPos.Length];
                for (int i = 0; i < targetPos.Length; i++)
                {
                    targetPos[i] = Convert.ToInt32(Convert.ToDouble(lplIncPos[i]) * scale);
                }

                if (args.Length == 3)
                {
                    LEVEL_SPEED speed = LEVEL_SPEED.SLOW;
                    //string speed = args[(int)PARMS_ARG.VALUE].ToString();
                    decimal nVel = 0;

                    if (decimal.TryParse(args[(int)PARMS_ARG.VALUE].ToString(), out nVel))
                    {
                        vel = (uint)nVel * (uint)scale;
                    }
                    else if (Enum.TryParse(args[(int)PARMS_ARG.VALUE].ToString().ToUpper(), out speed))
                    {
                        switch (speed)
                        {
                            case LEVEL_SPEED.SLOW:
                                vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_low);
                                break;
                            case LEVEL_SPEED.NORMAL:
                                vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_medium);
                                break;
                            case LEVEL_SPEED.HIGH:
                                vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                                break;
                            default:
                                vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                                break;
                        }
                    }
                    else
                    {
                        vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                    }

                }
                else
                {
                    vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                }

                //if (args.Length == 3)
                //{
                //    vel = Convert.ToUInt32(Convert.ToDouble(args[(int)PARMS_ARG.VALUE]) * scale);
                //}
                //else
                //{
                //    vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel);
                //}

                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
                if (!IsConnected(axisIdx))
                {
                    return false;
                }

                switch (fastech.connectionType)
                {
                    //case FASTECH_CONNECTION_TYPE.SERIAL:
                    //    SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                    //    string strPort = GetPortString(serial.PortName);
                    //    byte bytePort = byte.Parse(strPort);

                    //    switch (fastech.axisType)
                    //    {
                    //        case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                    //        case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                    //            libRet = EziMOTIONPlusRV8Lib.FAS_MoveSingleAxisAbsPos(bytePort, fastech.ID, targetPos, vel);
                    //            break;

                    //        default:
                    //            libRet = EziMOTIONPlusRLib.FAS_MoveSingleAxisAbsPos(bytePort, fastech.ID, targetPos, vel);
                    //            break;
                    //    }
                    //    break;

                    case FASTECH_CONNECTION_TYPE.ETHERNET:
                        int[] iID_E = new int[axisLinear.Length];
                        for (int i = 0; i < axisLinear.Length; i++)
                        {
                            iID_E[i] = (int)axisLinear[i];
                        }
                        libRet = EziMOTIONPlusELib.FAS_MoveLinearIncPos2(fastech.ID, iID_E, targetPos, vel, ushort.Parse(axisParamData[(int)axisIdx].acc.ToString()));
                        break;
                }

                if (libRet == FMM_OK)
                {
                    ret = true;
                }
                else
                {
                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Fail to move {axisIdx} to {targetPos} because of {ret.ToString()}", CONTENT_TYPE.DEBUG);
                    ret = false;
                }

                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }

        /*
         * Add by hung96.tran
         * PARMS_ARG.VALUE = true: Run LowSpeed,
         * PARMS_ARG.VALUE = false or Not set: Run HighSpeed
         * PARMS_ARG.VALUE = 12345: Run with value input
         */
        public bool MoveTargetPulse(params object[] args)
        {
            try
            {
                bool ret = true;
                int libRet = FMM_OK;
                uint vel = 0;

                int axisIdx = Convert.ToInt32(args[(int)PARMS_ARG.SLAVE_NO]);
                double scale = Convert.ToDouble(axisParamData[(int)axisIdx].resolution) / Convert.ToDouble(axisParamData[(int)axisIdx].distance);
                int targetPos = Convert.ToInt32(Convert.ToDouble(args[(int)PARMS_ARG.FLAG]));

                if (args.Length == 3)
                {
                    string speed = args[(int)PARMS_ARG.VALUE].ToString();
                    //uint nVel = 0;

                    switch (speed)
                    {
                        case "SLOW":
                            vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_low);
                            break;
                        case "NORMAL":
                            vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_medium);
                            break;
                        case "HIGH":
                            vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                            break;
                        default:
                            vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_low);
                            break;
                    }
                    //bool bVel_low = false;
                    //uint nVel = 0;
                    //if (bool.TryParse(args[(int)PARMS_ARG.VALUE].ToString(), out bVel_low))
                    //{
                    //    if (Convert.ToBoolean(args[(int)PARMS_ARG.VALUE]))
                    //    {
                    //        vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_low);
                    //    }
                    //    else
                    //    {
                    //        vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                    //    }
                    //}
                    //else if (uint.TryParse(args[(int)PARMS_ARG.VALUE].ToString(), out nVel))
                    //{
                    //    vel = nVel * (uint)scale;
                    //}
                    //else
                    //{
                    //    vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                    //}

                }
                else
                {
                    vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                }

                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
                if (!IsConnected(axisIdx))
                {
                    return false;
                }

                switch (fastech.connectionType)
                {
                    case FASTECH_CONNECTION_TYPE.SERIAL:
                        SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                        string strPort = GetPortString(serial.PortName);
                        byte bytePort = byte.Parse(strPort);

                        switch (fastech.axisType)
                        {
                            case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                            case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                libRet = EziMOTIONPlusRV8Lib.FAS_MoveSingleAxisAbsPos(bytePort, fastech.ID, targetPos, vel);
                                break;

                            default:
                                libRet = EziMOTIONPlusRLib.FAS_MoveSingleAxisAbsPos(bytePort, fastech.ID, targetPos, vel);
                                break;
                        }
                        break;

                    case FASTECH_CONNECTION_TYPE.ETHERNET:
                        libRet = EziMOTIONPlusELib.FAS_MoveSingleAxisAbsPos(fastech.ID, targetPos, vel);
                        break;
                }

                if (libRet == FMM_OK)
                {
                    ret = true;
                }
                else
                {
                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Fail to move {axisIdx} to {targetPos} because of {ret.ToString()}", CONTENT_TYPE.DEBUG);
                    ret = false;
                }

                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }


        /**
         * @brief Origin 이동 함수
         * @param[in] axisIdx AXIS_LIST 번호
         * @return Origin 명령 정상 수행 여부
         */
        public bool MoveToOrigin(object axisIdx)
        {
            try
            {
                bool ret = true;
                int libRet = FMM_OK;

                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
                if (!IsConnected(axisIdx))
                {
                    return false;
                }

                switch (fastech.connectionType)
                {
                    case FASTECH_CONNECTION_TYPE.SERIAL:
                        SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                        string strPort = GetPortString(serial.PortName);
                        byte bytePort = byte.Parse(strPort);

                        switch (fastech.axisType)
                        {
                            case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                            case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                libRet = EziMOTIONPlusRV8Lib.FAS_MoveOriginSingleAxis(bytePort, fastech.ID);
                                break;

                            default:
                                libRet = EziMOTIONPlusRLib.FAS_MoveOriginSingleAxis(bytePort, fastech.ID);
                                break;
                        }
                        break;

                    case FASTECH_CONNECTION_TYPE.ETHERNET:
                        libRet = EziMOTIONPlusELib.FAS_MoveOriginSingleAxis(fastech.ID);
                        break;
                }

                if (libRet == FMM_OK)
                {
                    ret = true;
                }
                else
                {
                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Fail to move {axisIdx} to Origin because of {ret.ToString()}", CONTENT_TYPE.DEBUG);
                    ret = false;
                }

                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }

        /**
         * @brief Origin 이동 함수
         * @details 모든 축 origin 이동
         * @return Origin 명령 정상 수행 여부
         */
        public bool MoveToOrigin()
        {
            try
            {
                bool ret = true;
                int libRet = FMM_OK;

                foreach (KeyValuePair<AXIS_LIST, FastechObject> var in axisList)
                {
                    FastechObject fastech = var.Value;
                    if (!IsConnected(var.Key))
                    {
                        ret &= false;
                        continue;
                    }

                    switch (fastech.connectionType)
                    {
                        case FASTECH_CONNECTION_TYPE.SERIAL:
                            SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                            string strPort = GetPortString(serial.PortName);
                            byte bytePort = byte.Parse(strPort);

                            switch (fastech.axisType)
                            {
                                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                    libRet = EziMOTIONPlusRV8Lib.FAS_MoveOriginSingleAxis(bytePort, fastech.ID);
                                    break;

                                default:
                                    libRet = EziMOTIONPlusRLib.FAS_MoveOriginSingleAxis(bytePort, fastech.ID);
                                    break;
                            }

                            if (libRet == FMM_OK)
                            {
                                ret &= true;
                            }
                            else
                            {
                                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Fail to move {var.Key} to Origin because of {libRet.ToString()}", CONTENT_TYPE.DEBUG);
                                ret &= false;
                            }
                            break;

                        case FASTECH_CONNECTION_TYPE.ETHERNET:
                            libRet = EziMOTIONPlusELib.FAS_MoveOriginSingleAxis(fastech.ID);
                            if (libRet == FMM_OK)
                            {
                                ret &= true;
                            }
                            else
                            {
                                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Fail to move {var.Key} to Origin because of {libRet.ToString()}", CONTENT_TYPE.DEBUG);
                                ret &= false;
                            }
                            break;
                    }
                }

                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }

        /**
         * @brief Alarm clear 함수
         * @param[in] axisIdx AXIS_LIST 번호
         * @return Alarm clear 명령 정상 수행 여부
         */
        public bool ResetServoAlarm(object axisIdx = null)
        {
            try
            {
                bool ret = true;
                int libRet = FMM_OK;

                if (axisIdx == null)
                {
                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, "Axis index is null", CONTENT_TYPE.DEBUG);
                    return false;
                }

                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
                if (!IsConnected(axisIdx))
                {
                    return false;
                }

                switch (fastech.connectionType)
                {
                    case FASTECH_CONNECTION_TYPE.SERIAL:
                        SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                        string strPort = GetPortString(serial.PortName);
                        byte bytePort = byte.Parse(strPort);

                        switch (fastech.axisType)
                        {
                            case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                            case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                libRet = EziMOTIONPlusRV8Lib.FAS_ServoAlarmReset(bytePort, fastech.ID);
                                break;

                            default:
                                libRet = EziMOTIONPlusRLib.FAS_ServoAlarmReset(bytePort, fastech.ID);
                                break;
                        }
                        break;

                    case FASTECH_CONNECTION_TYPE.ETHERNET:
                        libRet = EziMOTIONPlusELib.FAS_ServoAlarmReset(fastech.ID);
                        break;
                }

                if (libRet == FMM_OK)
                {
                    ret = true;
                }
                else
                {
                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Fail to reset {(AXIS_LIST)axisIdx} servo alarm because of {libRet.ToString()}", CONTENT_TYPE.DEBUG);
                    ret = false;
                }

                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }

        /**
         * @brief Alarm clear 함수
         * @details 모든 축 alarm clear 
         * @return Alarm clear 명령 정상 수행 여부
         */
        public bool ResetServoAlarm()
        {
            try
            {
                bool ret = true;
                int libRet = FMM_OK;

                foreach (KeyValuePair<AXIS_LIST, FastechObject> var in axisList)
                {
                    FastechObject fastech = var.Value;
                    if (!IsConnected(var.Key))
                    {
                        continue;
                    }

                    switch (fastech.connectionType)
                    {
                        case FASTECH_CONNECTION_TYPE.SERIAL:
                            SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                            string strPort = GetPortString(serial.PortName);
                            byte bytePort = byte.Parse(strPort);

                            switch (fastech.axisType)
                            {
                                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                    libRet = EziMOTIONPlusRV8Lib.FAS_ServoAlarmReset(bytePort, fastech.ID);
                                    break;

                                default:
                                    libRet = EziMOTIONPlusRLib.FAS_ServoAlarmReset(bytePort, fastech.ID);
                                    break;
                            }
                            break;

                        case FASTECH_CONNECTION_TYPE.ETHERNET:
                            libRet = EziMOTIONPlusELib.FAS_ServoAlarmReset(fastech.ID);
                            break;
                    }

                    if (libRet == FMM_OK)
                    {
                        ret &= true;
                    }
                    else
                    {
                        LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Fail to reset {(AXIS_LIST)var.Key} servo alarm because of {libRet.ToString()}", CONTENT_TYPE.DEBUG);
                        ret &= false;
                    }
                }

                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }

        /**
         * @brief Servo off 함수
         * @param[in] axisIdx AXIS_LIST 번호
         * @return Servo off 명령 정상 수행 여부
         */
        public bool ServoOff(object axisIdx)
        {
            try
            {
                bool ret = true;
                int libRet = FMM_OK;

                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
                if (!IsConnected(axisIdx))
                {
                    return false;
                }

                switch (fastech.connectionType)
                {
                    case FASTECH_CONNECTION_TYPE.SERIAL:
                        SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                        string strPort = GetPortString(serial.PortName);
                        byte bytePort = byte.Parse(strPort);

                        switch (fastech.axisType)
                        {
                            case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                            case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                libRet = EziMOTIONPlusRV8Lib.FAS_ServoEnable(bytePort, fastech.ID, FALSE);
                                break;

                            default:
                                libRet = EziMOTIONPlusRLib.FAS_ServoEnable(bytePort, fastech.ID, FALSE);
                                break;
                        }
                        break;

                    case FASTECH_CONNECTION_TYPE.ETHERNET:
                        libRet = EziMOTIONPlusELib.FAS_ServoEnable(fastech.ID, FALSE);
                        break;
                }

                if (libRet == FMM_OK)
                {
                    ret = true;
                }
                else
                {
                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Fail to turn off {(AXIS_LIST)axisIdx} servo because of {libRet.ToString()}", CONTENT_TYPE.DEBUG);
                    ret = false;
                }

                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }

        /**
         * @brief Servo off 함수
         * @details 모든 축 servo off 수행
         * @return Servo off 명령 정상 수행 여부
         */
        public bool ServoOff()
        {
            try
            {
                bool ret = true;
                int libRet = FMM_OK;

                foreach (KeyValuePair<AXIS_LIST, FastechObject> var in axisList)
                {
                    FastechObject fastech = var.Value;
                    if (!IsConnected(var.Key))
                    {
                        continue;
                    }

                    switch (fastech.connectionType)
                    {
                        case FASTECH_CONNECTION_TYPE.SERIAL:
                            SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                            string strPort = GetPortString(serial.PortName);
                            byte bytePort = byte.Parse(strPort);

                            switch (fastech.axisType)
                            {
                                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                    libRet = EziMOTIONPlusRV8Lib.FAS_ServoEnable(bytePort, fastech.ID, FALSE);
                                    break;

                                default:
                                    libRet = EziMOTIONPlusRLib.FAS_ServoEnable(bytePort, fastech.ID, FALSE);
                                    break;
                            }
                            break;

                        case FASTECH_CONNECTION_TYPE.ETHERNET:
                            libRet = EziMOTIONPlusELib.FAS_ServoEnable(fastech.ID, FALSE);
                            break;
                    }

                    if (libRet == FMM_OK)
                    {
                        ret &= true;
                    }
                    else
                    {
                        LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Fail to turn off {(AXIS_LIST)var.Key} servo because of {libRet.ToString()}", CONTENT_TYPE.DEBUG);
                        ret &= false;
                    }
                }

                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }

        /**
         * @brief Servo on 함수
         * @param[in] axisIdx AXIS_LIST 번호
         * @return Servo on 명령 정상 수행 여부
         */
        public bool ServoOn(object axisIdx)
        {
            try
            {
                bool ret = true;
                int libRet = FMM_OK;

                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
                if (!IsConnected(axisIdx))
                {
                    return false;
                }

                switch (fastech.connectionType)
                {
                    case FASTECH_CONNECTION_TYPE.SERIAL:
                        SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                        string strPort = GetPortString(serial.PortName);
                        byte bytePort = byte.Parse(strPort);

                        switch (fastech.axisType)
                        {
                            case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                            case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                libRet = EziMOTIONPlusRV8Lib.FAS_ServoEnable(bytePort, fastech.ID, TRUE);
                                break;

                            default:
                                libRet = EziMOTIONPlusRLib.FAS_ServoEnable(bytePort, fastech.ID, TRUE);
                                break;
                        }
                        break;

                    case FASTECH_CONNECTION_TYPE.ETHERNET:
                        libRet = EziMOTIONPlusELib.FAS_ServoEnable(fastech.ID, TRUE);
                        libRet = EziMOTIONPlusELib.FAS_SetCommandPos(fastech.ID, fastech.fastechStatus.currentPos);
                        break;
                }

                if (libRet == FMM_OK)
                {
                    ret = true;
                }
                else
                {
                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Fail to turn on {(AXIS_LIST)axisIdx} servo because of {libRet.ToString()}", CONTENT_TYPE.DEBUG);
                    ret = false;
                }

                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }

        /**
         * @brief Servo on 함수
         * @details 모든 축 servo on 수행
         * @return Servo on 명령 정상 수행 여부
         */
        public bool ServoOn()
        {
            try
            {
                bool ret = true;
                int libRet = FMM_OK;

                foreach (KeyValuePair<AXIS_LIST, FastechObject> var in axisList)
                {
                    FastechObject fastech = var.Value;
                    if (!IsConnected(var.Key))
                    {
                        continue;
                    }

                    switch (fastech.connectionType)
                    {
                        case FASTECH_CONNECTION_TYPE.SERIAL:
                            SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                            string strPort = GetPortString(serial.PortName);
                            byte bytePort = byte.Parse(strPort);

                            switch (fastech.axisType)
                            {
                                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                    libRet = EziMOTIONPlusRV8Lib.FAS_ServoEnable(bytePort, fastech.ID, TRUE);
                                    break;

                                default:
                                    libRet = EziMOTIONPlusRLib.FAS_ServoEnable(bytePort, fastech.ID, TRUE);
                                    break;
                            }
                            break;

                        case FASTECH_CONNECTION_TYPE.ETHERNET:
                            libRet = EziMOTIONPlusELib.FAS_ServoEnable(fastech.ID, TRUE);
                            break;
                    }

                    if (libRet == FMM_OK)
                    {
                        ret &= true;
                    }
                    else
                    {
                        LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Fail to turn on {(AXIS_LIST)var.Key} servo because of {libRet.ToString()}", CONTENT_TYPE.DEBUG);
                        ret &= false;
                    }
                }

                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }

        /**
         * @brief Axis에 사용될 속도 관련 파라미터 저장 함수
         * @param[in] [0]:axisIdx AXIS_LIST 번호, [1]: AxisParamData
         */
        public bool SetAxisParams(object axisIdx, object data)
        {
            try
            {
                bool ret = true;
                int libRet = FMM_OK;

                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
                /*
                if (!IsConnected(axisIdx))
                {
                    return false;
                }
                */

                if (axisParamData[(int)axisIdx] is null)
                {
                    axisParamData[(int)axisIdx] = new AxisParamData();
                }
                axisParamData[(int)axisIdx].resolution = ((AxisParamData)data).resolution;
                axisParamData[(int)axisIdx].distance = ((AxisParamData)data).distance;
                axisParamData[(int)axisIdx].vel_high = ((AxisParamData)data).vel_high;
                axisParamData[(int)axisIdx].vel_medium = ((AxisParamData)data).vel_medium;
                axisParamData[(int)axisIdx].vel_low = ((AxisParamData)data).vel_low;
                axisParamData[(int)axisIdx].acc = ((AxisParamData)data).acc;
                axisParamData[(int)axisIdx].dec = ((AxisParamData)data).dec;
                axisParamData[(int)axisIdx].jogVel = ((AxisParamData)data).jogVel;
                axisParamData[(int)axisIdx].jogAcc = ((AxisParamData)data).jogAcc;
                axisParamData[(int)axisIdx].jogDec = ((AxisParamData)data).jogDec;
                axisParamData[(int)axisIdx].oriVel = ((AxisParamData)data).oriVel;
                axisParamData[(int)axisIdx].oriDec = ((AxisParamData)data).oriDec;
                axisParamData[(int)axisIdx].oriReturn = ((AxisParamData)data).oriReturn;
                axisParamData[(int)axisIdx].inpositionFlag = ((AxisParamData)data).inpositionFlag;

                if (axisParamData[(int)axisIdx].resolution is null || axisParamData[(int)axisIdx].distance is null)
                {
                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, "Please assign gear ratio data", CONTENT_TYPE.ERROR);
                    return false;
                }
                double scale = Convert.ToDouble(axisParamData[(int)axisIdx].resolution) / Convert.ToDouble(axisParamData[(int)axisIdx].distance);

                axisParamData[(int)axisIdx].vel_high = Convert.ToDouble(axisParamData[(int)axisIdx].vel_high) * scale;
                axisParamData[(int)axisIdx].vel_medium = Convert.ToDouble(axisParamData[(int)axisIdx].vel_medium) * scale;
                axisParamData[(int)axisIdx].vel_low = Convert.ToDouble(axisParamData[(int)axisIdx].vel_low) * scale;
                axisParamData[(int)axisIdx].jogVel = Convert.ToDouble(axisParamData[(int)axisIdx].jogVel) * scale;
                axisParamData[(int)axisIdx].oriVel = Convert.ToDouble(axisParamData[(int)axisIdx].oriVel) * scale;

                int accTime = Convert.ToInt32(axisParamData[(int)axisIdx].acc);
                int decTime = Convert.ToInt32(axisParamData[(int)axisIdx].dec);

                int jogVelocity = Convert.ToInt32(axisParamData[(int)axisIdx].jogVel);
                int jogAccDecTime = Convert.ToInt32(axisParamData[(int)axisIdx].jogAcc);

                int originVelocity = Convert.ToInt32(axisParamData[(int)axisIdx].oriVel);
                int originAccDecTime = Convert.ToInt32(axisParamData[(int)axisIdx].oriAcc);

                switch (fastech.connectionType)
                {
                    case FASTECH_CONNECTION_TYPE.SERIAL:
                        SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                        string strPort = GetPortString(serial.PortName);
                        byte bytePort = byte.Parse(strPort);

                        switch (fastech.axisType)
                        {
                            case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V6:
                                libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVO_PARAM.SERVO_AXISACCTIME, accTime);
                                libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVO_PARAM.SERVO_AXISDECTIME, decTime);

                                libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVO_PARAM.SERVO_JOGSPEED, jogVelocity);
                                libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVO_PARAM.SERVO_JOGACCDECTIME, jogAccDecTime);

                                libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVO_PARAM.SERVO_ORGSPEED, originVelocity);
                                libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVO_PARAM.SERVO_ORGACCDECTIME, originAccDecTime);
                                break;

                            case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                                libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVOV8_PARAM.SERVO_AXISACCTIME, accTime);
                                libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVOV8_PARAM.SERVO_AXISDECTIME, decTime);

                                libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVOV8_PARAM.SERVO_JOGSPEED, jogVelocity);
                                libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVOV8_PARAM.SERVO_JOGACCDECTIME, jogAccDecTime);

                                libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVOV8_PARAM.SERVO_ORGSPEED, originVelocity);
                                libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVOV8_PARAM.SERVO_ORGACCDECTIME, originAccDecTime);
                                break;

                            case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V6:
                                libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINK_PARAM.MOTIONLINK_AXISACCTIME, accTime);
                                libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINK_PARAM.MOTIONLINK_AXISDECTIME, decTime);

                                libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINK_PARAM.MOTIONLINK_JOGSPEED, jogVelocity);
                                libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINK_PARAM.MOTIONLINK_JOGACCDECTIME, jogAccDecTime);

                                libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINK_PARAM.MOTIONLINK_ORGSPEED, originVelocity);
                                libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINK_PARAM.MOTIONLINK_ORGACCDECTIME, originAccDecTime);
                                break;

                            case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINKV8_PARAM.MOTIONLINK_AXISACCTIME, accTime);
                                libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINKV8_PARAM.MOTIONLINK_AXISDECTIME, decTime);

                                libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINKV8_PARAM.MOTIONLINK_JOGSPEED, jogVelocity);
                                libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINKV8_PARAM.MOTIONLINK_JOGACCDECTIME, jogAccDecTime);

                                libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINKV8_PARAM.MOTIONLINK_ORGSPEED, originVelocity);
                                libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINKV8_PARAM.MOTIONLINK_ORGACCDECTIME, originAccDecTime);
                                break;
                        }
                        break;

                    case FASTECH_CONNECTION_TYPE.ETHERNET:
                        switch (fastech.axisType)
                        {
                            case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_E_V6:
                                libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZISERVO2_PARAM.SERVO2_AXISACCTIME, accTime);
                                libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZISERVO2_PARAM.SERVO2_AXISDECTIME, decTime);

                                libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZISERVO2_PARAM.SERVO2_JOGSPEED, jogVelocity);
                                libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZISERVO2_PARAM.SERVO2_JOGACCDECTIME, jogAccDecTime);

                                libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZISERVO2_PARAM.SERVO2_ORGSPEED, originVelocity);
                                libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZISERVO2_PARAM.SERVO2_ORGACCDECTIME, originAccDecTime);
                                break;

                            case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_E_V6:
                                libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZIMOTIONLINK2_PARAM.MOTIONLINK2_AXISACCTIME, accTime);
                                libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZIMOTIONLINK2_PARAM.MOTIONLINK2_AXISDECTIME, decTime);

                                libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZIMOTIONLINK2_PARAM.MOTIONLINK2_JOGSPEED, jogVelocity);
                                libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZIMOTIONLINK2_PARAM.MOTIONLINK2_JOGACCDECTIME, jogAccDecTime);

                                libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZIMOTIONLINK2_PARAM.MOTIONLINK2_ORGSPEED, originVelocity);
                                libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZIMOTIONLINK2_PARAM.MOTIONLINK2_ORGACCDECTIME, originAccDecTime);
                                break;
                        }
                        break;
                }

                if (libRet == FMM_OK)
                {
                    ret = true;
                }
                else
                {
                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Fail to set parameter to {(AXIS_LIST)axisIdx}", CONTENT_TYPE.DEBUG);
                    ret = false;
                }

                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }

        /**
         * @brief Axis에 사용될 속도 관련 파라미터 저장 함수
         * @param[in] [0] : axis parameter data array
         */
        public bool SetAxisParams(params object[] args)
        {
            try
            {
                bool ret = true;
                int libRet = FMM_OK;

                axisParamData = (AxisParamData[])args;

                foreach (KeyValuePair<AXIS_LIST, FastechObject> var in axisList)
                {
                    FastechObject fastech = axisList[(AXIS_LIST)var.Key];
                    if (!IsConnected((AXIS_LIST)var.Key))
                    {
                        return false;
                    }

                    double scale = Convert.ToDouble(axisParamData[(int)var.Key].resolution) / Convert.ToDouble(axisParamData[(int)var.Key].distance);

                    axisParamData[(int)var.Key].vel_high = Convert.ToDouble(axisParamData[(int)var.Key].vel_high) * scale;
                    axisParamData[(int)var.Key].vel_medium = Convert.ToDouble(axisParamData[(int)var.Key].vel_medium) * scale;
                    axisParamData[(int)var.Key].vel_low = Convert.ToDouble(axisParamData[(int)var.Key].vel_low) * scale;
                    axisParamData[(int)var.Key].jogVel = Convert.ToDouble(axisParamData[(int)var.Key].jogVel) * scale;
                    axisParamData[(int)var.Key].oriVel = Convert.ToDouble(axisParamData[(int)var.Key].oriVel) * scale;

                    int velocity = Convert.ToInt32(axisParamData[(int)var.Key].vel_high);
                    int accTime = Convert.ToInt32(axisParamData[(int)var.Key].acc);
                    int decTime = Convert.ToInt32(axisParamData[(int)var.Key].dec);

                    int jogVelocity = Convert.ToInt32(axisParamData[(int)var.Key].jogVel);
                    int jogAccDecTime = Convert.ToInt32(axisParamData[(int)var.Key].jogAcc);

                    int originVelocity = Convert.ToInt32(axisParamData[(int)var.Key].oriVel);
                    int originAccDecTime = Convert.ToInt32(axisParamData[(int)var.Key].oriAcc);

                    switch (fastech.connectionType)
                    {
                        case FASTECH_CONNECTION_TYPE.SERIAL:
                            SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                            string strPort = GetPortString(serial.PortName);
                            byte bytePort = byte.Parse(strPort);

                            switch (fastech.axisType)
                            {
                                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V6:
                                    libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVO_PARAM.SERVO_AXISACCTIME, accTime);
                                    libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVO_PARAM.SERVO_AXISDECTIME, decTime);

                                    libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVO_PARAM.SERVO_JOGSPEED, jogVelocity);
                                    libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVO_PARAM.SERVO_JOGACCDECTIME, jogAccDecTime);

                                    libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVO_PARAM.SERVO_ORGSPEED, originVelocity);
                                    libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVO_PARAM.SERVO_ORGACCDECTIME, originAccDecTime);
                                    break;

                                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                                    libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVOV8_PARAM.SERVO_AXISACCTIME, accTime);
                                    libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVOV8_PARAM.SERVO_AXISDECTIME, decTime);

                                    libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVOV8_PARAM.SERVO_JOGSPEED, jogVelocity);
                                    libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVOV8_PARAM.SERVO_JOGACCDECTIME, jogAccDecTime);

                                    libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVOV8_PARAM.SERVO_ORGSPEED, originVelocity);
                                    libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVOV8_PARAM.SERVO_ORGACCDECTIME, originAccDecTime);
                                    break;

                                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V6:
                                    libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINK_PARAM.MOTIONLINK_AXISACCTIME, accTime);
                                    libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINK_PARAM.MOTIONLINK_AXISDECTIME, decTime);

                                    libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINK_PARAM.MOTIONLINK_JOGSPEED, jogVelocity);
                                    libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINK_PARAM.MOTIONLINK_JOGACCDECTIME, jogAccDecTime);

                                    libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINK_PARAM.MOTIONLINK_ORGSPEED, originVelocity);
                                    libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINK_PARAM.MOTIONLINK_ORGACCDECTIME, originAccDecTime);
                                    break;

                                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                    libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINKV8_PARAM.MOTIONLINK_AXISACCTIME, accTime);
                                    libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINKV8_PARAM.MOTIONLINK_AXISDECTIME, decTime);

                                    libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINKV8_PARAM.MOTIONLINK_JOGSPEED, jogVelocity);
                                    libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINKV8_PARAM.MOTIONLINK_JOGACCDECTIME, jogAccDecTime);

                                    libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINKV8_PARAM.MOTIONLINK_ORGSPEED, originVelocity);
                                    libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINKV8_PARAM.MOTIONLINK_ORGACCDECTIME, originAccDecTime);
                                    break;
                            }
                            break;

                        case FASTECH_CONNECTION_TYPE.ETHERNET:
                            switch (fastech.axisType)
                            {
                                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_E_V6:
                                    libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZISERVO2_PARAM.SERVO2_AXISACCTIME, accTime);
                                    libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZISERVO2_PARAM.SERVO2_AXISDECTIME, decTime);

                                    libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZISERVO2_PARAM.SERVO2_JOGSPEED, jogVelocity);
                                    libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZISERVO2_PARAM.SERVO2_JOGACCDECTIME, jogAccDecTime);

                                    libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZISERVO2_PARAM.SERVO2_ORGSPEED, originVelocity);
                                    libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZISERVO2_PARAM.SERVO2_ORGACCDECTIME, originAccDecTime);
                                    break;

                                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_E_V6:
                                    libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZIMOTIONLINK2_PARAM.MOTIONLINK2_AXISACCTIME, accTime);
                                    libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZIMOTIONLINK2_PARAM.MOTIONLINK2_AXISDECTIME, decTime);

                                    libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZIMOTIONLINK2_PARAM.MOTIONLINK2_JOGSPEED, jogVelocity);
                                    libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZIMOTIONLINK2_PARAM.MOTIONLINK2_JOGACCDECTIME, jogAccDecTime);

                                    libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZIMOTIONLINK2_PARAM.MOTIONLINK2_ORGSPEED, originVelocity);
                                    libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZIMOTIONLINK2_PARAM.MOTIONLINK2_ORGACCDECTIME, originAccDecTime);
                                    break;
                            }
                            break;
                    }

                    if (libRet == FMM_OK)
                    {
                        ret &= true;
                    }
                    else
                    {
                        LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Fail to set parameter to {(AXIS_LIST)var.Key}", CONTENT_TYPE.DEBUG);
                        ret &= false;
                    }
                }

                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }

        /**
         * @brief Origin sensor가 감지되었는지 확인하는 함수
         * @param[in] axisIdx AXIS_LIST 번호
         * @return Origin sensor 감지 여부
         */
        public bool IsOnOriginSensor(object axisIdx)
        {
            return CheckAxisStatus(axisIdx, (uint)AXISSTATUS.FFLAG_ORIGINSENSOR);
        }

        /**
         * @brief 긴급 정지 명령 함수
         * @param[in] axisIdx AXIS_LIST 번호
         * @return 긴급 정지 명령 정상 수행 여부
         */
        public void EmergencyMoveStop(object axisIdx)
        {
            try
            {
                int libRet = FMM_OK;

                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
                if (!IsConnected(axisIdx))
                {
                    return;
                }

                switch (fastech.connectionType)
                {
                    case FASTECH_CONNECTION_TYPE.SERIAL:
                        SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                        string strPort = GetPortString(serial.PortName);
                        byte bytePort = byte.Parse(strPort);

                        switch (fastech.axisType)
                        {
                            case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                            case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                libRet = EziMOTIONPlusRV8Lib.FAS_EmergencyStop(bytePort, fastech.ID);
                                break;
                            default:
                                libRet = EziMOTIONPlusRLib.FAS_EmergencyStop(bytePort, fastech.ID);
                                break;
                        }
                        break;

                    case FASTECH_CONNECTION_TYPE.ETHERNET:
                        libRet = EziMOTIONPlusELib.FAS_EmergencyStop(fastech.ID);
                        break;
                }

                if (libRet != FMM_OK)
                {
                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Fail to emergency stop {(AXIS_LIST)axisIdx} servo because of {libRet.ToString()}", CONTENT_TYPE.DEBUG);
                }
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
            }
        }

        /**
         * Fastech driver에서 사용하지 않음
         */
        public bool InitIO()
        {
            throw new NotImplementedException();
        }
        public bool ClearPosition(object axisIdx)
        {
            try
            {
                bool ret = true;
                int libRet = FMM_OK;

                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
                if (!IsConnected(axisIdx))
                {
                    return false;
                }

                switch (fastech.connectionType)
                {
                    case FASTECH_CONNECTION_TYPE.SERIAL:
                        SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                        string strPort = GetPortString(serial.PortName);
                        byte bytePort = byte.Parse(strPort);

                        switch (fastech.axisType)
                        {
                            case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                            case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                libRet = EziMOTIONPlusRV8Lib.FAS_ClearPosition(bytePort, fastech.ID);
                                break;

                            default:
                                libRet = EziMOTIONPlusRLib.FAS_ClearPosition(bytePort, fastech.ID);
                                break;
                        }
                        break;

                    case FASTECH_CONNECTION_TYPE.ETHERNET:
                        libRet = EziMOTIONPlusELib.FAS_ClearPosition(fastech.ID);
                        break;
                }

                if (libRet == FMM_OK)
                {
                    ret = true;
                }
                else
                {
                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Fail to clear position {(AXIS_LIST)axisIdx} servo because of {libRet.ToString()}", CONTENT_TYPE.DEBUG);
                    ret = false;
                }

                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }
        //Bổ sung phương thức kiểm tra sensor limit
        public bool IsLowerLimit(object axisIdx)
        {
            try
            {
                bool ret = false;
                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];

                if ((fastech.objectType & FASTECH_OBJECT_TYPE.AXIS) != FASTECH_OBJECT_TYPE.NONE)
                {
                    ret = CheckAxisStatus(axisIdx, (uint)AXISSTATUS.FFLAG_HWNEGALMT);
                }

                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }

        public bool IsUpperLimit(object axisIdx)
        {
            try
            {
                bool ret = false;
                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];

                if ((fastech.objectType & FASTECH_OBJECT_TYPE.AXIS) != FASTECH_OBJECT_TYPE.NONE)
                {
                    ret = CheckAxisStatus(axisIdx, (uint)AXISSTATUS.FFLAG_HWPOSILMT);
                }

                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }
    }
}


Vendor/HoneywellBarcodeReader.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Auto_Insert_Sim_Tray.Configs.Model;
using Auto_Insert_Sim_Tray.HW.BarcodeReader;

namespace Auto_Insert_Sim_Tray.HW.Vendor.Honeywell
{
    public class HoneywellBarcodeReader : BarcodeReader.BarcodeReader
    {
        string StopCommand = String.Empty;
        public HoneywellBarcodeReader(BarcodeReaderConfig config, byte STX = 0x16, byte ETX = 0x0D) : base(config)
        {
            this.STX = STX;
            //this.ETX = ETX;
            //this.ReadCommand = $"{((char)this.STX)}{this.ReadCommand}";
            //this.StopCommand = $"{((char)this.STX)}U";
            this.ReadCommand = $"T";
            this.StopCommand = $"{((char)this.STX)}U";
        }

        public void StartRead()
        {
            base.Trigger();
        }
        public void StopRead()
        {
            base.Send(this.StopCommand);
        }

    }
}

Manager/SystemManager.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Auto_Insert_Sim_Tray.Configs;
using Auto_Insert_Sim_Tray.Define;
using Auto_Insert_Sim_Tray.Utils;
using static Auto_Insert_Sim_Tray.Define.LogDefine;
using static Auto_Insert_Sim_Tray.Define.SystemEnum;

namespace Auto_Insert_Sim_Tray.Manager
{
    public struct OpMsg
    {
        public OP_MODE opMode;
        public int errCode;

        public OpMsg(OP_MODE op, int message = -1)
        {
            opMode = op;
            errCode = message;
        }
    }
    /**
     * @brief Operation Mode를 관리하는 클래스 
     */
    public class SystemManager : IObservable<OpMsg>
    {
        private IList<IObserver<OpMsg>> listObserver;
        private OpMsg opMsg;
        private OpMsg prevOpMode;
        public bool IsRunning { get; set; }
        private MainForm mainForm;
        private ManualResetEvent pauseEvent;
        private object idleLock;
        private bool isIdle;
        private object outOfStockWarningLock;
        private bool isOutOfStockWarning;
        private object outOfStockLock;
        private bool isOutOfStock;
        private object inputStopLock;
        private object outputStopLock;
        private bool isInputStop;
        private bool isOutputStop;
        private RUN_MODE runMode;
        private Stack<OpMsg> opStack;
        private Stack<OpMsg> tempStack;
        public SynchronizationContext syncContext { get; set; }

        public delegate void IsOpCallChange(bool isCall);
        public event IsOpCallChange IsOpCalled;

        /**
         * @brief 생성자
         * @param[in] main Mainform 
         */
        public SystemManager(MainForm main)
        {
            LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, "Init system manager", CONTENT_TYPE.DEBUG);
            InitializeVariable(main);
        }

        /**
         * @brief 변수 초기화 해주는 함수
         * @param[in] main Mainform 
         */
        private void InitializeVariable(MainForm main)
        {
            pauseEvent = new ManualResetEvent(true);
            listObserver = new List<IObserver<OpMsg>>();
            syncContext = SynchronizationContext.Current;
            mainForm = main;
            opMsg.opMode = OP_MODE.NONE;
            prevOpMode.opMode = OP_MODE.NONE;
            runMode = RUN_MODE.NONE;
            isIdle = false;
            isOutOfStockWarning = false;
            isOutOfStock = false;
            idleLock = new object();
            outOfStockWarningLock = new object();
            outOfStockLock = new object();
            inputStopLock = new object();
            outputStopLock = new object();
            opStack = new Stack<OpMsg>();
            tempStack = new Stack<OpMsg>();

            TacktimeManager = JsonHelper.Instance.logisticModel.TackTime;

            initializeChecker = new InitializeChecker(TacktimeManager);
        }
        public RUN_MODE RunMode
        {
            set
            {
                runMode = value;
            }
            get
            {
                return runMode;
            }
        }

        public ManualResetEvent PauseEvent
        {
            set
            {
                pauseEvent = value;
            }
            get
            {
                return pauseEvent;
            }
        }

        /**
         * @brief observer를 observer list에 넣어주는 함수
         * @return Dispose 하기 용이하도록 Unsubscriber 객체
         */
        public IDisposable Subscribe(IObserver<OpMsg> observer)
        {
            if (!listObserver.Contains(observer))
            {
                listObserver.Add(observer);
                return new UnSubscriber<OpMsg>(listObserver, observer);
            }
            else
            {
                return null;
            }
        }

        bool isOpCall = false;
        public bool IsOpCall
        {
            get => isOpCall;
            set
            {
                isOpCall = value;
                IsOpCalled?.Invoke(isOpCall);
            }
        }
        public bool IsIdleEnter
        {
            get
            {
                lock (idleLock)
                {
                    return isIdle;
                }
            }
            set
            {
                lock (idleLock)
                {
                    isIdle = value;
                }
            }
        }

        public bool IsOutOfStockWarning
        {
            get
            {
                lock (outOfStockWarningLock)
                {
                    return isOutOfStockWarning;
                }
            }
            set
            {
                lock (outOfStockWarningLock)
                {
                    isOutOfStockWarning = value;
                }
            }
        }
        public bool IsOutOfStock
        {
            get
            {
                lock (outOfStockLock)
                {
                    return isOutOfStock;
                }
            }
            set
            {
                lock (outOfStockLock)
                {
                    isOutOfStock = value;
                }
            }
        }
        public bool IsInputStop
        {
            get
            {
                lock (inputStopLock)
                {
                    return isInputStop;
                }
            }
            set
            {
                lock (inputStopLock)
                {
                    isInputStop = value;
                }
            }
        }
        public bool IsOutputStop
        {
            get
            {
                lock (outputStopLock)
                {
                    return isOutputStop;
                }
            }
            set
            {
                lock (outputStopLock)
                {
                    isOutputStop = value;
                }
            }
        }
        public void StackPush(OpMsg msg)
        {
            bool find = false;
            if (opStack.Count() > 0)
            {
                for (int i = 0; i < opStack.Count(); i++)
                {
                    if ((opStack.ElementAt(i).opMode == msg.opMode) && (opStack.ElementAt(i).errCode == msg.errCode))
                    {
                        find = true;
                    }
                }
            }
            if (!find)
            {
                opStack.Push(msg);
            }
        }
        public void StackClear()
        {
            opStack.Clear();
            tempStack.Clear();
        }
        public OpMsg StackPop(OpMsg msg)
        {
            OpMsg check;
            while (!IsEmpty())
            {
                check = opStack.Peek();
                if (check.opMode == msg.opMode && check.errCode == msg.errCode)
                {
                    if (tempStack.Count > 0)
                    {
                        opStack.Pop();
                        while (tempStack.Count > 0)
                        {
                            opStack.Push(tempStack.Pop());
                        }
                    }
                    else
                    {
                        opStack.Pop();
                    }
                    break;
                }
                else
                {
                    tempStack.Push(opStack.Pop());
                }
            }
            return IsEmpty() ? new OpMsg(OP_MODE.NONE) : opStack.Peek();
        }
        private bool IsEmpty()
        {
            return (opStack.Count == 0);
        }
        /**
         * @brief 각 Observer들이 Operation mode를 변경하고자 할 때 호출 하는 함수
         * @details Operation mode 규칙에 따라 여러 요청이 와도 무시당할 수 있다
         * @param[in] op operation mode
         * @param[in] errCode error 발생 코드
         */
        public void SetOPModeWithAsync(OP_MODE op, int errCode = -1)
        {
            syncContext.Post(
            delegate
            {
                opMsg = new OpMsg(op, errCode);
                switch (op)
                {
                    case OP_MODE.READY:
                    case OP_MODE.INIT:
                    case OP_MODE.RESET:
                    case OP_MODE.SEMI_RUN:
                    case OP_MODE.ORG_RUN:
                        OpMsg = opMsg;
                        break;
                    case OP_MODE.RUN:
                        mainForm.autoPanel.login = null;
                        mainForm.login = null;
                        if (mainForm.CheckStartCondition())
                        {
                            mainForm.selected_Unit = UNIT_TYPE.NONE;
                            IsRunning = true;
                            OpMsg = opMsg;
                        }
                        else
                        {
                            opMsg = new OpMsg(OP_MODE.STOP);
                            OpMsg = opMsg;
                            SetOPModeWithAsync(OP_MODE.STOP, SystemDefine.ERRCODE_STOP_YELLOW);
                        }
                        break;
                    case OP_MODE.STOP:
                        if (mainForm.alarmForm != null)
                        {
                            mainForm.alarmForm = null;
                        }
                        //if (prevOpMode.opMode == OP_MODE.STOP)
                        //{
                        //    if (prevOpMode.errCode != opMsg.errCode)
                        //    {
                        //        OpMsg = opMsg;
                        //    }
                        //    OpMsg = opMsg; //add
                        //}
                        //else
                        //{
                        //    OpMsg = opMsg;
                        //}
                        OpMsg = opMsg;
                        break;
                    case OP_MODE.E_STOP:
                        if (prevOpMode.opMode == OP_MODE.E_STOP)
                        {
                            if (prevOpMode.errCode != opMsg.errCode)
                            {
                                OpMsg = opMsg;
                            }
                        }
                        else
                        {
                            OpMsg = opMsg;
                        }
                        break;
                }
                prevOpMode = opMsg;
                mainForm.nV_Mainform_TOP1.SetMachineStatus(op.ToString());
            }, null);

        }

        public OpMsg OpMsg
        {
            set
            {
                opMsg = value;
                Update(opMsg);
            }
            get
            {
                return opMsg;
            }
        }

        /**
         * @brief 구독하고 있는 observer들에게 broad cast 시켜주는 함수
         * @param[in] data Operation Mode와 error code를 지닌 객체
         */
        public TactTimeUtil TacktimeManager { get; set; }

        public InitializeChecker initializeChecker { get; private set; }

        protected void Update(OpMsg data)
        {
            foreach (var ob in listObserver)
            {
                ob.OnNext(data);
            }
            Notify();
        }

        /**
         * @brief 구독하고 있는 observer들에게 업데이트가 완료됨을 알려주는 함수
         */
        public void Notify()
        {
            foreach (var ob in listObserver)
            {
                ob.OnCompleted();
            }
            if (opMsg.opMode == OP_MODE.RUN || opMsg.opMode == OP_MODE.RESET || opMsg.opMode == OP_MODE.SEMI_RUN
                || opMsg.opMode == OP_MODE.ORG_RUN || opMsg.opMode == OP_MODE.INIT)
            {
                PauseEvent.Set();
            }
            else if (opMsg.opMode == OP_MODE.STOP || opMsg.opMode == OP_MODE.E_STOP)
            {
                PauseEvent.Reset();
            }
        }

    }
}

Manager/UnSubscriber.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Auto_Insert_Sim_Tray.Manager
{
    /**
     * @brief Obser에서 구독 해지하기 위한 클래스
     */
    class UnSubscriber<OP_MODE> : IDisposable
    {
        private IList<IObserver<OP_MODE>> listObserver;
        private IObserver<OP_MODE> observer;

        /**
         * @brief 생성자
         * @param[in] listOb observer 관리 리스트
         * @param[in] ob observer
         */
        public UnSubscriber(IList<IObserver<OP_MODE>> listOb, IObserver<OP_MODE> ob)
        {
            listObserver = listOb;
            observer = ob;
        }

        /**
         * @brief Dispose 될 때, observer list에서 observer 제거
         */
        public void Dispose()
        {
            if (listObserver.Contains(observer))
            {
                listObserver.Remove(observer);
            }
        }
    }
}

Mechanical/CV/MIn_CV.cs
using Auto_Insert_Sim_Tray.HW.Interface;
using Auto_Insert_Sim_Tray.Mechanical;
using Auto_Insert_Sim_Tray.Utils;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static Auto_Insert_Sim_Tray.Define.IODefine;
using static Auto_Insert_Sim_Tray.Define.SystemEnum;

namespace Auto_Insert_Sim_Tray.Mechanical
{
    public class MIn_CV : M_Base
    {
        public IConveyor iCV_In;

        sSETInfo set = new sSETInfo();

        public bool IsReadyPick, IsReadyPlace;
        public bool IsHaveSet_CV_In;
        public bool IsTriggerScanner = false;
        public MIn_CV(IIO iIO, IAxis iAxis)
        {
            this.iIO = iIO;
            this.iAxis = iAxis;

            Unit_Type = UNIT_TYPE.IN_CV;

            SetConveyor(DO._13_CV_INPUT, null, DI._14_SS_CV_IN_DETECT_1, DI._14_SS_CV_IN_DETECT_2, DI._14_SS_CV_IN_DETECT_3, ref iCV_In);
        }

        internal sSETInfo SET { get => set; set => set = value; }

        //IF
        public bool isIFForntReady { get; set; }
        public bool isIFForntBusy { get; set; }
        public void SetIFBusyToFrontMachine(bool isNormalCloseSignal)
        {
            if (!isNormalCloseSignal)
            {
                iIO.On(DO._13_IF_FRONT_BUSY);
            }
            else
            {
                iIO.Off(DO._13_IF_FRONT_BUSY);
            }
        }
        public void ClearIFBusyToFrontMachine(bool isNormalCloseSignal)
        {
            if (!isNormalCloseSignal)
            {
                iIO.Off(DO._13_IF_FRONT_BUSY);
            }
            else
            {
                iIO.On(DO._13_IF_FRONT_BUSY);
            }
        }

        //Khai báo biến X
        public bool bDetect_In_Chk => iCV_In.IsInSensor();

        public bool bDetect_Mid_Chk => iCV_In.IsMiddleSensor();
        public bool bDetect_Out_Chk => iCV_In.IsOutSensor();

        //Khai báo biến Y
        public bool bCV_In_Run => iCV_In.IsRunCW();
        public bool bCV_In_Stop => !iCV_In.IsRunCW();

        //Set biến Y        
        public ECODE Run_CV_In()
        {
            iCV_In.RunCW();
            return ECODE.WORK_SUCCESS;
        }

        public ECODE Stop_CV_In()
        {
            iCV_In.Stop();
            return ECODE.WORK_SUCCESS;
        }
    }
}

Mechanical/CV/MInput_Left_CV.cs
using Auto_Insert_Sim_Tray.HW.Interface;
using Auto_Insert_Sim_Tray.Mechanical;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static Auto_Insert_Sim_Tray.Define.IODefine;
using static Auto_Insert_Sim_Tray.Define.SystemEnum;

namespace Auto_Insert_Sim_Tray.Mechanical.CV
{
    public class MInput_Left_CV : M_Base
    {
        public IConveyor iCV_Input_Left_1;
        public IConveyor iCV_Input_Left_2;
        public ICylinder iStopper_1_Sol;
        public ICylinder iStopper_2_Sol;

        public bool IsEmpty_CV_1, IsEmpty_CV_2;

        public bool IsHaveTray_CV_Input_1, IsHaveTray_CV_Input_2;

        public MInput_Left_CV(IIO iIO, IAxis iAxis)
        {
            this.iIO = iIO;
            this.iAxis = iAxis;

            Unit_Type = UNIT_TYPE.LEFT_INTRAY_CV;

            SetConveyor(DO._13_CV_INTRAY_LEFT_INPUT_1, null, null, null, DI._11_SS_INTRAY_LEFT_DETECT_1, ref iCV_Input_Left_1);
            SetConveyor(DO._13_CV_INTRAY_LEFT_INPUT_2, null, null, null, DI._11_SS_INTRAY_LEFT_DETECT_2, ref iCV_Input_Left_2);
            SetSingleCylinder(DO._11_SOL_INTRAY_LEFT_STOPPER_1_DOWN, null, DI._11_SS_INTRAY_LEFT_STOPPER_1_UP, DI._11_SS_INTRAY_LEFT_STOPPER_1_DOWN, ref iStopper_1_Sol);
            SetSingleCylinder(DO._11_SOL_INTRAY_LEFT_STOPPER_2_DOWN, null, DI._11_SS_INTRAY_LEFT_STOPPER_2_UP, DI._11_SS_INTRAY_LEFT_STOPPER_2_DOWN, ref iStopper_2_Sol);
        }

        //Khai báo biến X
        public bool bDetect_Input_1_Chk => iCV_Input_Left_1.IsOutSensor();
        public bool bStopper_Input_1_Up_Chk => iStopper_1_Sol.IsActive();
        public bool bStopper_Input_1_Down_Chk => iStopper_1_Sol.IsDeactive();
        public bool bDetect_Input_2_Chk => iCV_Input_Left_2.IsOutSensor();
        public bool bStopper_Input_2_Up_Chk => iStopper_2_Sol.IsActive();
        public bool bStopper_Input_2_Down_Chk => iStopper_2_Sol.IsDeactive();

        //Khai báo biến Y
        public bool bCV_Input_Left_1_Run => iCV_Input_Left_1.IsRunCW();
        public bool bCV_Input_Left_1_Stop => !iCV_Input_Left_1.IsRunCW();
        public bool bStopper_Input_1_Up_Sol => iStopper_1_Sol.IsSolActive();
        public bool bStopper_Input_1_Down_Sol => iStopper_1_Sol.IsSolDeactive();
        public bool bCV_Input_Left_2_Run => iCV_Input_Left_2.IsRunCW();
        public bool bCV_Input_Left_2_Stop => !iCV_Input_Left_2.IsRunCW();
        public bool bStopper_Input_2_Up_Sol => iStopper_2_Sol.IsSolActive();
        public bool bStopper_Input_2_Down_Sol => iStopper_2_Sol.IsSolDeactive();

        //Set biến Y
        public ECODE Run_CV_Input_Left_1()
        {
            iCV_Input_Left_1.RunCW();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stop_CV_Input_Left_1()
        {
            iCV_Input_Left_1.Stop();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stopper_Input_1_Up()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iStopper_1_Sol.Active();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stopper_Input_1_Down()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iStopper_1_Sol.Deactive();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Run_CV_Input_Left_2()
        {
            iCV_Input_Left_2.RunCW();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stop_CV_Input_Left_2()
        {
            iCV_Input_Left_2.Stop();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stopper_Input_2_Up()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iStopper_2_Sol.Active();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stopper_Input_2_Down()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iStopper_2_Sol.Deactive();
            return ECODE.WORK_SUCCESS;
        }
    }
}

Mechanical/CV/MInput_Right_CV.cs
using Auto_Insert_Sim_Tray.HW.Interface;
using Auto_Insert_Sim_Tray.Mechanical;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static Auto_Insert_Sim_Tray.Define.IODefine;
using static Auto_Insert_Sim_Tray.Define.SystemEnum;

namespace Auto_Insert_Sim_Tray.Mechanical.CV
{
    public class MInput_Right_CV : M_Base
    {
        public IConveyor iCV_Input_Right_1;
        public IConveyor iCV_Input_Right_2;
        public ICylinder iStopper_1_Sol;
        public ICylinder iStopper_2_Sol;

        public bool IsEmpty_CV_1, IsEmpty_CV_2;

        public bool IsHaveTray_CV_Input_1, IsHaveTray_CV_Input_2;

        public MInput_Right_CV(IIO iIO, IAxis iAxis)
        {
            this.iIO = iIO;
            this.iAxis = iAxis;

            Unit_Type = UNIT_TYPE.RIGHT_INTRAY_CV;

            SetConveyor(DO._13_CV_INTRAY_RIGHT_INPUT_1, null, null, null, DI._12_SS_INTRAY_RIGHT_DETECT_1, ref iCV_Input_Right_1);
            SetConveyor(DO._13_CV_INTRAY_RIGHT_INPUT_2, null, null, null, DI._12_SS_INTRAY_RIGHT_DETECT_2, ref iCV_Input_Right_2);
            SetSingleCylinder(DO._11_SOL_INTRAY_RIGHT_STOPPER_1_DOWN, null, DI._12_SS_INTRAY_RIGHT_STOPPER_1_UP, DI._12_SS_INTRAY_RIGHT_STOPPER_1_DOWN, ref iStopper_1_Sol);
            SetSingleCylinder(DO._11_SOL_INTRAY_RIGHT_STOPPER_2_DOWN, null, DI._12_SS_INTRAY_RIGHT_STOPPER_2_UP, DI._12_SS_INTRAY_RIGHT_STOPPER_2_DOWN, ref iStopper_2_Sol);
        }

        // IF
        public bool isReadyTransferFromAGV { get; set; }
        public bool isBusyTransferFromAGV { get; set; }
        public void SetIFReadytoAGV()
        {
            iIO.On(DO._13_OUT_AGV_2_5);
        }
        public void ClearIFReadytoAGV()
        {
            iIO.Off(DO._13_OUT_AGV_2_5);
        }

        //Khai báo biến X
        public bool bDetect_Input_1_Chk => iCV_Input_Right_1.IsOutSensor();
        public bool bStopper_Input_1_Up_Chk => iStopper_1_Sol.IsActive();
        public bool bStopper_Input_1_Down_Chk => iStopper_1_Sol.IsDeactive();
        public bool bDetect_Input_2_Chk => iCV_Input_Right_2.IsOutSensor();
        public bool bStopper_Input_2_Up_Chk => iStopper_2_Sol.IsActive();
        public bool bStopper_Input_2_Down_Chk => iStopper_2_Sol.IsDeactive();

        //Khai báo biến Y
        public bool bCV_Input_Right_1_Run => iCV_Input_Right_1.IsRunCW();
        public bool bCV_Input_Right_1_Stop => !iCV_Input_Right_1.IsRunCW();
        public bool bStopper_Input_1_Up_Sol => iStopper_1_Sol.IsSolActive();
        public bool bStopper_Input_1_Down_Sol => iStopper_1_Sol.IsSolDeactive();
        public bool bCV_Input_Right_2_Run => iCV_Input_Right_2.IsRunCW();
        public bool bCV_Input_Right_2_Stop => !iCV_Input_Right_2.IsRunCW();
        public bool bStopper_Input_2_Up_Sol => iStopper_2_Sol.IsSolActive();
        public bool bStopper_Input_2_Down_Sol => iStopper_2_Sol.IsSolDeactive();

        //Set biến Y
        public ECODE Run_CV_Input_Right_1()
        {
            iCV_Input_Right_1.RunCW();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stop_CV_Input_Right_1()
        {
            iCV_Input_Right_1.Stop();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stopper_Input_1_Up()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iStopper_1_Sol.Active();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stopper_Input_1_Down()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iStopper_1_Sol.Deactive();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Run_CV_Input_Right_2()
        {
            iCV_Input_Right_2.RunCW();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stop_CV_Input_Right_2()
        {
            iCV_Input_Right_2.Stop();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stopper_Input_2_Up()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iStopper_2_Sol.Active();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stopper_Input_2_Down()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iStopper_2_Sol.Deactive();
            return ECODE.WORK_SUCCESS;
        }
    }
}

Mechanical/CV/MOut_CV.cs
using Auto_Insert_Sim_Tray.HW.Interface;
using Auto_Insert_Sim_Tray.Utils;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static Auto_Insert_Sim_Tray.Define.AxisDefine;
using static Auto_Insert_Sim_Tray.Define.IODefine;
using static Auto_Insert_Sim_Tray.Define.SystemEnum;

namespace Auto_Insert_Sim_Tray.Mechanical
{
    public class MOut_CV : M_Base
    {
        public IConveyor iCV_Out;

        sSETInfo set = new sSETInfo();

        public bool IsReadyPick, IsReadyPlace;
        public bool isHaveSet_CV_Out= false;
        public MOut_CV(IIO iIO, IAxis iAxis)
        {
            this.iIO = iIO;
            this.iAxis = iAxis;

            Unit_Type = UNIT_TYPE.OUT_CV;

            SetConveyor(DO._13_CV_OUTPUT, null, DI._14_SS_CV_OUT_DETECT_1 , null, DI._14_SS_CV_OUT_DETECT_2, ref iCV_Out);
        }

        internal sSETInfo SET { get => set; set => set = value; }

        //IF
        public bool isIFBehindBusy { get; set; }
        public bool isIFBehindReady { get; set; }
        public void SetIFReadyToBehindMachine(bool isNormalCloseSignal)
        {
            if (!isNormalCloseSignal)
            {
                iIO.On(DO._13_IF_BEHIND_READY);
            }
            else
            {
                iIO.Off(DO._13_IF_BEHIND_READY);
            }
        }
        public void ClearIFReadyToBehindMachine(bool isNormalCloseSignal)
        {
            if (!isNormalCloseSignal)
            {
                iIO.Off(DO._13_IF_BEHIND_READY);
            }
            else
            {
                iIO.On(DO._13_IF_BEHIND_READY);
            }
        }

        //Khai báo biến X

        public bool bDetect_In_Chk => iCV_Out.IsInSensor();
        public bool bDetect_Out_Chk => iCV_Out.IsOutSensor();

        //Khai báo biến Y
        public bool bCV_Out_Run => iCV_Out.IsRunCW();
        public bool bCV_Out_Stop => !iCV_Out.IsRunCW();

        //Set biến Y        
        public ECODE Run_CV_Out()
        {
            iCV_Out.RunCW();
            return ECODE.WORK_SUCCESS;
        }

        public ECODE Stop_CV_Out()
        {
            iCV_Out.Stop();
            return ECODE.WORK_SUCCESS;
        }
    }
}

Mechanical/CV/MOuttray_Left_CV.cs
using Auto_Insert_Sim_Tray.HW.Interface;
using Auto_Insert_Sim_Tray.Mechanical;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static Auto_Insert_Sim_Tray.Define.IODefine;
using static Auto_Insert_Sim_Tray.Define.SystemEnum;

namespace Auto_Insert_Sim_Tray.Mechanical.CV
{
    public class MOuttray_Left_CV : M_Base
    {
        public IConveyor iCV_Outtray_Left_1;
        public IConveyor iCV_Outtray_Left_2;
        public ICylinder iStopper_1_Sol;
        public ICylinder iStopper_2_Sol;

        public bool IsEmpty_CV_1, IsEmpty_CV_2;

        public bool IsHaveTray_CV_Outtray_1, IsHaveTray_CV_Outtray_2;

        public MOuttray_Left_CV(IIO iIO, IAxis iAxis)
        {
            this.iIO = iIO;
            this.iAxis = iAxis;

            Unit_Type = UNIT_TYPE.LEFT_OUTTRAY_CV;

            SetConveyor(DO._13_CV_OUTTRAY_LEFT_OUTPUT_1, null, null, null, DI._13_SS_OUTTRAY_LEFT_DETECT_1, ref iCV_Outtray_Left_1);
            SetConveyor(DO._13_CV_OUTTRAY_LEFT_OUTPUT_2, null, null, null, DI._13_SS_OUTTRAY_LEFT_DETECT_2, ref iCV_Outtray_Left_2);
            SetSingleCylinder(DO._12_SOL_OUTTRAY_STOPPER_LEFT_DOWN_1, null, DI._14_SS_OUTTRAY_LEFT_STOPPER_1_UP, DI._14_SS_OUTTRAY_LEFT_STOPPER_1_DOWN, ref iStopper_1_Sol);
            SetSingleCylinder(DO._12_SOL_OUTTRAY_STOPPER_LEFT_DOWN_2, null, DI._14_SS_OUTTRAY_LEFT_STOPPER_2_UP, DI._14_SS_OUTTRAY_LEFT_STOPPER_2_DOWN, ref iStopper_2_Sol);
        }

        //Khai báo biến X
        public bool bDetect_Outtray_1_Chk => iCV_Outtray_Left_1.IsOutSensor();
        public bool bStopper_Outtray_1_Up_Chk => iStopper_1_Sol.IsActive();
        public bool bStopper_Outtray_1_Down_Chk => iStopper_1_Sol.IsDeactive();
        public bool bDetect_Outtray_2_Chk => iCV_Outtray_Left_2.IsOutSensor();
        public bool bStopper_Outtray_2_Up_Chk => iStopper_2_Sol.IsActive();
        public bool bStopper_Outtray_2_Down_Chk => iStopper_2_Sol.IsDeactive();

        //Khai báo biến Y
        public bool bCV_Outtray_Left_1_Run => iCV_Outtray_Left_1.IsRunCW();
        public bool bCV_Outtray_Left_1_Stop => !iCV_Outtray_Left_1.IsRunCW();
        public bool bStopper_Outtray_1_Up_Sol => iStopper_1_Sol.IsSolActive();
        public bool bStopper_Outtray_1_Down_Sol => iStopper_1_Sol.IsSolDeactive();
        public bool bCV_Outtray_Left_2_Run => iCV_Outtray_Left_2.IsRunCW();
        public bool bCV_Outtray_Left_2_Stop => !iCV_Outtray_Left_2.IsRunCW();
        public bool bStopper_Outtray_2_Up_Sol => iStopper_2_Sol.IsSolActive();
        public bool bStopper_Outtray_2_Down_Sol => iStopper_2_Sol.IsSolDeactive();

        //Set biến Y
        public ECODE Run_CV_Outtray_Left_1()
        {
            iCV_Outtray_Left_1.RunCW();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stop_CV_Outtray_Left_1()
        {
            iCV_Outtray_Left_1.Stop();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stopper_Outtray_1_Up()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iStopper_1_Sol.Active();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stopper_Outtray_1_Down()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iStopper_1_Sol.Deactive();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Run_CV_Outtray_Left_2()
        {
            iCV_Outtray_Left_2.RunCW();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stop_CV_Outtray_Left_2()
        {
            iCV_Outtray_Left_2.Stop();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stopper_Outtray_2_Up()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iStopper_2_Sol.Active();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stopper_Outtray_2_Down()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iStopper_2_Sol.Deactive();
            return ECODE.WORK_SUCCESS;
        }
    }
}

Mechanical/CV/MOuttray_Right_CV.cs
using Auto_Insert_Sim_Tray.HW.Interface;
using Auto_Insert_Sim_Tray.Mechanical;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static Auto_Insert_Sim_Tray.Define.IODefine;
using static Auto_Insert_Sim_Tray.Define.SystemEnum;

namespace Auto_Insert_Sim_Tray.Mechanical.CV
{
    public class MOuttray_Right_CV : M_Base
    {
        public IConveyor iCV_Outtray_Right_1;
        public IConveyor iCV_Outtray_Right_2;
        public ICylinder iStopper_1_Sol;
        public ICylinder iStopper_2_Sol;

        public bool IsEmpty_CV_1, IsEmpty_CV_2;

        public bool IsHaveTray_CV_Outtray_1, IsHaveTray_CV_Outtray_2;

        public MOuttray_Right_CV(IIO iIO, IAxis iAxis)
        {
            this.iIO = iIO;
            this.iAxis = iAxis;

            Unit_Type = UNIT_TYPE.RIGHT_OUTTRAY_CV;

            SetConveyor(DO._13_CV_OUTTRAY_RIGHT_OUTPUT_1, null, null, null, DI._13_SS_OUTTRAY_RIGHT_DETECT_1, ref iCV_Outtray_Right_1);
            SetConveyor(DO._13_CV_OUTTRAY_RIGHT_OUTPUT_2, null, null, null, DI._13_SS_OUTTRAY_RIGHT_DETECT_2, ref iCV_Outtray_Right_2);
            SetSingleCylinder(DO._12_SOL_OUTTRAY_STOPPER_RIGHT_DOWN_1, null, DI._14_SS_OUTTRAY_RIGHT_STOPPER_1_UP, DI._14_SS_OUTTRAY_RIGHT_STOPPER_1_DOWN, ref iStopper_1_Sol);
            SetSingleCylinder(DO._12_SOL_OUTTRAY_STOPPER_RIGHT_DOWN_2, null, DI._14_SS_OUTTRAY_RIGHT_STOPPER_2_UP, DI._14_SS_OUTTRAY_RIGHT_STOPPER_2_DOWN, ref iStopper_2_Sol);
        }


        //Khai báo biến X
        public bool bDetect_Outtray_1_Chk => iCV_Outtray_Right_1.IsOutSensor();
        public bool bStopper_Outtray_1_Up_Chk => iStopper_1_Sol.IsActive();
        public bool bStopper_Outtray_1_Down_Chk => iStopper_1_Sol.IsDeactive();
        public bool bDetect_Outtray_2_Chk => iCV_Outtray_Right_2.IsOutSensor();
        public bool bStopper_Outtray_2_Up_Chk => iStopper_2_Sol.IsActive();
        public bool bStopper_Outtray_2_Down_Chk => iStopper_2_Sol.IsDeactive();

        //Khai báo biến Y
        public bool bCV_Outtray_Right_1_Run => iCV_Outtray_Right_1.IsRunCW();
        public bool bCV_Outtray_Right_1_Stop => !iCV_Outtray_Right_1.IsRunCW();
        public bool bStopper_Outtray_1_Up_Sol => iStopper_1_Sol.IsSolActive();
        public bool bStopper_Outtray_1_Down_Sol => iStopper_1_Sol.IsSolDeactive();
        public bool bCV_Outtray_Right_2_Run => iCV_Outtray_Right_2.IsRunCW();
        public bool bCV_Outtray_Right_2_Stop => !iCV_Outtray_Right_2.IsRunCW();
        public bool bStopper_Outtray_2_Up_Sol => iStopper_2_Sol.IsSolActive();
        public bool bStopper_Outtray_2_Down_Sol => iStopper_2_Sol.IsSolDeactive();

        //Set biến Y
        public ECODE Run_CV_Outtray_Right_1()
        {
            iCV_Outtray_Right_1.RunCW();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stop_CV_Outtray_Right_1()
        {
            iCV_Outtray_Right_1.Stop();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stopper_Outtray_1_Up()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iStopper_1_Sol.Active();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stopper_Outtray_1_Down()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iStopper_1_Sol.Deactive();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Run_CV_Outtray_Right_2()
        {
            iCV_Outtray_Right_2.RunCW();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stop_CV_Outtray_Right_2()
        {
            iCV_Outtray_Right_2.Stop();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stopper_Outtray_2_Up()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iStopper_2_Sol.Active();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stopper_Outtray_2_Down()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iStopper_2_Sol.Deactive();
            return ECODE.WORK_SUCCESS;
        }
    }
}

Mechanical/Intray/MIntray_Base.cs
using Auto_Insert_Sim_Tray.HW.Interface;
using Auto_Insert_Sim_Tray.Utils;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static Auto_Insert_Sim_Tray.Define.AxisDefine;
using static Auto_Insert_Sim_Tray.Define.IODefine;
using static Auto_Insert_Sim_Tray.Define.SystemEnum;

namespace Auto_Insert_Sim_Tray.Mechanical.Intray
{
    public abstract class MIntray_Base : M_Base
    {
        public object Intray_Detect_4_Chk;

        public ICylinder iHold_Sol;
        public ICylinder iSeperate_Sol;
        public ICylinder iElevator_1_Sol;
        public ICylinder iElevator_2_Sol;
        public ICylinder iRemove_Down_Sol;
        public ICylinder iRemove_BW_Sol;
        public ICylinder iAlign_Sol;
        public ICylinder iAlign_Top_Sol;

        public IConveyor iCV_Work;

        public bool IsHaveTray_Work_Left, IsHaveTray_Align_Left, IsHaveTray_Work_Right, IsHaveTray_Align_Right;
        public bool IsAlign_Done_Left, IsAlign_Done_Right;

        public PulseIO PulseTray;
        //public PulseFlag Pulse_Tray = new PulseFlag();

        public bool IsHaveNew_Tray;
        //Khai báo biến X
        public bool bHold_On_Chk => iHold_Sol.IsActive();
        public bool bHold_Off_Chk => iHold_Sol.IsDeactive();
        public bool bSeparate_On_Chk => iSeperate_Sol.IsActive();
        public bool bSeparate_Off_Chk => iSeperate_Sol.IsDeactive();
        public bool bElevator_1_FW_Chk => iElevator_1_Sol.IsActive();
        public bool bElevator_1_BW_Chk => iElevator_1_Sol.IsDeactive();
        public bool bElevator_2_FW_Chk => iElevator_2_Sol.IsActive();
        public bool bElevator_2_BW_Chk => iElevator_2_Sol.IsDeactive();
        public bool bRemove_Up_Chk => iRemove_Down_Sol.IsActive();
        public bool bRemove_Down_Chk => iRemove_Down_Sol.IsDeactive();
        public bool bRemove_FW_Chk => iRemove_BW_Sol.IsActive();
        public bool bRemove_BW_Chk => iRemove_BW_Sol.IsDeactive();
        public bool bAlign_On_Chk => iAlign_Sol.IsActive();
        public bool bAlign_Off_Chk => iAlign_Sol.IsDeactive();
        public bool bAlign_Top_On_Chk => iAlign_Top_Sol.IsActive();
        //public bool bAlign_Top_Off_Chk => iAlign_Top_Sol.IsDeactive();

        public bool bIntray_Detect_4 => iIO.IsOn(Intray_Detect_4_Chk); //Khai báo ss thường mở

        public bool bIntray_Detect_3 => iCV_Work.IsOutSensor();

        //Khai báo biến Y
        public bool bHold_On_Sol => iHold_Sol.IsSolActive();
        public bool bHold_Off_Sol => iHold_Sol.IsSolDeactive();
        public bool bSeparate_On_Sol => iSeperate_Sol.IsSolActive();
        public bool bSeparate_Off_Sol => iSeperate_Sol.IsSolDeactive();
        public bool bElevator_1_FW_Sol => iElevator_1_Sol.IsSolActive();
        public bool bElevator_1_BW_Sol => iElevator_1_Sol.IsSolDeactive();
        public bool bElevator_2_FW_Sol => iElevator_2_Sol.IsSolActive();
        public bool bElevator_2_BW_Sol => iElevator_2_Sol.IsSolDeactive();
        public bool bRemove_Up_Sol => iRemove_Down_Sol.IsSolActive();
        public bool bRemove_Down_Sol => iRemove_Down_Sol.IsSolDeactive();
        public bool bRemove_FW_Sol => iRemove_BW_Sol.IsSolActive();
        public bool bRemove_BW_Sol => iRemove_BW_Sol.IsSolDeactive();
        public bool bAlign_On_Sol => iAlign_Sol.IsSolActive();
        public bool bAlign_Off_Sol => iAlign_Sol.IsSolDeactive();
        public bool bAlign_Top_On_Sol => iAlign_Top_Sol.IsSolActive();
        public bool bAlign_Top_Off_Sol => iAlign_Top_Sol.IsSolDeactive();

        public bool bCV_Work_Run => iCV_Work.IsRunCW();
        public bool bCV_Work_Stop => !iCV_Work.IsRunCW();

        //Set biến Y
        public ECODE Hold_On()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iHold_Sol.Active();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Hold_Off()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iHold_Sol.Deactive();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Separate_On()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iSeperate_Sol.Active();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Separate_Off()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iSeperate_Sol.Deactive();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Elevator_1_FW()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iElevator_1_Sol.Active();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Elevator_1_BW()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iElevator_1_Sol.Deactive();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Elevator_2_FW()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iElevator_2_Sol.Active();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Elevator_2_BW()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iElevator_2_Sol.Deactive();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Remove_Up()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iRemove_Down_Sol.Active();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Remove_Down()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iRemove_Down_Sol.Deactive();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Remove_FW()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iRemove_BW_Sol.Active();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Remove_BW()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iRemove_BW_Sol.Deactive();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Align_On()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iAlign_Sol.Active();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Align_Off()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iAlign_Sol.Deactive();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Align_Top_On()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iAlign_Top_Sol.Active();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Align_Top_Off()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iAlign_Top_Sol.Deactive();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Run_CV_Work()
        {
            iCV_Work.RunCW();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stop_CV_Work()
        {
            iCV_Work.Stop();
            return ECODE.WORK_SUCCESS;
        }
    }
}

Mechanical/Intray/MIntray_Left.cs
using Auto_Insert_Sim_Tray.HW.Interface;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static Auto_Insert_Sim_Tray.Define.AxisDefine;
using static Auto_Insert_Sim_Tray.Define.IODefine;
using static Auto_Insert_Sim_Tray.Define.SystemEnum;

namespace Auto_Insert_Sim_Tray.Mechanical.Intray
{
    public class MIntray_Left : MIntray_Base
    {
        public MIntray_Left(IIO iIO, IAxis iAxis)
        {
            this.iIO = iIO;
            this.iAxis = iAxis;

            Unit_Type = UNIT_TYPE.INTRAY_LEFT;

            SetDoubleCylinder(DO._11_SOL_INTRAY_LEFT_HOLD_ON, 
                              DO._11_SOL_INTRAY_LEFT_HOLD_OFF, 
                              DI._11_SS_INTRAY_LEFT_HOLD_ON, 
                              DI._11_SS_INTRAY_LEFT_HOLD_OFF, ref iHold_Sol);
            SetDoubleCylinder(DO._11_SOL_INTRAY_LEFT_SEPERATE_ON, 
                              DO._11_SOL_INTRAY_LEFT_SEPERATE_OFF, 
                              DI._11_SS_INTRAY_LEFT_SEPERATE_ON, 
                              DI._11_SS_INTRAY_LEFT_SEPERATE_OFF, ref iSeperate_Sol);
            SetDoubleCylinder(DO._11_SOL_INTRAY_LEFT_ELEVATOR_1_FW, 
                              DO._11_SOL_INTRAY_LEFT_ELEVATOR_1_BW, 
                              DI._11_SS_INTRAY_LEFT_ELEVATOR_1_FW, 
                              DI._11_SS_INTRAY_LEFT_ELEVATOR_1_BW, ref iElevator_1_Sol);
            SetDoubleCylinder(DO._11_SOL_INTRAY_LEFT_ELEVATOR_2_FW,
                              DO._11_SOL_INTRAY_LEFT_ELEVATOR_2_BW,
                              DI._11_SS_INTRAY_LEFT_ELEVATOR_2_FW,
                              DI._11_SS_INTRAY_LEFT_ELEVATOR_2_BW, ref iElevator_2_Sol);
            SetDoubleCylinder(DO._11_SOL_INTRAY_LEFT_REMOVE_UP,
                              DO._11_SOL_INTRAY_LEFT_REMOVE_DOWN,
                              DI._11_SS_INTRAY_LEFT_REMOVE_UP,
                              DI._11_SS_INTRAY_LEFT_REMOVE_DOWN, ref iRemove_Down_Sol);
            SetDoubleCylinder(DO._11_SOL_INTRAY_LEFT_REMOVE_FW,
                              DO._11_SOL_INTRAY_LEFT_REMOVE_BW,
                              DI._11_SS_INTRAY_LEFT_REMOVE_FW,
                              DI._11_SS_INTRAY_LEFT_REMOVE_BW, ref iRemove_BW_Sol);
            SetSingleCylinder(DO._11_SOL_INTRAY_LEFT_ALIGN_OFF, 
                              null, 
                              DI._11_SS_INTRAY_LEFT_ALIGN_ON, 
                              DI._11_SS_INTRAY_LEFT_ALIGN_OFF, ref iAlign_Sol);
            SetSingleCylinder(DO._11_SOL_INTRAY_LEFT_ALIGN_TOP_OFF,
                              null,
                              DI._11_SS_INTRAY_LEFT_ALIGN_TOP_ON,
                              null, ref iAlign_Top_Sol);

            Set_IO_Value(DI._11_SS_INTRAY_LEFT_DETECT_4, ref Intray_Detect_4_Chk);

            SetConveyor(DO._13_CV_INTRAY_LEFT_WORK, null, null, null, DI._11_SS_INTRAY_LEFT_DETECT_3, ref iCV_Work);

            PulseTray = new Utils.PulseIO(this.iIO, DI._11_SS_INTRAY_LEFT_DETECT_4);
        }
    }
}

Mechanical/Intray/MIntray_Right.cs
using Auto_Insert_Sim_Tray.HW.Interface;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static Auto_Insert_Sim_Tray.Define.AxisDefine;
using static Auto_Insert_Sim_Tray.Define.IODefine;
using static Auto_Insert_Sim_Tray.Define.SystemEnum;

namespace Auto_Insert_Sim_Tray.Mechanical.Intray
{
    public class MIntray_Right : MIntray_Base
    {
        public MIntray_Right(IIO iIO, IAxis iAxis)
        {
            this.iIO = iIO;
            this.iAxis = iAxis;

            Unit_Type = UNIT_TYPE.INTRAY_RIGHT;

            SetDoubleCylinder(DO._11_SOL_INTRAY_RIGHT_HOLD_ON,
                              DO._11_SOL_INTRAY_RIGHT_HOLD_OFF,
                              DI._12_SS_INTRAY_RIGHT_HOLD_ON,
                              DI._12_SS_INTRAY_RIGHT_HOLD_OFF, ref iHold_Sol);
            SetDoubleCylinder(DO._11_SOL_INTRAY_RIGHT_SEPERATE_ON,
                              DO._11_SOL_INTRAY_RIGHT_SEPERATE_OFF,
                              DI._12_SS_INTRAY_RIGHT_SEPERATE_ON,
                              DI._12_SS_INTRAY_RIGHT_SEPERATE_OFF, ref iSeperate_Sol);
            SetDoubleCylinder(DO._11_SOL_INTRAY_RIGHT_ELEVATOR_1_FW,
                              DO._11_SOL_INTRAY_RIGHT_ELEVATOR_1_BW,
                              DI._12_SS_INTRAY_RIGHT_ELEVATOR_1_FW,
                              DI._12_SS_INTRAY_RIGHT_ELEVATOR_1_BW, ref iElevator_1_Sol);
            SetDoubleCylinder(DO._11_SOL_INTRAY_RIGHT_ELEVATOR_2_FW,
                              DO._11_SOL_INTRAY_RIGHT_ELEVATOR_2_BW,
                              DI._12_SS_INTRAY_RIGHT_ELEVATOR_2_FW,
                              DI._12_SS_INTRAY_RIGHT_ELEVATOR_2_BW, ref iElevator_2_Sol);
            SetDoubleCylinder(DO._11_SOL_INTRAY_RIGHT_REMOVE_UP,
                              DO._11_SOL_INTRAY_RIGHT_REMOVE_DOWN,
                              DI._12_SS_INTRAY_RIGHT_REMOVE_UP,
                              DI._12_SS_INTRAY_RIGHT_REMOVE_DOWN, ref iRemove_Down_Sol);
            SetDoubleCylinder(DO._11_SOL_INTRAY_RIGHT_REMOVE_FW,
                              DO._11_SOL_INTRAY_RIGHT_REMOVE_BW,
                              DI._12_SS_INTRAY_RIGHT_REMOVE_FW,
                              DI._12_SS_INTRAY_RIGHT_REMOVE_BW, ref iRemove_BW_Sol);
            SetSingleCylinder(DO._11_SOL_INTRAY_RIGHT_ALIGN_OFF,
                              null,
                              DI._12_SS_INTRAY_RIGHT_ALIGN_ON,
                              DI._12_SS_INTRAY_RIGHT_ALIGN_OFF, ref iAlign_Sol);
            SetSingleCylinder(DO._11_SOL_INTRAY_RIGHT_ALIGN_TOP_OFF,
                              null,
                              DI._12_SS_INTRAY_RIGHT_ALIGN_TOP_ON,
                              null, ref iAlign_Top_Sol);

            Set_IO_Value(DI._12_SS_INTRAY_RIGHT_DETECT_4, ref Intray_Detect_4_Chk);

            SetConveyor(DO._13_CV_INTRAY_RIGHT_WORK, null, null, null, DI._12_SS_INTRAY_RIGHT_DETECT_3, ref iCV_Work);

            PulseTray = new Utils.PulseIO(this.iIO, DI._12_SS_INTRAY_RIGHT_DETECT_4);

        }
    }
}

​x
 
Communication/Ethernet.cs
/* 
 * Copyright (C) Samsung Electronics Co., Ltd., Inc - All Rights Reserved
 * Unauthorized copying of this file, via any medium is strictly prohibited
 * Proprietary and confidential
 * 
 * Written by Donghyun Ko <dh79.ko@samsung.com>, June 2022
 * Written by Sanghyeon Lee <sirano06.lee@samsung.com>, June 2022
 * 
 */
using System;
using System.Collections.Generic;
using System.IO.Ports;
using System.Linq;
using System.Net;
using System.Net.NetworkInformation;
using System.Net.Sockets;
using System.Text;
using Auto_Insert_Sim_Tray.UI;
using Auto_Insert_Sim_Tray.Utils;
using Auto_Insert_Sim_Tray.Configs.Model;
using static Auto_Insert_Sim_Tray.Define.LogDefine;
​
namespace Auto_Insert_Sim_Tray.Communication
{
    /**
     * @brief Ethernet 모드
     */
    public enum EthernetMode
    {
        eNone,
        eServerMode,
        eClientMode
    };
​
    /**
     * @brief Ethernet 결과
     */
    public enum EthernetResult
    {
        SUCCESS,
        SERVER_ACCEPT_ERROR,
        CLIENT_CONNECT_ERROR,
        SEND_DATA_ERROR,
        SEND_DATA_CONNECT_CLOSE_ERROR,
    };
​
    /**
     * @brief 비동기 통신 상태 정보 클래스
     */
    public class ConnectedSocketStateObject
    {
        // Client  socket.  
        private Socket workSocket = null;
        // Size of receive buffer.  
        private const int bufferSize = 1024;
        // Receive buffer.  
        private byte[] receiveBuffer = new byte[bufferSize];
        // Receive buffer.  
        private int receiveDataSize;
        // Received data string.  
        private StringBuilder receiveDataStringBuilder = new StringBuilder();
​
        public Socket WorkSocket
        {
            get { return workSocket; }
            set { workSocket = value; }
        }
        public int BufferSize
        {
            get { return bufferSize; }
        }
        public byte[] ReceiveBuffer
        {
            get { return receiveBuffer; }
            set { receiveBuffer = value; }
        }
        public int ReceiveDataSize
        {
            get { return receiveDataSize; }
            set { receiveDataSize = value; }
        }
        public StringBuilder ReceiveDataStringBuilder
        {
            get { return receiveDataStringBuilder; }
            set { receiveDataStringBuilder = value; }
        }
​
        public void ClearBuffer()
        {
            Array.Clear(receiveBuffer, 0, BufferSize); // Xóa và đặt các phần tử của mảng về giá trị mặc định là 0
        }
    }
​
    /**
     * @brief Ethernet 통신 클래스
     */
    public class Ethernet
    {
        private static string CLASS_NAME = "Ethernet";
​
        private const int MinimumPortNum = 0;
        private const int InvalidPortNum = -1;
​
        private EthernetMode mode;
        private IPAddress ipAddress;
        private int portNum;
        private Socket mainSocket;
        private IPEndPoint endPoint;
        public List<ConnectedSocketStateObject> connectedSocketList;
​
        public delegate void ConnectCallbackEvent(EthernetResult result, string remoteEndPoint);
        public event ConnectCallbackEvent ConnectCallbackEventHandler;
        public delegate void SendDataCallbackEvent(EthernetResult result, string remoteEndPoint, string sendData = null);
        public event SendDataCallbackEvent SendDataCallbackEventHandler;
        public delegate void ReceiveDataCallbackEvent(string readData, string remoteEndPoint);
        public event ReceiveDataCallbackEvent ReceiveDataCallbackEventHandler;
        public delegate void DisconnectedCallbackEvent(string remoteEndPoint);
        public event DisconnectedCallbackEvent DisconnectedCallbackEventHandler;
​
        
​
        /**
         * @brief Ethernet 클래스 생성자
         * @param[in] mode EthernetMode 타입의 모드
         * @param[in] ipAddress Target IP address (string)
         * @param[in] portNum Target port number
         */
        public Ethernet(EthernetMode mode = EthernetMode.eNone, string ipAddress = null, int portNum = InvalidPortNum)
        {
            this.mode = mode;
            this.ipAddress = IPAddress.Parse(ipAddress);
            this.portNum = portNum;
​
            mainSocket = null;
            endPoint = null;
        }
        /**
         * @brief Ethernet 클래스 생성자
         * @param[in] mode EthernetMode 타입의 모드
         * @param[in] ipAddress Target IP address (IPAddress)
         * @param[in] portNum Target port number
         */
        public Ethernet(EthernetMode mode = EthernetMode.eNone, IPAddress ipAddress = null, int portNum = InvalidPortNum)
        {
            this.mode = mode;
            this.ipAddress = ipAddress;
            this.portNum = portNum;
​
            mainSocket = null;
            endPoint = null;
        }
​
        /**
         * @brief Ethernet 연결 함수
         * @details 생성자로 전달 된 EthernetMode에 맞는 연결 요청
         */
        public void Connect()
        {
            LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, "Connect", CONTENT_TYPE.INFO);
            if (!IsOpen)
            {
                try
                {
                    switch (mode)
                    {
                        case EthernetMode.eServerMode:
                            startServer();
                            break;
​
                        case EthernetMode.eClientMode:
                            startClient();
                            break;
​
                        default:
                            LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, "Wrong mode", CONTENT_TYPE.DEBUG);
                            break;
                    }
                }
                catch (Exception ex)
                {
                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"{ex}", CONTENT_TYPE.EXCEPTION);
                    throw ex;
                }
            }
        }
​
        /**
         * @brief Ethernet 연결 종료 함수
         * @details 생성자로 전달 된 EthernetMode에 맞는 연결 종료 처리
         */
        public void DisConnect()
        {
            LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, "Disconnect", CONTENT_TYPE.INFO);
            try
            {
                switch (mode)
                {
                    case EthernetMode.eServerMode:
                        CloseAllSocket();
                        break;
                    case EthernetMode.eClientMode:
                        CloseAllSocket();
                        break;
                }
            }
            catch (Exception ex)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"{ex}", CONTENT_TYPE.EXCEPTION);
                throw ex;
            }
​
        }
​
        /**
         * @brief 서버 시작 함수
         * @details EthernetMode 중 server mode 일때 해당
         */
        private void startServer()
        {
            LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, "startServer", CONTENT_TYPE.DEBUG);
            if ((ipAddress == null) || (portNum < MinimumPortNum))
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, "Wrong parameter", CONTENT_TYPE.DEBUG);
                throw new Exception("Wrong parameter");
            }
​
            endPoint = new IPEndPoint(ipAddress, portNum);
            mainSocket = new Socket(ipAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
            connectedSocketList = new List<ConnectedSocketStateObject>();
​
            try
            {
                mainSocket.Bind(endPoint);
                mainSocket.Listen(10);
                mainSocket.BeginAccept(new AsyncCallback(AcceptCallback), mainSocket);
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, "Wrong BeginAccept", CONTENT_TYPE.INFO);
​
            }
            catch (Exception ex)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"{ex}", CONTENT_TYPE.EXCEPTION);
                throw ex;
            }
        }
​
        /**
         * @brief 연결 허가 callback 함수
         * @param[in] ar IAsyncResult 타입으로 ascync state 등의 정보를 가지고 있는 매개변수
         */
        private void AcceptCallback(IAsyncResult ar)
        {
            LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, "AcceptCallback", CONTENT_TYPE.DEBUG);
            Socket client = null;
            try
            {
                // Get the socket that handles the client request.
                client = ((Socket)ar.AsyncState).EndAccept(ar);
                mainSocket.BeginAccept(AcceptCallback, mainSocket);
​
                // Create the state object.
                ConnectedSocketStateObject connSocketState = new ConnectedSocketStateObject();
                connSocketState.WorkSocket = client;
                connectedSocketList.Add(connSocketState);
​
                ConnectCallbackEventHandler?.Invoke(EthernetResult.SUCCESS, client.RemoteEndPoint.ToString());
​
                client.BeginReceive(connSocketState.ReceiveBuffer, 0, connSocketState.BufferSize, 0, new AsyncCallback(ReceiveDataCallback), connSocketState);
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, "Accept success", CONTENT_TYPE.INFO);
​
            }
            catch (Exception ex)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"{ex}", CONTENT_TYPE.EXCEPTION);
                string endPoint = null;
​
                if ((client != null) && (client.RemoteEndPoint != null))
                {
                    endPoint = client.RemoteEndPoint.ToString();
                }
                ConnectCallbackEventHandler?.Invoke(EthernetResult.SERVER_ACCEPT_ERROR, endPoint);
            }
        }
​
        /**
         * @brief Client 시작 함수
         * @details EthernetMode 중 client mode 일때 해당
         */
        public void startClient()
        {
            LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, "startClient", CONTENT_TYPE.DEBUG);
            if ((ipAddress == null) || (portNum < MinimumPortNum))
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, "Wrong parameter", CONTENT_TYPE.DEBUG);
                throw new Exception("Wrong parameter");
            }
​
            endPoint = new IPEndPoint(ipAddress, portNum);
            mainSocket = new Socket(ipAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
​
            if (!mainSocket.Connected)
            {
                try
                {
                    mainSocket.BeginConnect(endPoint, new AsyncCallback(ConnectCallback), mainSocket);
                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, "BeginConnect", CONTENT_TYPE.INFO);
                }
                catch (Exception ex)
                {
                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"{ex}", CONTENT_TYPE.EXCEPTION);
                    throw new Exception("Start client error!");
                }
            }
        }
​
        /**
         * @brief Connection에 대한 응답이 이루어지는 함수
         * @param[in] ar IAsyncResult 타입으로 ascync state 등의 정보를 가지고 있는 매개변수
         */
        private void ConnectCallback(IAsyncResult ar)
        {
            LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, "ConnectCallback", CONTENT_TYPE.DEBUG);
            Socket client = null;
            try
            {
                // Retrieve the socket from the state object.  
                client = (Socket)ar.AsyncState;
​
                // Complete the connection.  
                client.EndConnect(ar);
​
                ConnectedSocketStateObject connSocketState = new ConnectedSocketStateObject();
                connSocketState.WorkSocket = mainSocket;
​
                ConnectCallbackEventHandler?.Invoke(EthernetResult.SUCCESS, ipAddress.ToString());
​
                client.BeginReceive(connSocketState.ReceiveBuffer, 0, connSocketState.BufferSize, 0, new AsyncCallback(ReceiveDataCallback), connSocketState);
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, "BeginReceive", CONTENT_TYPE.INFO);
​
​
            }
            catch (Exception ex)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"{ex}", CONTENT_TYPE.EXCEPTION);
                ConnectCallbackEventHandler?.Invoke(EthernetResult.CLIENT_CONNECT_ERROR, ipAddress.ToString());
                CloseAllSocket();
            }
        }
​
        /**
         * @brief Target으로 부터 receive 받게 되면 불리는 함수
         * @param[in] ar IAsyncResult 타입으로 ascync state 등의 정보를 가지고 있는 매개변수
         */
        private void ReceiveDataCallback(IAsyncResult ar)
        {
            LogUtil.Instance.Log(LOG_TYPE.TCP_LOG, $"[{mode}][Port {portNum}] ReceiveData:", CONTENT_TYPE.LOG);
            string content = String.Empty;
​
            // Retrieve the state object and the handler socket  
            // from the asynchronous state object.  
            ConnectedSocketStateObject connSocketState = (ar.AsyncState) as ConnectedSocketStateObject;
​
            try
            {
                // Read data from the remote socket.
                connSocketState.ReceiveDataSize = connSocketState.WorkSocket.EndReceive(ar);
​
                if (connSocketState.ReceiveDataSize > 0)
                {
                    // There  might be more data, so store the data received so far.  
                    connSocketState.ReceiveDataStringBuilder.Append(Encoding.UTF8.GetString(connSocketState.ReceiveBuffer, 0, connSocketState.ReceiveDataSize));
                    content = connSocketState.ReceiveDataStringBuilder.ToString();
                    connSocketState.ClearBuffer();
                    connSocketState.ReceiveDataStringBuilder.Clear();
                    connSocketState.ReceiveDataSize = 0;
                    ReceiveDataCallbackEventHandler?.Invoke(content, connSocketState.WorkSocket.RemoteEndPoint.ToString());
​
                    connSocketState.WorkSocket.BeginReceive(connSocketState.ReceiveBuffer, 0, connSocketState.BufferSize, 0, new AsyncCallback(ReceiveDataCallback), connSocketState);            
                    LogUtil.Instance.Log(LOG_TYPE.TCP_LOG, $"[{connSocketState.WorkSocket.RemoteEndPoint}]{content}", CONTENT_TYPE.LOG);
                }
                else
                {
                    throw new Exception("ReceivedDataSize Error!");
                }
            }
            catch (ObjectDisposedException objectDisposedException)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"{objectDisposedException}", CONTENT_TYPE.EXCEPTION);
            }
            catch (Exception ex)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"{ex}", CONTENT_TYPE.EXCEPTION);
​
                string endPoint = null;
​
                if (mode == EthernetMode.eServerMode)
                {
                    if ((connSocketState != null) && (connSocketState.WorkSocket != null))
                    {
                        if (connSocketState.WorkSocket.RemoteEndPoint != null)
                        {
                            endPoint = connSocketState.WorkSocket.RemoteEndPoint.ToString();
                        }
                        removeDisconnectedSocket(connSocketState.WorkSocket);
                    }
                }
                else
                {
                    endPoint = ipAddress.ToString();
                }
​
                DisconnectedCallbackEventHandler?.Invoke(endPoint);
            }
        }
​
        /**
         * @brief 연결이 끊긴 socket을 메모리에서 제거하는 함수
         * @param[in] socket 연결 끊긴 socket
         */
        private void removeDisconnectedSocket(Socket socket)
        {
            if (connectedSocketList != null)
            {
                for (int connectedClientsCount = connectedSocketList.Count - 1; connectedClientsCount >= 0; connectedClientsCount--)
                {
                    ConnectedSocketStateObject connSocketState = connectedSocketList[connectedClientsCount];
                    if (socket.RemoteEndPoint.Equals(connSocketState.WorkSocket.RemoteEndPoint) &&
                        socket.LocalEndPoint.Equals(connSocketState.WorkSocket.LocalEndPoint))
                    {
                        connSocketState.WorkSocket.Close();
                        connectedSocketList.RemoveAt(connectedClientsCount);
                        break;
                    }
                }
            }
        }
​
        /**
         * @brief 데이터 전송 함수
         * @param[in] data 전송할 데이터
         * @param[in] remoteIpAddress Target의 IP address (string)
         * @param[in] remotePortNum Target의 Port number
         */
        public void SendData(string data, string remoteIpAddress = null, int remotePortNum = InvalidPortNum)
        {
​
            LogUtil.Instance.Log(LOG_TYPE.TCP_LOG, $"[{mode}][Port {portNum}] SendData: {data}", CONTENT_TYPE.LOG);
            if (mode == EthernetMode.eClientMode)
            {
                if (isSocketConnected(mainSocket))
                {
                    LogUtil.Instance.Log(LOG_TYPE.TCP_LOG, $"[{mainSocket.RemoteEndPoint}]{data}", CONTENT_TYPE.LOG);
                    SendData(mainSocket, data);
                }
                else
                {
                    if (mainSocket != null)
                    {
                        SendDataCallbackEventHandler?.Invoke(EthernetResult.SEND_DATA_CONNECT_CLOSE_ERROR, mainSocket.RemoteEndPoint.ToString());
                    }
                    CloseAllSocket();
                }
            }
            else
            {
                Socket client = null;
                for (int connectedClientsCount = connectedSocketList.Count - 1; connectedClientsCount >= 0; connectedClientsCount--)
                {
                    ConnectedSocketStateObject connSocketState = connectedSocketList[connectedClientsCount];
                    if ((remoteIpAddress == null)
                        || ((remoteIpAddress != null) && IsSameDestination(remoteIpAddress, remotePortNum, connSocketState.WorkSocket)))
                    {
                        client = connSocketState.WorkSocket;
                        if (isSocketConnected(client))
                        {
                            LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"[{client.RemoteEndPoint}]{data}", CONTENT_TYPE.DEBUG);
                            SendData(client, data);
                        }
                        else
                        {
                            string endPoint = null;
​
                            if (client != null && client.RemoteEndPoint != null)
                            {
                                endPoint = client.RemoteEndPoint.ToString();
                            }
                            SendDataCallbackEventHandler?.Invoke(EthernetResult.SEND_DATA_CONNECT_CLOSE_ERROR, endPoint);
                            DisconnectedCallbackEventHandler?.Invoke(endPoint);
​
                            client.Close();
                            connectedSocketList.RemoveAt(connectedClientsCount);
                        }
                    }
                }
            }
        }
​
        /**
         * @brief 데이터 전송 함수
         * @param[in] handler 전송할 Target의 socket
         * @param[in] data 전송할 데이터
         */
​
        private void SendData(Socket handler, string data)
        {
            // Convert the string data to byte data using ASCII encoding.  
            byte[] byteData = Encoding.UTF8.GetBytes(data);
            //byte[] byteData = Encoding.ASCII.GetBytes(data);
​
            string endPoint = null;
​
            if (handler != null && handler.RemoteEndPoint != null)
            {
                endPoint = handler.RemoteEndPoint.ToString();
            }
​
            try
            {
                if (handler != null)
                {
                    // Begin sending the data to the remote device.  
                    handler.BeginSend(byteData, 0, byteData.Length, 0, new AsyncCallback(SendDataCallback), handler);
                    SendDataCallbackEventHandler?.Invoke(EthernetResult.SUCCESS, endPoint, data);
                }
            }
            catch (Exception ex)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"{ex}", CONTENT_TYPE.EXCEPTION);
                SendDataCallbackEventHandler?.Invoke(EthernetResult.SEND_DATA_ERROR, endPoint);
​
            }
        }
​
        /**
         * @brief 데이터 전송 후 불리는 callback 함수
         * @param[in] ar IAsyncResult 타입으로 ascync state 등의 정보를 가지고 있는 매개변수
         */
        private void SendDataCallback(IAsyncResult ar)
        {
            Socket handler = null;
​
            try
            {
                // Retrieve the socket from the state object.  
                handler = (Socket)ar.AsyncState;
​
                // Complete sending the data to the remote device.  
                int bytesSent = handler.EndSend(ar);
​
                if (handler != null)
                {
                    SendDataCallbackEventHandler?.Invoke(EthernetResult.SUCCESS, handler.RemoteEndPoint.ToString());
                }
            }
            catch (Exception ex)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"{ex}", CONTENT_TYPE.EXCEPTION);
​
                string endPoint = null;
​
                if (handler != null && handler.RemoteEndPoint != null)
                {
                    endPoint = handler.RemoteEndPoint.ToString();
                }
                SendDataCallbackEventHandler?.Invoke(EthernetResult.SEND_DATA_ERROR, endPoint);
            }
        }
​
        /**
         * @brief 연결 된 모든 socket 연결 종료 함수
         * @details ServerMode 일 경우에만 사용 
         */
        private void CloseAllSocket()
        {
            try
            {
                if (mainSocket != null)
                {
                    mainSocket.Close();
                }
​
                if ((mode == EthernetMode.eServerMode) && (connectedSocketList != null))
                {
                    for (int connectedClientsCount = connectedSocketList.Count - 1; connectedClientsCount >= 0; connectedClientsCount--)
                    {
                        ConnectedSocketStateObject connSocketState = connectedSocketList[connectedClientsCount];
                        if ((connSocketState != null) && (connSocketState.WorkSocket != null))
                        {
                            connSocketState.WorkSocket.Close();
                        }
                        connectedSocketList.RemoveAt(connectedClientsCount);
                    }
                }
​
                mainSocket = null;
                connectedSocketList = null;
            }
            catch (Exception ex)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"{ex}", CONTENT_TYPE.EXCEPTION);
                throw ex;
            }
        }
​
        /**
         * @brief 소켓이 연결 되어있는지 확인하는 함수
         * @param[in] socket Target socket
         */
        private bool isSocketConnected(Socket socket)
        {
            bool result = false;
            IPGlobalProperties ipProperties = IPGlobalProperties.GetIPGlobalProperties();
​
            TcpConnectionInformation[] tcpConnections;
​
            try
            {
                if (socket == null)
                {
                    throw new Exception("Socket is null");
                }
                else
                {
                    tcpConnections = ipProperties.GetActiveTcpConnections().Where(
                        x => x.LocalEndPoint.Equals(socket.LocalEndPoint) && x.RemoteEndPoint.Equals(socket.RemoteEndPoint)).ToArray();
                }
            }
            catch (Exception ex)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"{ex}", CONTENT_TYPE.EXCEPTION);
                return false;
            }
​
            if ((tcpConnections != null) && (tcpConnections.Length > 0))
            {
                TcpState stateOfConnection = tcpConnections.First().State;
​
                if (stateOfConnection == TcpState.Established)
                {
                    result = true; ;
                }
            }
​
            return result;
        }
​
        /**
         * @brief End point가 동일한 목적지인지 확인하는 함수 (동일 Target인지)
         * @param[in] remoteIpAddress Target IP address (string)
         * @param[in] remotePortNum Target port number
         * @param[in] socket Target socket
         * @return 동일한지 여부
         */
        private bool IsSameDestination(string remoteIpAddress, int remotePortNum, Socket socket)
        {
            bool result = false;
​
            try
            {
                IPEndPoint endPoint = (IPEndPoint)socket.RemoteEndPoint;
                string socketIpAddress = endPoint.Address.ToString();
                if (remoteIpAddress.Equals(socketIpAddress))
                {
                    if (remotePortNum != InvalidPortNum)
                    {
                        if (remotePortNum == endPoint.Port)
                        {
                            result = true;
                        }
                    }
                    else
                    {
                        result = true;
                    }
                }
            }
            catch (Exception ex)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"{ex}", CONTENT_TYPE.EXCEPTION);
                throw ex;
            }
​
            return result;
        }
​
        /**
         * @brief 현재 나의 IPAdress 얻는 클래스
         * @return IPAddress의 루프백
         */
        private IPAddress GetDefaultIpAddress()
        {
            IPHostEntry hostEntry = Dns.GetHostEntry(Dns.GetHostName());
            foreach (IPAddress address in hostEntry.AddressList)
            {
                if (address.AddressFamily == AddressFamily.InterNetwork)
                {
                    return address;
                }
            }
​
            return IPAddress.Loopback;
        }
        public bool IsOpen
        {
            get
            {
                if (connectedSocketList is null)
                {
                    return false;
                }
                return true;
            }
        }
        //private void LogDataSent(string msg)
        //{
​
        //    LogUtil.Instance.Log(LOG_TYPE.TCP_LOG, $"{mSerialPort.PortName} => {msg}", CONTENT_TYPE.LOG);
        //}
        //private void LogDataRecv(string msg)
        //{
        //    LogUtil.Instance.Log(LOG_TYPE.TCP_LOG, $"{mSerialPort.PortName} <= {msg}", CONTENT_TYPE.LOG);
        //}
    }
}
​
Configs/Model/AxisParamData.Cs
/* 
 * Copyright (C) Samsung Electronics Co., Ltd., Inc - All Rights Reserved
 * Unauthorized copying of this file, via any medium is strictly prohibited
 * Proprietary and confidential
 * 
 * Written by Donghyun Ko <dh79.ko@samsung.com>, June 2022
 * Written by Sanghyeon Lee <sirano06.lee@samsung.com>, June 2022
 * 
 */
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
​
namespace Auto_Insert_Sim_Tray.Configs.Model
{
    /**
     * @brief Axis 동작시키기위한 Data 클래스
     * @details scale, 평상시/Jog이동시/Origin시의 속도, 가감속을 입력받아야 한다
     */
    public class AxisParamData
    {
        // distance = pitch * 톱니바퀴 갯수
        // scale = resolution / distance
​
        //public object resolution; //pulse;
        //public object distance; //mm
        //public object vel; // (mm/s)
        //public object acc; // (ms)
        //public object dec; // (ms)
        //public object jogVel; // (mm/s)
        //public object jogAcc; // (ms)
        //public object jogDec; // (ms)
        //public object oriVel; // (mm/s)
        //public object oriAcc; // (ms)
        //public object oriDec; // (ms)
        //public object oriReturn; // (pulse)
​
        /*
         * Fix by hung96.tran
         */
        [DisplayName("[Axis Parameter] Resolution")]
        [Description("Resolution for motor (pulse)")]
        [JsonProperty]
        [TypeConverter(typeof(AxisParamExpandableObjectConverter))]
        public object resolution { get; set; } //pulse;
​
        [DisplayName("[Axis Parameter] Distance")]
        [Description("Distance of motor's pulley (cm)")]
        [JsonProperty]
        [TypeConverter(typeof(AxisParamExpandableObjectConverter))]
        public object distance { get; set; } //cm
​
        [DisplayName("[Axis Parameter] Velocity high")]
        [Description("Default motor velocity high (mm/s)")]
        [JsonProperty]
        [TypeConverter(typeof(AxisParamExpandableObjectConverter))]
        public object vel_high { get; set; } = 0;// (cm/s)
​
        [DisplayName("[Axis Parameter] Velocity medium")]
        [Description("Default motor velocity medium (mm/s)")]
        [JsonProperty]
        [TypeConverter(typeof(AxisParamExpandableObjectConverter))]
        public object vel_medium { get; set; } = 0;// (cm/s)
​
        [DisplayName("[Axis Parameter] Velocity low")]
        [Description("Default motor velocity low (mm/s)")]
        [JsonProperty]
        [TypeConverter(typeof(AxisParamExpandableObjectConverter))]
        public object vel_low { get; set; } = 0; // (cm/s)
​
        [DisplayName("[Axis Parameter] Velocity value maximum")]
        [Description("Default motor velocity value maximum (mm/s)")]
        [JsonProperty]
        [TypeConverter(typeof(AxisParamExpandableObjectConverter))]
        public object vel_value_max { get; set; } = 0; // (cm/s)
​
        [DisplayName("[Axis Parameter] Velocity value minimum")]
        [Description("Default motor velocity value minimum (mm/s)")]
        [JsonProperty]
        [TypeConverter(typeof(AxisParamExpandableObjectConverter))]
        public object vel_value_min { get; set; } = 0; // (cm/s)
​
        [DisplayName("[Axis Parameter] Acceleration")]
        [Description("Default motor acceleration (ms)")]
        [JsonProperty]
        [TypeConverter(typeof(AxisParamExpandableObjectConverter))]
        public object acc { get; set; } // (ms)
​
        [DisplayName("[Axis Parameter] Deceleration")]
        [Description("Default motor dcceleration (ms)")]
        [JsonProperty]
        [TypeConverter(typeof(AxisParamExpandableObjectConverter))]
        public object dec { get; set; } // (ms)
​
        [DisplayName("[Axis Parameter] Jog velocity")]
        [Description("Jog motor velocity (mm/s)")]
        [JsonProperty]
        [TypeConverter(typeof(AxisParamExpandableObjectConverter))]
        public object jogVel { get; set; } = 0; // (mm/s)
​
        [DisplayName("[Axis Parameter] Jog acceleration")]
        [Description("Jog motor acceleration (ms)")]
        [JsonProperty]
        [TypeConverter(typeof(AxisParamExpandableObjectConverter))]
        public object jogAcc { get; set; } // (ms)
​
        [DisplayName("[Axis Parameter] Jog dcceleration")]
        [Description("Jog motor dcceleration (ms)")]
        [JsonProperty]
        [TypeConverter(typeof(AxisParamExpandableObjectConverter))]
        public object jogDec { get; set; } // (ms)
​
        [DisplayName("[Axis Parameter] Origin velocity")]
        [Description("Origin motor velocity (mm/s)")]
        [JsonProperty]
        [TypeConverter(typeof(AxisParamExpandableObjectConverter))]
        public object oriVel { get; set; }// (mm/s)
​
        [DisplayName("[Axis Parameter] Origin acceleration")]
        [Description("Origin motor acceleration (ms)")]
        [JsonProperty]
        [TypeConverter(typeof(AxisParamExpandableObjectConverter))]
        public object oriAcc { get; set; } // (ms)
​
        [DisplayName("[Axis Parameter] Origin dcceleration")]
        [Description("Origin motor dcceleration (ms)")]
        [JsonProperty]
        [TypeConverter(typeof(AxisParamExpandableObjectConverter))]
        public object oriDec { get; set; } // (ms)
​
        [DisplayName("[Axis Parameter] Origin return value")]
        [Description("If you don't use origin origin and limit +, - sensors, you can insert null (pulse)")]
        [JsonProperty]
        [TypeConverter(typeof(AxisParamExpandableObjectConverter))]
        public object oriReturn { get; set; } // (pulse)
​
        [DisplayName("[Axis Parameter] Inposition flag")]
        [Description("(Only Fastech) When motor be stopped, you can reference inposition flag or not (bool)")]
        [JsonProperty]
        //[TypeConverter(typeof(AxisParamExpandableObjectConverter))]
        public bool inpositionFlag { get; set; } // Motor Stop시 Inposition flag 확인 여부 설정(Only for Fastech)
​
        public AxisParamData(object resolution, object distance, object vel, object vel_low, object acc, object dec,
                           object jogVel, object jogAcc, object jogDec,
                           object oriVel, object oriAcc, object oriDec, object oriReturn = null, bool inpositionFlag = false)
        {
            this.resolution = resolution;
            this.distance = distance;
            this.vel_high = vel;
            this.vel_low = vel_low;
            this.acc = acc;
            this.dec = dec;
            this.jogVel = jogVel;
            this.jogAcc = jogAcc;
            this.jogDec = jogDec;
            this.oriVel = oriVel;
            this.oriAcc = oriAcc;
            this.oriDec = oriDec;
            this.oriReturn = oriReturn;
            this.inpositionFlag = inpositionFlag;
        }
​
        public AxisParamData() { }
    }
    public class AxisParamExpandableObjectConverter : ExpandableObjectConverter
    {
        double tempData = 0;
        public override bool CanConvertTo(ITypeDescriptorContext context, System.Type destinationType)
        {
            return true;
        }
​
        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, System.Type destinationType)
        {
            tempData = Convert.ToDouble(value);
            return Convert.ToString(value);
        }
​
        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
        {
            return true;
        }
​
        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
        {
            try
            {
                return Convert.ToDouble(value);
            }
            catch (Exception e)
            {
                MessageBox.Show(e.Message.ToString());
                return tempData;
            }
        }
    }
}
Configs/Model/ConfigMC.cs
using Microsoft.Office.Interop.Excel;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
​
namespace Auto_Insert_Sim_Tray.Configs.Model
{
    public class ConfigMC
    {
        //[Category("Out Tray")]
        //[Description("Number of tray")]
​
        [Category("Out Tray")]
        [DisplayName("Number of tray")]
        [Description("Number of tray")]
        [JsonProperty]
        public int Number_Of_Tray_Max { get; set; } = 0;
​
        [Browsable(false)]
        [Category("Out Tray")]
        [DisplayName("Current tray")]
        [Description("Current tray on out tray")]
        [JsonProperty]
        public int Count_Tray_OutTray { get; set; } = 0;
​
        [Category("Out Tray")]
        [DisplayName("Offset Tray")]
        [Description("Define Offset value (cm)")]
        [JsonProperty]
        public decimal Offset_OutTray { get; set; } = 0; //cm
​
        [Category("Cylinder Rotate")]
        [DisplayName("Cyliner Rotate LD SET Front")]
        [Description("Select true: Rotate Front/ false:  Rotate Rear")]
        [JsonProperty]
        public bool Rotate_LD_SET { get; set; } = true;
​
        [Category("Cylinder Rotate")]
        [DisplayName("Cyliner Rotate ULD SET Rear")]
        [Description("Select true: Rotate Front/ false:  Rotate Rear")]
        [JsonProperty]
        public bool Rotate_ULD_SET { get; set; } = true;
​
        [Category("By Pass Mode")]
        [DisplayName("Select where to place set")]
        [Description("Select true: Set OK/ false:  SET NG")]
        [JsonProperty]
        public bool ByPassSetOK { get; set; } = true;
​
        [Category("Jig Left")]
        [DisplayName("Number of insert Tray Sim Fail")]
        [Description("Number of insert Tray Sim Fail")]
        [JsonProperty]
        public int Number_Of_NG_Jig_Left { get; set; } = 0;
​
        [Category("Jig Right")]
        [DisplayName("Number of insert Tray Sim Fail")]
        [Description("Number of insert Tray Sim Fail")]
        [JsonProperty]
        public int Number_Of_NG_Jig_Right { get; set; } = 0;
​
        [Category("Robot XYZ")]
        [DisplayName("Number of Grip Tray Sim fail")]
        [Description("Number of Grip Tray Sim fail")]
        [JsonProperty]
        public int Number_Of_Grip_Tray_Sim_Fail { get; set; } = 0;
​
        //[Browsable(false)]
        [Category("Robot XYZ")]
        [DisplayName("Use Run Servo ABSLiner")]
        [Description("Cài đặt True sẽ chạy ABSLiner từ điểm Wait đi gắp Tray Sim, False sẽ chạy đơn từng trục từ điểm Wait đi gắp Tray Sim")] //Dùng cho trường hợp chạy ABSLiner bị giật trục ở vài điểm cố định
        [JsonProperty]
        public bool Use_Run_Servo_ABSLiner { get; set; } = true;
​
    }
}
​
Configs/Model/DelayTimeModel.cs
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
​
namespace Auto_Insert_Sim_Tray.Configs.Model
{
    public class DelayTimeModel
    {
        [Category("Cylinder of Jig")]
        [DisplayName("1. Cylinder Align Hor")]
        [Description("Define Align Hor Sol delay (s)")]
        [JsonProperty]
        public double Jig_Align_Hor_Delay { get; set; } = 0.1f; //s
        [Category("Cylinder of Jig")]
        [DisplayName("2. Cylinder Align Ver")]
        [Description("Define Align Hor Sol delay (s)")]
        [JsonProperty]
        public double Jig_Align_Ver_Delay { get; set; } = 0.1f; //s
​
        [Category("Cylinder of Shutter NG")]
        [DisplayName("1. NG Cylinder Up/Down")]
        [Description("Define Up/Down Sol delay (s)")]
        [JsonProperty]
        public double NG_UpDownSolDelay { get; set; } = 0.1f; //s
​
        [Category("Cylinder of Shutter NG")]
        [DisplayName("2. NG FW")]
        [Description("Define FW Sol delay (s)")]
        [JsonProperty]
        public double NG_FWSolDelay { get; set; } = 0.1f; //s
​
        [Category("Cylinder of Shutter NG")]
        [DisplayName("3. NG BW")]
        [Description("Define BW Sol delay (s)")]
        [JsonProperty]
        public double NG_BWSolDelay { get; set; } = 0.1f; //s
​
        [Category("Intray")]
        [DisplayName("1. Check Khay Tray Sim")]
        [Description("Define Check Tray Sim delay to Align  (s)")]
        [JsonProperty]
        public double Intray_Check_Tray_Sim_Delay { get; set; } = 0.1f; //s
​
        [Category("Intray")]
        [DisplayName("2. Cycliner Align Tray")]
        [Description("Define Cylinder Align delay (s)")]
        [JsonProperty]
        public double Intray_Align_Delay { get; set; } = 0.1f; //s
​
        [Category("Intray")]
        [DisplayName("3. Cycliner Unalign Tray")]
        [Description("Define Cylinder Align delay (s)")]
        [JsonProperty]
        public double Intray_Unalign_Delay { get; set; } = 0.1f; //s
​
        [Category("Intray")]
        [DisplayName("4. Separate Tray Sim")]
        [Description("Define Cylinder Cylinder of Intray delay (s)")]
        [JsonProperty]
​
        public double Step_Separate_Delay { get; set; } = 0.1f; //s
​
        [Category("Robot XYZ")]
        [DisplayName("1. Time check NG")]
        [Description("Define time check NG when insert sim tray (s)")]
        [JsonProperty]
        public double Insert_Sim_Tray_Check_NG { get; set; } = 0.1f; //s
​
        [Category("Robot XYZ")]
        [DisplayName("2. Grip Sim Tray ")]
        [Description("Define time Grip Sim Tray delay (s)")]
        [JsonProperty]
        public double RobotXYZ_Grip_Delay { get; set; } = 0.1f; //s
​
        [Category("Robot XYZ")]
        [DisplayName("3. Down Cylinder Rear ")]
        [Description("Define time Down Cylinder Rear delay (s)")]
        [JsonProperty]
        public double RobotXYZ_Down_Rear_Delay { get; set; } = 0.1f; //s
​
        [Category("Robot XYZ")]
        [DisplayName("4. Down Cylinder Front ")]
        [Description("Define time Down Cylinder Front delay (s)")]
        [JsonProperty]
        public double RobotXYZ_Down_Front_Delay { get; set; } = 0.1f; //s
​
        [Category("Robot XYZ")]
        [DisplayName("5. Check Tray Sim ")]
        [Description("Define time to check Grip Tray Sim Ok or NG (s)")]
        [JsonProperty]
        public double RobotXYZ_Check_Tray_Sim { get; set; } = 0.1f; //s
​
​
​
​
​
        [Category("Conveyor")]
        [DisplayName("Load CV delay")]
        [Description("Define CV run after detecting sensor out On <-> Off (s)")]
        [JsonProperty]
        public double LoadCVDelay { get; set; } = 0.1f; //s
​
        [Category("Conveyor")]
        [DisplayName("Unload CV delay")]
        [Description("Define CV run after detecting sensor out On <-> Off (s)")]
        [JsonProperty]
        public double UnloadCVDelay { get; set; } = 0.1f; //s
​
        [Category("Conveyor")]
        [DisplayName("CV Input Tray Sim")]
        [Description("Define CV Input Tray Sim run after detecting sensor out On <-> Off (s)")]
        [JsonProperty]
        public double CVInputDelay { get; set; } = 0.1f; //s
​
        [Category("Conveyor")]
        [DisplayName("CV Outtray Tray Sim")]
        [Description("Define CV Input Tray Sim run after detecting sensor out On <-> Off (s)")]
        [JsonProperty]
        public double CVOuttrayDelay { get; set; } = 0.1f; //s
​
​
        [Category("Testing")]
        [DisplayName("Dry Run Testing time")]
        [Description("Define Dry Run Testing Time (s)")]
        [JsonProperty]
        public double TestDryrunTime { get; set; } = 10.0f; //s  
​
        [Category("Testing")]
        [DisplayName("Dry Run Down RF Cable time")]
        [Description("Define Dry Run Down RF Cable time (s)")]
        [JsonProperty]
        public double TestRFDownTime { get; set; } = 5.0f; //s  
​
        [Category("Buzzer")]
        [DisplayName("On buzzer time")]
        [Description("Define buzzer time (s)")]
        [JsonProperty]
        public double OnBuzzerTime { get; set; } = 5.0f; //s  
​
        [Category("Common")]
        [DisplayName("Out Set Timer")]
        [Description("Define Out Set Timer (s)")]
        [JsonProperty]
        public double OutSetTime { get; set; } = 5.0f; //s  
​
        [Category("Load SET")]
        [DisplayName("1. Time check model SET")]
        [Description("Define  Time check model SET vs model Tray Sim delay (s)")]
        [JsonProperty]
        public double Wait_To_LD_Pick_Set { get; set; } = 0.1f; //s
​
        [Category("Load SET")]
        [DisplayName("2. Clamp On LD")]
        [Description("Define time Clamp On LD delay (s)")]
        [JsonProperty]
        public double Clamp_On_LD_Delay { get; set; } = 0.1f; //s
​
        [Category("Load SET")]
        [DisplayName("3. Clamp On ULD")]
        [Description("Define time Clamp On ULD delay (s)")]
        [JsonProperty]
        public double Clamp_On_ULD_Delay { get; set; } = 0.1f; //s
    }
}
​
Configs/Model/LogisticModel.cs
/* 
 * Copyright (C) Samsung Electronics Co., Ltd., Inc - All Rights Reserved
 * Unauthorized copying of this file, via any medium is strictly prohibited
 * Proprietary and confidential
 * 
 * Written by Donghyun Ko <dh79.ko@samsung.com>, June 2022
 * Written by Sanghyeon Lee <sirano06.lee@samsung.com>, June 2022
 * 
 */
using Auto_Insert_Sim_Tray.Utils;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static Auto_Insert_Sim_Tray.Define.SystemDefine;
​
namespace Auto_Insert_Sim_Tray.Configs.Model
{
    /**
     * @brief 물류 프로그램에서 사용할 Config의 데이터 클래스
     * @details Json property 타입의 변수들을 가지는 클래스
     */
    public class LogisticModel
    {
        [Browsable(false)]
        [Category("Logistics")]
        [DisplayName("Make metal duration")]
        [Description("Make metal duration for dry run(ms)")]
        [JsonProperty]
        public int MakeMetalDurationForDryrun { get; set; } = 5000; //ms
​
        [Browsable(false)]
        [Category("Logistics")]
        [DisplayName("Use door sensor")]
        [Description("Select true/false to use door sensor")]
        [JsonProperty]
        public bool IsUseDoorSensor { get; set; } = true;
​
        [Browsable(false)]
        [Category("Logistics")]
        [DisplayName("Use area sensor")]
        [Description("Select true/false to use area sensor")]
        [JsonProperty]
        public bool IsUseAreaSensor { get; set; } = true;
​
        [Category("Logistics")]
        [DisplayName("Use sensor check tray sim")]
        [Description("Select true/false to use area sensor")]
        [JsonProperty]
        public bool IsUseSensorCheckTraySim { get; set; } = true;
​
        //[Category("Logistics")]
        //[DisplayName("Use printer label")]
        //[Description("Select true/false to use printer label")]
        //[JsonProperty]
        //public bool IsUsePrinter { get; set; } = true;
​
        [Category("Logistics")]
        [DisplayName("X Ready Signal at CV In")]
        [Description("True: NC Signal || False: NO Signal")]
        [JsonProperty]
        public bool IsIF_XReady_CVIn_NC { get; set; } = true;
​
        [Category("Logistics")]
        [DisplayName("Y Busy Signal at CV In")]
        [Description("True: NC Signal || False: NO Signal")]
        [JsonProperty]
        public bool IsIF_YBusy_CVIn_NC { get; set; } = true;
​
        [Category("Logistics")]
        [DisplayName("X Busy Signal at CV Out")]
        [Description("True: NC Signal || False: NO Signal")]
        [JsonProperty]
        public bool IsIF_XBusy_CVOut_NC { get; set; } = true;
​
        [Category("Logistics")]
        [DisplayName("Y Ready Signal at CV Out")]
        [Description("True: NC Signal || False: NO Signal")]
        [JsonProperty]
        public bool IsIF_YReady_CVOut_NC { get; set; } = true;
​
        [Category("Logistics")]
        [DisplayName("Last machine")]
        [Description("Select true/false to check last machine for same modules or line")]
        [JsonProperty]
        public bool IsEndMachine { get; set; } = false;
​
        [Category("Logistics")]
        [DisplayName("Barcode")]
        [Description("Select true/false to use or not use Barcode")]
        [JsonProperty]
        public bool UseBarcode { get; set; } = false;
​
        [Category("Logistics")]
        [DisplayName("Vision")]
        [Description("Select true/false to use or not use Vision")]
        [JsonProperty]
        public bool UseVision { get; set; } = false;
​
        [Category("Logistics")]
        [DisplayName("AGV")]
        [Description("Select true/false to use or not use AGV")]
        [JsonProperty]
        public bool UseAGV { get; set; } = false;
​
        #region Logistics Time
        [Category("Logistics Time")]
        [DisplayName("#1 Shift Start Time")]
        [Description("Time to start #1 shift")]
        [JsonProperty]
        public string lineStartTime1 { get; set; } = "08:00";
​
        [Category("Logistics Time")]
        [DisplayName("#1 Shift End Time")]
        [Description("Time to end #1 shift")]
        [JsonProperty]
        public string lineEndTime1 { get; set; } = "17:00";
​
        [Category("Logistics Time")]
        [DisplayName("#2 Shift Start Time")]
        [Description("Time to start #2 shift")]
        [JsonProperty]
        public string lineStartTime2 { get; set; } = "21:30";
​
        [Category("Logistics Time")]
        [DisplayName("#2 Shift End Time")]
        [Description("Time to end #2 shift")]
        [JsonProperty]
        public string lineEndTime2 { get; set; } = "06:30";
​
        [Browsable(false)]
        [Category("Logistics Time")]
        [DisplayName("#1 Rest Start Time")]
        [Description("Time to start #1 rest time")]
        [JsonProperty]
        public string lineRestStartTime1 { get; set; } = "10:30";
​
        [Browsable(false)]
        [Category("Logistics Time")]
        [DisplayName("#1 Rest End Time")]
        [Description("Time to end #1 rest time")]
        [JsonProperty]
        public string lineRestEndTime1 { get; set; } = "10:45";
​
        [Browsable(false)]
        [Category("Logistics Time")]
        [DisplayName("#2 Rest Start Time")]
        [Description("Time to start #2 rest time")]
        [JsonProperty]
        public string lineRestStartTime2 { get; set; } = "15:00";
​
        [Browsable(false)]
        [Category("Logistics Time")]
        [DisplayName("#2 Rest End Time")]
        [Description("Time to end #2 rest time")]
        [JsonProperty]
        public string lineRestEndTime2 { get; set; } = "15:15";
​
        [Browsable(false)]
        [Category("Logistics Time")]
        [DisplayName("#3 Rest Start Time")]
        [Description("Time to start #3 rest time")]
        [JsonProperty]
        public string lineRestStartTime3 { get; set; } = "23:30";
​
        [Browsable(false)]
        [Category("Logistics Time")]
        [DisplayName("#3 Rest End Time")]
        [Description("Time to end #3 rest time")]
        [JsonProperty]
        public string lineRestEndTime3 { get; set; } = "23:45";
​
        [Browsable(false)]
        [Category("Logistics Time")]
        [DisplayName("#4 Rest Start Time")]
        [Description("Time to start #3 rest time")]
        [JsonProperty]
        public string lineRestStartTime4 { get; set; } = "03:30";
​
        [Browsable(false)]
        [Category("Logistics Time")]
        [DisplayName("#4 Rest End Time")]
        [Description("Time to end #4 rest time")]
        [JsonProperty]
        public string lineRestEndTime4 { get; set; } = "03:45";
​
        [Category("Logistics Time")]
        [DisplayName("Initializing interval(ms)")]
        [Description("Interval time for tact time or initializing system")]
        [JsonProperty]
        public int tactTimeResetCheckInterval { get; set; } = 1000 * 15; // 50sec
        #endregion
​
​
        //[Category("Logistics Password")]
        //[DisplayName("Password for dat tab")]
        //[Description("Password when you want to access data tab")]
        [ReadOnly(true)]
        [JsonProperty]
        public string dataPwd { get; set; } = "0000";
​
        //[Category("Logistics Password")]
        //[DisplayName("Password for origin tab")]
        //[Description("Password when you want to access origin tab. Which has to different from data tab and origin tab")]
        [ReadOnly(true)]
        [JsonProperty]
        public string originReturnPwd { get; set; } = "0001";
​
​
        [Browsable(false)]
        [Category("Block Condition")]
        [DisplayName("Continue fail block count")]
        [Description("Set continue fail block count (times)")]
        [JsonProperty]
        public int nPackFailBlockCount { get; set; } = 0;
​
        [Browsable(false)]
        [Category("Block Condition")]
        [DisplayName("Fail rate block percent")]
        [Description("Set fail rate block percent (%)")]
        [JsonProperty]
        public float nFailRateBlock { get; set; } = 100;
​
        [Browsable(false)]
        [Category("Block Condition")]
        [DisplayName("Max retest count on current JIG")]
        [Description("Set max retest count on current JIG (times)")]
        [JsonProperty]
        public int nRetestPackCount { get; set; } = 0;
​
        [Browsable(false)]
        [Category("Jig Tester Operation")]
        [DisplayName("Use retest tab on next JIG")]
        [Description("Select true/false to use retest tab on next JIG")]
        [JsonProperty]
        public bool IsUseRetestOnNextJig { get; set; } = true;
​
        [Browsable(false)]
        [Category("Jig Tester Operation")]
        [DisplayName("Delay Rf cable insert after Pack insert")]
        [Description("Define delay (ms)")]
        [JsonProperty]
        public uint RfCableInsertDelay { get; set; } = 30000;
​
        [Category("01 Line Name")]
        [DisplayName("Line Name")]
        [Description("Setup current line name")]
        [JsonProperty]
        public string sLineName { get; set; } = "01";
​
        //[Category("Common")]
        //[DisplayName("Use blow dusty")]
        //[Description("Select true/false to use blow dusty")]
        //[JsonProperty]
        //public bool IsUseBlowDusty { get; set; } = true;
​
        //[Category("Common")]
        //[DisplayName("Use clean vinyl")]
        //[Description("Select true/false to use clean vinyl")]
        //[JsonProperty]
        //public bool IsUseCleanVinyl { get; set; } = true;
​
        [Browsable(false)]
        [Category("Logistics")]
        [DisplayName("Model name")]
        [Description("Current selected model name")]
        [JsonProperty]
        public string modelName { get; set; } = "None";
​
        [Browsable(false)]
        [Category("Logistics")]
        [DisplayName("Model name sim tray left")]
        [Description("Current selected model name sim tray left")]
        [JsonProperty]
        public string modelSimTrayLeft { get; set; } = "None";
​
        [Browsable(false)]
        [Category("Logistics")]
        [DisplayName("Model name sim tray right")]
        [Description("Current selected model name sim tray right")]
        [JsonProperty]
        public string modelSimTrayRight { get; set; } = "None";
​
        [Browsable(false)]
​
        public MACHINE_TYPE modelType = MACHINE_TYPE.B;
​
        public ProductInfoModel productInfo { get; set; } = new ProductInfoModel();
​
        public TactTimeUtil TackTime = new TactTimeUtil();
    }
}
Configs/Model/VisionConfig.cs
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static Auto_Insert_Sim_Tray.Define.SystemEnum;
​
namespace Auto_Insert_Sim_Tray.Configs.Model
{
    public class VisionConfig
    {
        [Browsable(false)]
        [Category("Vision Left")]
        [DisplayName("IP Address of Vision Left")]
        [Description("IP Address of Vision Left")]
        [JsonProperty]
        public string IPAddress_Vision_1 { get; set; } = "107.114.203.127";
​
        [Category("Vision Left")]
        [DisplayName("Port of Vision Left")]
        [Description("Port of Vision Left")]
        [JsonProperty]
        public int Port_Vision_1 { get; set; } = 5000;
​
        [Category("Vision Left")]
        [DisplayName("Use Vision Left")]
        [Description("Select true/false to use or not use Vision Left")]
        [JsonProperty]
        public bool UseVision_Left { get; set; } = true;
​
        [Browsable(false)]
        [Category("Vision Right")]
        [DisplayName("IP Address of Vision Right")]
        [Description("IP Address of Vision Right")]
        [JsonProperty]
        public string IPAddress_Vision_2 { get; set; } = "107.114.203.127";
​
        [Category("Vision Right")]
        [DisplayName("Port of Vision Right")]
        [Description("Port of Vision Right")]
        [JsonProperty]
        public int Port_Vision_2 { get; set; } = 5050;
​
        [Category("Vision Right")]
        [DisplayName("Use Vision Right")]
        [Description("Select true/false to use or not use Vision Right")]
        [JsonProperty]
        public bool UseVision_Right { get; set; } = true;
​
​
        [Category("Vision Setting")]
        [DisplayName("Timeout")]
        [Description("Timeout")]
        [JsonProperty]
        public int TimeOut { get; set; } = 3000; //ms
​
        [Category("Vision Setting")]
        [DisplayName("Max Retry")]
        [Description("Max Retry")]
        [JsonProperty]
        public int MaxRetry { get; set; } = 3;
​
        [Browsable(false)]
        [Category("Vision Setting")]
        [DisplayName("Read Command")]
        [Description("Read Command")]
        [JsonProperty]
        public string ReadCommand { get; set; } = "grab";
    }
    /*public class VisionConfig
    {
        [JsonProperty]
        public string Name { get; set; }
        [JsonProperty]
        public string IPAddress { get; set; }
        [JsonProperty]
        public int Port { get; set; }
    }*/
}
​
Configs/JsonHelper.cs
/* 
 * Copyright (C) Samsung Electronics Co., Ltd., Inc - All Rights Reserved
 * Unauthorized copying of this file, via any medium is strictly prohibited
 * Proprietary and confidential
 * 
 * Written by Donghyun Ko <dh79.ko@samsung.com>, June 2022
 * Written by Sanghyeon Lee <sirano06.lee@samsung.com>, June 2022
 * 
 */
using Auto_Insert_Sim_Tray.Configs.Model;
using Auto_Insert_Sim_Tray.Define;
using Auto_Insert_Sim_Tray.Define.Position;
using Auto_Insert_Sim_Tray.HW.Common;
using Auto_Insert_Sim_Tray.Utils;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Ports;
using System.Linq;
using System.Runtime.Serialization.Json;
using System.Text;
using System.Threading.Tasks;
using static Auto_Insert_Sim_Tray.Define.AxisDefine;
using static Auto_Insert_Sim_Tray.Define.LogDefine;
using static Auto_Insert_Sim_Tray.Define.SystemEnum;
using static Auto_Insert_Sim_Tray.HW.Vendor.Fastech.Lib.EZI_COMM_DEFINE;
​
namespace Auto_Insert_Sim_Tray.Configs
{
    /**
     * @brief Json parsing과 write 를 지원하는 class
     * @details newton json library 활용으로 Json 형태의 파일의 직렬/역직렬화 하여 변수로 read / write 할 수 있다
     */
    public class JsonHelper
    {
        private static JsonHelper instance;
        public static JsonHelper Instance
        {
            get
            {
                if (instance == null)
                    instance = new JsonHelper();
                return instance;
            }
        }
​
        // TODO : 아래 Json 으로 read / write 할 자료구조 선정 및 변수 선언 후 이용
        [JsonProperty]
        public LogisticModel logisticModel = new LogisticModel();
        
​
        [JsonProperty]
        public Dictionary<AXIS_LIST, AxisParamData> axisParams = new Dictionary<AXIS_LIST, AxisParamData>()
        {
            { AXIS_LIST.X_AXIS_LD_SET, new AxisParamData() },
            { AXIS_LIST.X_AXIS_ULD_SET, new AxisParamData() },
​
            { AXIS_LIST.X_AXIS_ROBOTXYZ, new AxisParamData() },
            { AXIS_LIST.Y_AXIS_ROBOTXYZ, new AxisParamData() },
            { AXIS_LIST.Z_AXIS_ROBOTXYZ, new AxisParamData() },
​
            { AXIS_LIST.X_AXIS_ULD_TRAY, new AxisParamData() },
            { AXIS_LIST.Z_AXIS_OUT_TRAY, new AxisParamData() },
​
            { AXIS_LIST.R_AXIS_RELOAD_SIM, new AxisParamData() },
        };
​
        /*[JsonProperty]
        public Dictionary<LIST_ETHERNET, EthernetModel> ethernetConnections = new Dictionary<LIST_ETHERNET, EthernetModel>()
        {
            {LIST_ETHERNET.VISION_1, new EthernetModel() { Name = "VISION 1", IPAddress = "127.0.0.1", Port = 0} },
            {LIST_ETHERNET.VISION_2, new EthernetModel() { Name = "VISION 2", IPAddress = "127.0.0.1", Port = 1} },
        };*/
        [JsonProperty]
        public Dictionary<AxisPositionKey, Tuple<decimal, decimal>> axisPos = new Dictionary<AxisPositionKey, Tuple<decimal, decimal>>(new AxisPositionComparer());
​
        [JsonProperty]
        public Dictionary<int, Tuple<string, string, string>> errorMsg = new Dictionary<int, Tuple<string, string, string>>();
​
        //[JsonProperty]
        //public Dictionary<SerialPortElement, SerialPortModel> serialPortModel = new Dictionary<SerialPortElement, SerialPortModel>()
        //{
        //    {SerialPortElement.SERIAL_PC1, new SerialPortModel(){PortName = "COM10", ReadTimeout = 3000, WriteTimeout = 3000} },
        //};
​
        [JsonProperty]
        public DelayTimeModel delayTime = new DelayTimeModel();
​
        [JsonProperty]
        public TimeoutModel timeout = new TimeoutModel();
​
        [JsonProperty]
        public ConfigMC configMC = new ConfigMC();
​
        //[JsonProperty]
        //public Vinyl_MC2_Model vinyl_MC2_Model = new Vinyl_MC2_Model();
​
        //[JsonProperty]
        //public AxisZ_Wait_Offset_Model offset = new AxisZ_Wait_Offset_Model();
​
        [JsonProperty]
        public List<string> modelList = new List<string>();
​
        [JsonProperty]
        public Dictionary<string, string> models = new Dictionary<string, string>();
​
        [JsonProperty]
        public ProductInfoModel productInfo = new ProductInfoModel();
​
        [JsonProperty]
        public VisionConfig visionConfig = new VisionConfig();
​
        [JsonProperty]
        public BarcodeConfig barcodeConfig = new BarcodeConfig();
​
        [JsonProperty]
        public Dictionary<TOWERLAMP_MODE, TOWERLAMP_ELEMENT> towerLamp = new Dictionary<TOWERLAMP_MODE, TOWERLAMP_ELEMENT>()
        {
            { TOWERLAMP_MODE.MANUAL, TOWERLAMP_ELEMENT.Y },
            { TOWERLAMP_MODE.AUTO, TOWERLAMP_ELEMENT.G },
            { TOWERLAMP_MODE.ERROR, TOWERLAMP_ELEMENT.R },
            { TOWERLAMP_MODE.OPP, TOWERLAMP_ELEMENT.Y },
            { TOWERLAMP_MODE.OP_CALL, TOWERLAMP_ELEMENT.Y },
            { TOWERLAMP_MODE.IDLE, TOWERLAMP_ELEMENT.Y },
        };
​
        [JsonProperty]
        public Dictionary<string, PatternsModel> patterns = new Dictionary<string, PatternsModel>();
​
        public Dictionary<AXIS_LIST, Tuple<int, int>> dic_Limit_Speed = new Dictionary<AXIS_LIST, Tuple<int, int>>();
        /**
         * @details 원하는 Config type의 json 저장 경로를 리턴해 준다
         * @param[in] type CONFIG_TYPE : JSON config type
         * @todo CONFIG_TYPE이 추가되면 case 추가 필요하다
         * @return 해당 Config의 JSON 파일 경로를 리턴한다
         */
        private string GetPath(CONFIG_TYPE type)
        {
            string path = "";
            switch (type)
            {
                case CONFIG_TYPE.LOGISTIC:
                    path = ConfigDefine.logisticJson;
                    break;
                case CONFIG_TYPE.AXIS:
                    path = ConfigDefine.axisParamJson;
                    break;
                case CONFIG_TYPE.PRODUCT_INFO:
                    path = ConfigDefine.productInfoJson;
                    break;
                case CONFIG_TYPE.ERROR:
                    path = ConfigDefine.errorJson;
                    break;
                case CONFIG_TYPE.SERIAL_PORT:
                    path = ConfigDefine.serialJson;
                    break;
                case CONFIG_TYPE.DELAY_TIME:
                    path = ConfigDefine.delayTimeJson;
                    break;
                case CONFIG_TYPE.TIMEOUT:
                    path = ConfigDefine.timeoutJson;
                    break;
                case CONFIG_TYPE.MODEL_LIST:
                    path = ConfigDefine.modelListJson;
                    break;
                case CONFIG_TYPE.MODEL:
                    path = ConfigDefine.modelJson;
                    break;
                case CONFIG_TYPE.AXIS_POS:
                    path = ConfigDefine.axisPosDirectory + JsonHelper.Instance.logisticModel.modelName + "_AxisPos.json";
                    break;
                case CONFIG_TYPE.PATTERNS:
                    path = ConfigDefine.patternJson;
                    break;
                case CONFIG_TYPE.VISION:
                    path = ConfigDefine.vision;
                    break;
                case CONFIG_TYPE.TOWER_LAMP:
                    path = ConfigDefine.towerLampJson;
                    break;
                case CONFIG_TYPE.CONFIG_MC:
                    path = ConfigDefine.config_MC;
                    break;
                default:
                    break;
            }
            return path;
        }
​
        /**
         * @details CONFIG_TYPE에 맞춰 serialize 하기 위한 객체를 리턴해준다
         * @param[in] type CONFIG_TYPE : JSON config type
         * @todo CONFIG_TYPE 추가 시에, 리턴하는 객체 case를 추가해야 한다
         * @return CONFIG를 저장하고 있는 멤버변수를 object화 하여 리턴한다
         */
        private object GetSerialInstance(CONFIG_TYPE type)
        {
            object ob;
            switch (type)
            {
                case CONFIG_TYPE.LOGISTIC:
                    ob = logisticModel;
                    break;
                case CONFIG_TYPE.AXIS:
                    ob = axisParams;
                    break;
                case CONFIG_TYPE.PRODUCT_INFO:
                    ob = productInfo;
                    break;
                case CONFIG_TYPE.TOWER_LAMP:
                    ob = towerLamp;
                    break;
                case CONFIG_TYPE.ERROR:
                    ob = errorMsg;
                    break;
                case CONFIG_TYPE.SERIAL_PORT:
                    ob = barcodeConfig;
                    break;
                case CONFIG_TYPE.DELAY_TIME:
                    ob = delayTime;
                    break;
                case CONFIG_TYPE.TIMEOUT:
                    ob = timeout;
                    break;
                case CONFIG_TYPE.MODEL_LIST:
                    ob = modelList;
                    break;
                case CONFIG_TYPE.MODEL:
                    ob = models;
                    break;
                case CONFIG_TYPE.AXIS_POS:
                    ob = axisPos;
                    break;
                case CONFIG_TYPE.PATTERNS:
                    ob = patterns;
                    break;
                case CONFIG_TYPE.VISION:
                    ob = visionConfig;
                    break;
                case CONFIG_TYPE.CONFIG_MC:
                    ob = configMC;
                    break;
                default:
                    ob = null;
                    break;
            }
            return ob;
        }
​
        private Type GetType(CONFIG_TYPE type)
        {
            Type ob;
            switch (type)
            {
                case CONFIG_TYPE.LOGISTIC:
                    ob = logisticModel.GetType();
                    break;
                case CONFIG_TYPE.AXIS:
                    ob = axisParams.GetType();
                    break;
                case CONFIG_TYPE.AXIS_POS:
                    ob = axisPos.GetType();
                    break;
                case CONFIG_TYPE.PRODUCT_INFO:
                    ob = productInfo.GetType();
                    break;
                case CONFIG_TYPE.TOWER_LAMP:
                    ob = towerLamp.GetType();
                    break;
                case CONFIG_TYPE.ERROR:
                    ob = errorMsg.GetType();
                    break;
                case CONFIG_TYPE.SERIAL_PORT:
                    ob = barcodeConfig.GetType();
                    break;
                case CONFIG_TYPE.TIMEOUT:
                    ob = timeout.GetType();
                    break;
                case CONFIG_TYPE.MODEL_LIST:
                    ob = modelList.GetType();
                    break;
                case CONFIG_TYPE.MODEL:
                    ob = models.GetType();
                    break;
                case CONFIG_TYPE.DELAY_TIME:
                    ob = delayTime.GetType();
                    break;
                case CONFIG_TYPE.PATTERNS:
                    ob = patterns.GetType();
                    break;
                case CONFIG_TYPE.VISION:
                    ob = visionConfig.GetType();
                    break;
                case CONFIG_TYPE.CONFIG_MC:
                    ob = configMC.GetType();
                    break;
                default:
                    ob = null;
                    break;
            }
            return ob;
        }
​
        /**
         * @details 읽어온 Json string을 deserialize하여 객체화 한다
         * @param[in] type CONFIG_TYPE : JSON config type
         * @param[in] strJson Json에서 읽어온 string 데이터
         * @todo CONFIG_TYPE 추가 시에, 객체화 하는 case 추가
         */
        public void Deserialize(CONFIG_TYPE type, string strJson)
        {
            if (strJson != "")
            {
                DataContractJsonSerializer serializer = new DataContractJsonSerializer(GetType(type));
​
                switch (type)
                {
                    case CONFIG_TYPE.LOGISTIC:
                        logisticModel = JsonConvert.DeserializeObject<LogisticModel>(strJson);
                        break;
                    case CONFIG_TYPE.AXIS:
                        axisParams = JsonConvert.DeserializeObject<Dictionary<AXIS_LIST, AxisParamData>>(strJson);
                        break;
                    case CONFIG_TYPE.PRODUCT_INFO:
                        productInfo = JsonConvert.DeserializeObject<ProductInfoModel>(strJson);
                        break;
                    case CONFIG_TYPE.TOWER_LAMP:
                        towerLamp = JsonConvert.DeserializeObject<Dictionary<TOWERLAMP_MODE, TOWERLAMP_ELEMENT>>(strJson);
                        break;
                    case CONFIG_TYPE.ERROR:
                        errorMsg = JsonConvert.DeserializeObject<Dictionary<int, Tuple<string, string, string>>>(strJson);
                        break;
                    case CONFIG_TYPE.SERIAL_PORT:
                        barcodeConfig = JsonConvert.DeserializeObject<BarcodeConfig>(strJson);
                        if (barcodeConfig.scanner is null)
                        {
                            barcodeConfig.scanner = new HW.BarcodeReader.BarcodeReaderConfig()
                            {
                                ReadCommand = "T",
                                DataLength = 10,
                                RetryRead = 3,
                                NewLine = "\r\n"
                            };
                        }
                        break;
                    case CONFIG_TYPE.DELAY_TIME:
                        delayTime = JsonConvert.DeserializeObject<DelayTimeModel>(strJson);
                        break;
                    case CONFIG_TYPE.TIMEOUT:
                        timeout = JsonConvert.DeserializeObject<TimeoutModel>(strJson);
                        break;
                    case CONFIG_TYPE.MODEL_LIST:
                        modelList = JsonConvert.DeserializeObject<List<string>>(strJson);
                        break;
                    case CONFIG_TYPE.MODEL:
                        models = JsonConvert.DeserializeObject<Dictionary<string, string>>(strJson);
                        break;
                    case CONFIG_TYPE.AXIS_POS:
                        // axisPos = JsonConvert.DeserializeObject<Dictionary<AxisPositionKey, Tuple<decimal, string>>>(strJson);
                        using (MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(strJson)))
                        {
                            Dictionary<AxisPositionKey, Tuple<decimal, decimal>> temp = (Dictionary<AxisPositionKey, Tuple<decimal, decimal>>)serializer.ReadObject(ms);
                            for (int i = 0; i < temp.Count(); i++)
                            {
                                if (axisPos.Keys.Contains(temp.ElementAt(i).Key))
                                {
                                    axisPos[temp.ElementAt(i).Key] = temp.ElementAt(i).Value;
                                }
                                else
                                {
                                    axisPos.Add(temp.ElementAt(i).Key, temp.ElementAt(i).Value);
                                }
                            }
                        }
                        break;
                    case CONFIG_TYPE.PATTERNS:
                        patterns = JsonConvert.DeserializeObject<Dictionary<string, PatternsModel>>(strJson);
                        break;
                    case CONFIG_TYPE.VISION:
                        visionConfig = JsonConvert.DeserializeObject<VisionConfig>(strJson);
                        break;
                    case CONFIG_TYPE.CONFIG_MC:
                        configMC = JsonConvert.DeserializeObject<ConfigMC>(strJson);
                        //if (configMC.scanner.Count == 0 || connectionData.screwConnections.Count == 0)
                        //{
                        //    //Init Defaul Value
                        //    InitDefaultValue(CONFIG_TYPE.CONNECTION);
                        //}
                        break;
                    default:
                        break;
                }
            }
        }
​
        /**
         * @details CONFIG_TYPE에 맞춰 JSON 파일에 내용 저장
         * @param[in] type CONFIG_TYPE : JSON config type
         */
        public void SaveSettings(CONFIG_TYPE type)
        {
            try
            {
                string path = GetPath(type);
​
                if (type == CONFIG_TYPE.AXIS_POS)
                {
                    if (!File.Exists(path))
                    {
                        string msg = "Config path not found : " + type.ToString();
                        LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, msg, CONTENT_TYPE.WARNING);
                        Directory.CreateDirectory(ConfigDefine.axisPosDirectory);
                    }
​
                    DataContractJsonSerializer serializer = new DataContractJsonSerializer(GetType(type));
                    using (MemoryStream ms = new MemoryStream())
                    {
                        serializer.WriteObject(ms, GetSerialInstance(type));
                        string strJson = Encoding.Default.GetString(ms.ToArray());
                        string strJson_Idt = JToken.Parse(strJson).ToString(Formatting.Indented);
                        File.WriteAllText(path, strJson_Idt, Encoding.UTF8);
                    }
                }
                else
                {
                    if (!File.Exists(path))
                    {
                        string msg = "Config path not found : " + type.ToString();
                        LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, msg, CONTENT_TYPE.WARNING);
                        Directory.CreateDirectory(ConfigDefine.configRootPath);
                    }
                    string strJson = JsonConvert.SerializeObject(GetSerialInstance(type));
                    string strJson_Idt = JToken.Parse(strJson).ToString(Formatting.Indented);
                    File.WriteAllText(path, strJson_Idt, Encoding.UTF8);
                }
            }
            catch (Exception ex)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, ex.ToString(), CONTENT_TYPE.EXCEPTION);
            }
        }
​
        /**
         * @details CONFIG_TYPE에 맞춰 JSON 파일에서 객체로 parsing 해오는 함수
         * @param[in] type CONFIG_TYPE : JSON config type
         */
        public void LoadSettings(CONFIG_TYPE type)
        {
            string path = GetPath(type);
​
            if (File.Exists(path) == true)
            {
                try
                {
                    string strJson = File.ReadAllText(path, Encoding.UTF8);
                    Deserialize(type, strJson);
                }
                catch (Exception ex)
                {
                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, ex.ToString(), CONTENT_TYPE.EXCEPTION);
                }
            }
            else
            {
                string msg = "File not found : " + type.ToString();
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, msg, CONTENT_TYPE.WARNING);
                SaveSettings(type);
            }
        }
    }
}
​
Define/AxisDefine.cs
/* 
 * Copyright (C) Samsung Electronics Co., Ltd., Inc - All Rights Reserved
 * Unauthorized copying of this file, via any medium is strictly prohibited
 * Proprietary and confidential
 * 
 * Written by Donghyun Ko <dh79.ko@samsung.com>, June 2022
 * Written by Sanghyeon Lee <sirano06.lee@samsung.com>, June 2022
 * 
 */
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
​
namespace Auto_Insert_Sim_Tray.Define
{
    [Serializable]
    public static class AxisDefine
    {
        public const decimal ACCEPTABLE_DISTANCE = 0.1m; //cm
        public const int AXIS_MOVE_DELAY = 100; // msec
​
        public enum AXIS_LIST
        {
            NONE = -1,
​
            X_AXIS_LD_SET,
            X_AXIS_ULD_SET,
​
            X_AXIS_ULD_TRAY,
​
            R_AXIS_RELOAD_SIM,
​
            X_AXIS_ROBOTXYZ,
            Y_AXIS_ROBOTXYZ,
            Z_AXIS_ROBOTXYZ,
​
            Z_AXIS_OUT_TRAY,
​
            
            MAX,
        }
​
        public enum X_LD_POSITION
        {
            NONE = -1,
            Wait,
​
            Input,
            Left_Jig,
            Right_Jig,
            //Max
        }
        public enum X_ULD_POSITION
        {
            NONE = -1,
            Wait,
​
            Output,
            NG,
            Left_Jig,
            Right_Jig,
            //Max
        }
        public enum XYZ_ROBOT_POSITION
        {
            NONE = -1,
            Wait,
            Wait_Unload_Tray,
​
            L_Wait_Check_Vision,
            L_Tray_Pick_Up_1,
            L_Tray_Pick_Up_2,
            L_Tray_Pick_Down_1,
            //L_Tray_Pick_Down_2,
            L_Jig_Insert_Up,
            L_Jig_Insert_Down_1,
            L_Jig_Insert_Down_2,
​
            R_Wait_Check_Vision,
            R_Tray_Pick_Up_1,
            R_Tray_Pick_Up_2,
            R_Tray_Pick_Down_1,
            //R_Tray_Pick_Down_2,
            R_Jig_Insert_Up,
            R_Jig_Insert_Down_1,
            R_Jig_Insert_Down_2,
​
            NG_Sim_Up,
            NG_Sim_Down,
​
            //Tọa độ trung gian khi gán từ vision
            
            
            L_Pos_1,
            L_Pos_2,
            L_Pos_3,
            L_Pos_4,
            L_Pos_5,
            L_Pos_6,
​
            R_Pos_1,
            R_Pos_2,
            R_Pos_3,
            R_Pos_4,
            R_Pos_5,
            R_Pos_6,
​
​
        }
        public enum X_ULD_TRAY_POSITION
        {
            NONE = -1,
            Wait,
​
            Left_Tray_Pick,
​
            Right_Tray_Pick,
​
            Place_Tray,
​
        }
        public enum Z_TF_OUTTRAY_POSITION
        {
            NONE = -1,
            Wait,
​
            Input_Tray,
​
            Output_Tray,
​
        }
​
​
        public enum LASER_POSITION
        {
            NONE = 1,
            READY,
            #region Module AC
            LASER_WORK_A,
            LASER_WORK_C,
            #endregion
            #region Module B
            LASER_WORK_B_0_DEGREE,
            LASER_WORK_B_90_DEGREE,
            LASER_WORK_B_180_DEGREE,
            LASER_WORK_B_270_DEGREE,
            #endregion
        }
    }
}
​
Define/ConfigDefine.cs
/* 
 * Copyright (C) Samsung Electronics Co., Ltd., Inc - All Rights Reserved
 * Unauthorized copying of this file, via any medium is strictly prohibited
 * Proprietary and confidential
 * 
 * Written by Donghyun Ko <dh79.ko@samsung.com>, June 2022
 * Written by Sanghyeon Lee <sirano06.lee@samsung.com>, June 2022
 * 
 */
using Auto_Insert_Sim_Tray.Configs;
using Auto_Insert_Sim_Tray.Configs.Model;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
​
namespace Auto_Insert_Sim_Tray.Define
{
    /**
     * @brief Config를 다루는데 필요한 상수들을 정의하는 클래스
     * @details 경로, 파일명 등의 저장이 가능함
     */
    public class ConfigDefine
    {
        public static string configRootPath = SystemDefine.rootPath + @"Json\";
        public static string axisPosDirectory = configRootPath + @"AxisPosition\";
​
        public static string logisticJson = configRootPath + @"Logistic.Json";
        public static string positionJson = configRootPath + @"Position.Json";
        public static string errorJson = configRootPath + @"ErrorCode.Json";
        public static string serialJson = configRootPath + @"SerialPort.Json";
        public static string productInfoJson = configRootPath + @"ProductInfo.Json";
        public static string axisParamJson = configRootPath + @"AxisParam.Json";
        public static string delayTimeJson = configRootPath + @"DelayTime.Json";
        public static string timeoutJson = configRootPath + @"Timeout.Json";
        public static string modelListJson = configRootPath + @"ModelList.Json";
        public static string modelJson = configRootPath + @"Model.Json";
        public static string axisPosJson = axisPosDirectory + JsonHelper.Instance.logisticModel.modelName + "_AxisPos.json";
        public static string metalLogisticsInfo = configRootPath + @"MetalLogisticsInfo.Json";
        public static string patternJson = configRootPath + @"Patterns.Json";
        //public static string offsetAxisJson = configRootPath + @"OffsetAxis.Json";
        public static string towerLampJson = configRootPath + @"Tower Lamp.Json";
        public static string config_MC = configRootPath + @"Config MC.Json";
        public static string vision = configRootPath + @"Vision.Json";
    }
​
    /**
     * @brief 물류 프로그램에서 다룰 Config 종류를 정의하는 enum
     * @details 기본적으로 물류, 모터, 검사결과, 에러코드, serial 설정들을 다룸
     * @todo 물류 프로그램에서 다룰 Config 종류의 추가가 필요하면 해당 enum에 추가해야 한다.
     */
    public enum CONFIG_TYPE
    {
        LOGISTIC = 0,
        AXIS,
        PRODUCT_INFO,
        ERROR,
        SERIAL_PORT,
        DELAY_TIME,
        TIMEOUT,
        MODEL_LIST,
        MODEL,
        AXIS_POS,
        PATTERNS,
        VISION,
        TOWER_LAMP,
        CONFIG_MC,
        
    }
}
​
Define/ConveyorDefine.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
​
namespace Auto_Insert_Sim_Tray.Define
{
    public enum CONVEYOR_LIST
    {
        NONE = -1,
        INPUT1,
        INPUT2,
        OUTPUT,
        MAX,
    }
​
    public class ConveyorData
    {
        public object runCW;
        public object runCCW;
        public object inSensor;
        public object middleSensor;
        public object outSensor;
​
        public ConveyorData(object runCW, object runCCW, object inSensor, object middleSensor, object outSensor)
        {
            this.runCW = runCW;
            this.runCCW = runCCW;
            this.inSensor = inSensor;
            this.middleSensor = middleSensor;
            this.outSensor = outSensor;
        }
    }
}
​
Define/IODefine.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
​
namespace Auto_Insert_Sim_Tray.Define
{
    /**
     * @brief 물류 프로그램에서 사용하는 IO를 define 하는 클래스
     * @details Input에 관한 DI와 output에 관한 DO가 있다
     */
    public static class IODefine
    {
        public enum DI
        {
            NONE = -1,
​
            #region MyRegion
            _10_EMG,
            _10_SS_DOOR,
            _10_BUTTON_START,
            _10_BUTTON_STOP,
            _10_BUTTON_RESET,
            _10_SS_LD_CLAMP_UP,
            _10_SS_LD_CLAMP_DOWN,
            _10_SS_LD_UP,
            _10_SS_LD_DOWN,
            _10_SS_LD_ROTATE_REAR,
            _10_SS_LD_ROTATE_FRONT,
            _10_SS_LD_ROTATE_MIDDLE,
            _10_SS_LD_CLAMP_OFF,
            _10_SS_LD_CLAMP_ON,
            _10_SS_ULD_UP,
            _10_SS_ULD_DOWN,
​
            _10_SS_ULD_ROTATE_REAR,
            _10_SS_ULD_ROTATE_FRONT,
            _10_SS_ULD_ROTATE_MIDDLE,
            _10_SS_ULD_CLAMP_OFF,
            _10_SS_ULD_CLAMP_ON,
            _10_SS_ULD_CLAMP_UP,
            _10_SS_ULD_CLAMP_DOWN,
            _10_SS_JIG_LEFT_POS_OUT,
            _10_SS_JIG_LEFT_POS_IN,
            _10_SS_JIG_LEFT_BW,
            _10_SS_JIG_LEFT_FW,
            _10_SS_JIG_LEFT_ALIGN_HOR_OFF,
            _10_SS_JIG_LEFT_ALIGN_HOR_ON,
            _10_SS_JIG_LEFT_ALIGN_VER_OFF,
            _10_SS_JIG_LEFT_ALIGN_VER_ON,
            _10_SS_JIG_LEFT_DETECT_SET,
​
​
            _11_SS_INTRAY_LEFT_HOLD_OFF,
            _11_SS_INTRAY_LEFT_HOLD_ON,
            _11_SS_INTRAY_LEFT_SEPERATE_OFF,
            _11_SS_INTRAY_LEFT_SEPERATE_ON,
            _11_SS_INTRAY_LEFT_ELEVATOR_1_BW,
            _11_SS_INTRAY_LEFT_ELEVATOR_1_FW,
            _11_SS_INTRAY_LEFT_ELEVATOR_2_BW,
            _11_SS_INTRAY_LEFT_ELEVATOR_2_FW,
            _11_SS_INTRAY_LEFT_STOPPER_1_DOWN,
            _11_SS_INTRAY_LEFT_STOPPER_1_UP,
            _11_SS_INTRAY_LEFT_STOPPER_2_DOWN,
            _11_SS_INTRAY_LEFT_STOPPER_2_UP,
            _11_SS_INTRAY_LEFT_REMOVE_DOWN,
            _11_SS_INTRAY_LEFT_REMOVE_UP,
            _11_SS_INTRAY_LEFT_REMOVE_BW,
            _11_SS_INTRAY_LEFT_REMOVE_FW,
​
            _11_SS_INTRAY_LEFT_ALIGN_OFF,
            _11_SS_INTRAY_LEFT_ALIGN_ON,
            _11_SS_INTRAY_LEFT_ALIGN_TOP_ON,
            _11_SS_INTRAY_LEFT_DETECT_1,
            _11_SS_INTRAY_LEFT_DETECT_2,
            _11_SS_INTRAY_LEFT_DETECT_3,
            _11_SS_INTRAY_LEFT_DETECT_4,
            _11_SS_JIG_RIGHT_POS_OUT,
            _11_SS_JIG_RIGHT_POS_IN,
            _11_SS_JIG_RIGHT_BW,
            _11_SS_JIG_RIGHT_FW,
            _11_SS_JIG_RIGHT_ALIGN_HOR_OFF,
            _11_SS_JIG_RIGHT_ALIGN_HOR_ON,
            _11_SS_JIG_RIGHT_ALIGN_VER_OFF,
            _11_SS_JIG_RIGHT_ALIGN_VER_ON,
            _11_SS_JIG_RIGHT_DETECT_SET,
​
​
            _12_SS_INTRAY_RIGHT_HOLD_OFF,
            _12_SS_INTRAY_RIGHT_HOLD_ON,
            _12_SS_INTRAY_RIGHT_SEPERATE_OFF,
            _12_SS_INTRAY_RIGHT_SEPERATE_ON,
            _12_SS_INTRAY_RIGHT_ELEVATOR_1_BW,
            _12_SS_INTRAY_RIGHT_ELEVATOR_1_FW,
            _12_SS_INTRAY_RIGHT_ELEVATOR_2_BW,
            _12_SS_INTRAY_RIGHT_ELEVATOR_2_FW,
            _12_SS_INTRAY_RIGHT_STOPPER_1_DOWN,
            _12_SS_INTRAY_RIGHT_STOPPER_1_UP,
            _12_SS_INTRAY_RIGHT_STOPPER_2_DOWN,
            _12_SS_INTRAY_RIGHT_STOPPER_2_UP,
            _12_SS_INTRAY_RIGHT_REMOVE_DOWN,
            _12_SS_INTRAY_RIGHT_REMOVE_UP,
            _12_SS_INTRAY_RIGHT_REMOVE_BW,
            _12_SS_INTRAY_RIGHT_REMOVE_FW,
​
            _12_SS_INTRAY_RIGHT_ALIGN_OFF,
            _12_SS_INTRAY_RIGHT_ALIGN_ON,
            _12_SS_INTRAY_RIGHT_ALIGN_TOP_ON,
            _12_SS_INTRAY_RIGHT_DETECT_1,
            _12_SS_INTRAY_RIGHT_DETECT_2,
            _12_SS_INTRAY_RIGHT_DETECT_3,
            _12_SS_INTRAY_RIGHT_DETECT_4,
            _12_SS_ULD_POS_OK,
            _12_SS_ULD_POS_NG,
            _12_SPARE2,
            _12_SS_NG_SHUTTER_DETECT_1,
            _12_SS_NG_SHUTTER_DETECT_2,
            _12_SS_NG_SHUTTER_DETECT_3,
            _12_SS_NG_SHUTTER_DETECT_4,
            _12_SS_NG_SHUTTER_BW,
            _12_SS_NG_SHUTTER_FW,
            
​
            _13_SS_TRAY_SIM_ROTATE_OFF,
            _13_SS_TRAY_SIM_ROTATE_ON,
            _13_SS_TRAY_SIM_TURN_OFF,
            _13_SS_TRAY_SIM_TURN_ON,
            _13_SS_TRAY_SIM_GRIP_OFF,
            _13_SS_TRAY_SIM_GRIP_ON,
            _13_SS_TRAY_SIM_PUSH_FRONT_UP,
            _13_SS_TRAY_SIM_PUSH_FRONT_DOWN,
            _13_SS_TRAY_SIM_PUSH_REAR_UP,
            _13_SS_TRAY_SIM_PUSH_REAR_DOWN,
            _13_SS_TRAY_SIM_GRIP_CHECK,
            _13_SS_UNLOAD_TRAY_UP,
            _13_SS_UNLOAD_TRAY_DOWN,
            _13_SS_UNLOAD_TRAY_CLAMP_OFF,
            _13_SS_UNLOAD_TRAY_CLAMP_ON,
            _13_SPARE0,
​
            _13_SS_OUTTRAY_LIFT_DETECT,
            _13_SS_OUTTRAY_TRANSFER_FRONT_BW,
            _13_SS_OUTTRAY_TRANSFER_FRONT_FW,
            _13_SS_OUTTRAY_TRANSFER_REAR_BW,
            _13_SS_OUTTRAY_TRANSFER_REAR_FW,
            _13_SS_OUTTRAY_REMOVE_BW,
            _13_SS_OUTTRAY_REMOVE_FW,
            _13_SS_OUTTRAY_PUSH_UP,
            _13_SS_OUTTRAY_PUSH_DOWN,
            _13_SS_OUTTRAY_TRANSFER_FRONT_DETECT,
            _13_SS_OUTTRAY_TRANSFER_REAR_DETECT,
            _13_SS_OUTTRAY_LEFT_DETECT_1,
            _13_SS_OUTTRAY_LEFT_DETECT_2,
            _13_SS_OUTTRAY_RIGHT_DETECT_1,
            _13_SS_OUTTRAY_RIGHT_DETECT_2,
            _13_SS_TRAY_SIM_CHECK_NG,
​
​
            _14_SS_OUTTRAY_STOPPER_TRANSFER_UP,
            _14_SS_OUTTRAY_STOPPER_TRANSFER_DOWN,
            _14_SS_OUTTRAY_LEFT_STOPPER_1_UP,
            _14_SS_OUTTRAY_LEFT_STOPPER_1_DOWN,
            _14_SS_OUTTRAY_LEFT_STOPPER_2_UP,
            _14_SS_OUTTRAY_LEFT_STOPPER_2_DOWN,
            _14_SS_OUTTRAY_RIGHT_STOPPER_1_UP,
            _14_SS_OUTTRAY_RIGHT_STOPPER_1_DOWN,
            _14_SS_OUTTRAY_RIGHT_STOPPER_2_UP,
            _14_SS_OUTTRAY_RIGHT_STOPPER_2_DOWN,
            _14_SS_JIG_LEFT_ALIGN_SIM_ON,
            _14_SS_JIG_LEFT_ALIGN_SIM_OFF,
            _14_SS_JIG_RIGHT_ALIGN_SIM_ON,
            _14_SS_JIG_RIGHT_ALIGN_SIM_OFF,
            _14_IN_AGV_1_1,
            _14_IN_AGV_1_2,
​
​
            _14_IN_AGV_1_3,
            _14_IN_AGV_1_4, // ON khi AGV bắt đầu transfer hàng sang Robot
            _14_IN_AGV_2_1,
            _14_IN_AGV_2_2,
            _14_IN_AGV_2_3,
            _14_IN_AGV_2_4, // ON khi AGV bắt đầu transfer hàng sang Robot
            _14_SS_CV_IN_DETECT_1,
            _14_SS_CV_IN_DETECT_2,
            _14_SS_CV_IN_DETECT_3,
            _14_SS_CV_OUT_DETECT_1,
            _14_SS_CV_OUT_DETECT_2,
            _14_SS_RELOAD_SIM_SAFETY,
            _14_SS_SAFETY_ZONE_INPUT,
            _14_SS_SAFETY_ZONE_OUTPUT,
            _14_IF_FRONT_READY,
            _14_IF_BEHIND_BUSY,
            #endregion
​
            IN_MAX,
            IN_MAX1,
        };
​
        public enum DO
        {
            NONE = -1,
​
            #region MyRegion
            _10_BUTTON_START_LAMP,
            _10_BUTTON_STOP_LAMP,
            _10_BUTTON_RESET_LAMP,
            _10_TOWERLAMP_GREEN,
            _10_TOWERLAMP_YELLOW,
            _10_TOWERLAMP_RED,
            _10_BUZZ,
            _10_SOL_LD_UP,
            _10_SOL_LD_DOWN,
            _10_SOL_LD_ROTATE_REAR,
            _10_SOL_LD_ROTATE_FRONT,
            _10_SOL_LD_CLAMP_ON,
            _10_SOL_LD_CLAMP_UP_DOWN,
            _10_SOL_ULD_UP,
            _10_SOL_ULD_DOWN,
            _10_SOL_ULD_ROTATE_REAR,
​
            _10_SOL_ULD_ROTATE_FRONT,
            _10_SOL_ULD_CLAMP_ON,
            _10_SOL_ULD_POS_OK,
            _10_SOL_ULD_POS_NG,
            _10_SOL_ULD_CLAMP_UP_DOWN,
            _10_OUT_AGV_1_2, // ON khi muốn AGV transfer hàng ở bên trái
            _10_OUT_AGV_1_1, // ON khi muốn AGV transfer hàng ở bên phải
            _10_OUT_AGV_1_4, // ON khi hoàn thành transfer giữa Robot với AGV
            _10_OUT_AGV_1_5, // ON khi băng tải ngoài cùng tầng trên trống
            _10_SOL_JIG_LEFT_POS_OUT,
            _10_SOL_JIG_LEFT_POS_IN,
            _10_SOL_JIG_LEFT_BW,
            _10_SOL_JIG_LEFT_FW,
            _10_SOL_JIG_LEFT_ALIGN_HOR,
            _10_SOL_JIG_LEFT_ALIGN_VER,
            _10_SOL_JIG_LEFT_ALIGN_SIM,
​
​
            _11_SOL_INTRAY_LEFT_HOLD_OFF,
            _11_SOL_INTRAY_LEFT_HOLD_ON,
            _11_SOL_INTRAY_LEFT_SEPERATE_OFF,
            _11_SOL_INTRAY_LEFT_SEPERATE_ON,
            _11_SOL_INTRAY_LEFT_ELEVATOR_1_BW,
            _11_SOL_INTRAY_LEFT_ELEVATOR_1_FW,
            _11_SOL_INTRAY_LEFT_ELEVATOR_2_BW,
            _11_SOL_INTRAY_LEFT_ELEVATOR_2_FW,
            _11_SOL_INTRAY_LEFT_STOPPER_1_DOWN,
            _11_SOL_INTRAY_LEFT_STOPPER_2_DOWN,
            _11_SOL_INTRAY_LEFT_REMOVE_DOWN,
            _11_SOL_INTRAY_LEFT_REMOVE_UP,
            _11_SOL_INTRAY_LEFT_REMOVE_BW,
            _11_SOL_INTRAY_LEFT_REMOVE_FW,
            _11_SOL_INTRAY_LEFT_ALIGN_OFF,
            _11_SOL_INTRAY_LEFT_ALIGN_TOP_OFF,
​
​
            _11_SOL_INTRAY_RIGHT_HOLD_OFF,
            _11_SOL_INTRAY_RIGHT_HOLD_ON,
            _11_SOL_INTRAY_RIGHT_SEPERATE_OFF,
            _11_SOL_INTRAY_RIGHT_SEPERATE_ON,
            _11_SOL_INTRAY_RIGHT_ELEVATOR_1_BW,
            _11_SOL_INTRAY_RIGHT_ELEVATOR_1_FW,
            _11_SOL_INTRAY_RIGHT_ELEVATOR_2_BW,
            _11_SOL_INTRAY_RIGHT_ELEVATOR_2_FW,
            _11_SOL_INTRAY_RIGHT_STOPPER_1_DOWN,
            _11_SOL_INTRAY_RIGHT_STOPPER_2_DOWN,
            _11_SOL_INTRAY_RIGHT_REMOVE_DOWN,
            _11_SOL_INTRAY_RIGHT_REMOVE_UP,
            _11_SOL_INTRAY_RIGHT_REMOVE_BW,
            _11_SOL_INTRAY_RIGHT_REMOVE_FW,
            _11_SOL_INTRAY_RIGHT_ALIGN_OFF,
            _11_SOL_INTRAY_RIGHT_ALIGN_TOP_OFF,
​
​
            _12_SOL_TRAY_SIM_ROTATE_OFF,
            _12_SOL_TRAY_SIM_ROTATE_ON,
            _12_SOL_TRAY_SIM_TURN,
            _12_SOL_TRAY_SIM_GRIP,
            _12_SOL_TRAY_SIM_PUSH_FRONT,
            _12_SOL_TRAY_SIM_PUSH_REAR,
            _12_SPARE0,
            _12_SOL_OUTTRAY_TRANSFER_FRONT_BW,
            _12_SOL_OUTTRAY_TRANSFER_FRONT_FW,
            _12_SOL_OUTTRAY_TRANSFER_REAR_BW,
            _12_SOL_OUTTRAY_TRANSFER_REAR_FW,
            _12_SOL_OUTTRAY_REMOVE_BW,
            _12_SOL_OUTTRAY_REMOVE_FW,
            _12_SOL_OUTTRAY_PUSH_UP,
            _12_SOL_OUTTRAY_PUSH_DOWN,
            _12_SOL_OUTTRAY_STOPPER_TRANSFER_DOWN,
​
            _12_SOL_OUTTRAY_STOPPER_LEFT_DOWN_1,
            _12_SOL_OUTTRAY_STOPPER_LEFT_DOWN_2,
            _12_SOL_OUTTRAY_STOPPER_RIGHT_DOWN_1,
            _12_SOL_OUTTRAY_STOPPER_RIGHT_DOWN_2,
            _12_SOL_UNLOAD_TRAY_UP,
            _12_SOL_UNLOAD_TRAY_DOWN,
            _12_SOL_UNLOAD_TRAY_CLAMP_OFF,
            _12_SOL_UNLOAD_TRAY_CLAMP_ON,
            _12_SPARE1,
            _12_SOL_JIG_RIGHT_POS_OUT,
            _12_SOL_JIG_RIGHT_POS_IN,
            _12_SOL_JIG_RIGHT_BW,
            _12_SOL_JIG_RIGHT_FW,
            _12_SOL_JIG_RIGHT_ALIGN_HOR,
            _12_SOL_JIG_RIGHT_ALIGN_VER,
            _12_SOL_JIG_RIGHT_ALIGN_SIM,
​
​
            _13_SOL_NG_SHUTTER_FW,
            _13_SOL_NG_SHUTTER_BW,
            _13_SOL_NG_SHUTTER_DOWN_1,
            _13_SOL_NG_SHUTTER_DOWN_2,
            _13_SOL_NG_SHUTTER_DOWN_3,
            _13_OUT_AGV_1_6, // ON khi băng tải ngoài cùng tầng dưới có tray trống
            _13_OUT_AGV_1_7,
            _13_OUT_AGV_1_8,
            _13_OUT_AGV_2_1, // ON khi muốn AGV transfer hàng ở bên trái
            _13_OUT_AGV_2_2, // ON khi muốn AGV transfer hàng ở bên phải
            _13_OUT_AGV_2_3, 
            _13_OUT_AGV_2_4,  // ON khi hoàn thành transfer giữa Robot với AGV
            _13_OUT_AGV_2_5,  // ON khi băng tải ngoài cùng tầng trên trống
            _13_OUT_AGV_2_6,  // ON khi băng tải ngoài cùng tầng dưới có tray trống
            _13_OUT_AGV_2_7,
            _13_OUT_AGV_2_8,
​
            _13_CV_INPUT,
            _13_CV_OUTPUT,
            _13_CV_INTRAY_LEFT_WORK,
            _13_CV_INTRAY_LEFT_INPUT_1,
            _13_CV_INTRAY_LEFT_INPUT_2,
            _13_CV_INTRAY_RIGHT_WORK,
            _13_CV_INTRAY_RIGHT_INPUT_1,
            _13_CV_INTRAY_RIGHT_INPUT_2,
            _13_CV_OUTTRAY_TRANSFER,
            _13_CV_OUTTRAY_LEFT_OUTPUT_1,
            _13_CV_OUTTRAY_LEFT_OUTPUT_2,
            _13_CV_OUTTRAY_RIGHT_OUTPUT_1,
            _13_CV_OUTTRAY_RIGHT_OUTPUT_2,
            _13_SPARE0,
            _13_IF_FRONT_BUSY,
            _13_IF_BEHIND_READY,
            #endregion
​
            OUT_MAX
        };
    }
}
​
Define/SystemDefine.cs
using Auto_Insert_Sim_Tray.Configs;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
​
namespace Auto_Insert_Sim_Tray.Define
{
    /**
     * @brief 물류 프로그램에서 정의하고자 하는 상수를 정의하는 클래스
     */
    public static class SystemDefine
    {
        // System define
​
        // TODO : Machine 이름 포함 경로로 수정 필요
        public static string systemEquipmentName = "INSERT SIM TRAY"; //MES, GEIM 등에 보낼 설비 명
        public static string rootPath = @"C:\FA\" + systemEquipmentName + @"\";
        public static string modelTag = "Model : ";
        //public static string pgmVersion = $"V 1.0_B {System.Diagnostics.FileVersionInfo.GetVersionInfo(System.Reflection.Assembly.GetExecutingAssembly().Location).ProductVersion}";
        public static string pgmVersion = "20252301.03";
        //public static string pgmTittle = System.Reflection.Assembly.GetExecutingAssembly().FullName.Split(',')[0];
        public static string groupName = "Automation Group";
​
        public const bool TEST_NONE_HW = false;
        public const int UI_TIMER_INTERVAL = 1000; //ms
        public const int MAX_DISPLAY_LOGLINE = 20;
​
        public const int MAX_QUEUE_TO_CALCULATION_TACKTIME = 100;
​
        //Màn hình chuẩn khi thiết kế trên laptop
        public static System.Drawing.Size monitorDesign = new System.Drawing.Size(1280, 768);
​
        public const int DELAY_TIME_SYSTEM_HW_MANAGER_THREAD_RUN = 20; //ms
        public const int DELAY_TIME_DEFAULT_PROC_THREAD_RUN = 20; //ms
        public const int DELAY_TIME_FOR_DRYRUN_THREAD_RUN = 200; //ms
        public const bool IsRunWithMachine = true;
        public static bool IsLoadingFinish = false;
        public static bool IsRun_No_PC_Test = false;
​
        // System 에러코드 
        #region system error code
        /*
         * System define error code : 수정가능
         */
        public const int ERROR_NOT_ALLOCATE = 0;
        public const int ERRCODE_NO_ERROR = -1000;
        public const int ERRCODE_STOP_YELLOW = 39578;
​
        public const int ERRCODE_EMO_PRESS = ((int)SystemEnum.ECODE.EMERGENCY_STOP);
        public const int ERRCODE_LIGHT_CURTAIN_ABOVE = ((int)SystemEnum.ECODE.LIGHT_CURTAIN_ABOVE);
        public const int ERRCODE_LIGHT_CURTAIN_BELOW = ((int)SystemEnum.ECODE.LIGHT_CURTAIN_BELOW);
        public const int ERRCODE_DOOR_OPEN = ((int)SystemEnum.ECODE.DOOR_OPEN);
        //public const int ERRCODE_DOOR_MC1_OPEN = ((int)SystemEnum.ECODE.DOOR_MC1_OPEN);
        //public const int ERRCODE_DOOR_MC2_OPEN = ((int)SystemEnum.ECODE.DOOR_MC2_OPEN);
​
        /*
         * System define error code : 삭제하지 말 것 
         * Json의 error code와 code 중복 사용하지 말 것
         */
        #endregion
        public const int ERRCODE_ETHERCAT_MASTER_NOT_FOUND = 30000;
        public const int ERRCODE_ETHERCAT_INIT_FAIL = 30001;
        public static int BUZZER_TIMEOUT = (int)(JsonHelper.Instance.delayTime.OnBuzzerTime * 1000); //ms - default 3sec
        public const int CHECK_IDLE_TIME = 60000; //ms - default 60sec
        public const int CHECK_OOS_TIME = 15000; //ms - default 15sec
​
        public enum MACHINE_TYPE
        {
            B,
            AC2,
            AC1
        }
​
        public enum HAND_NUM
        {
            NONE = -1,
            HAND1,
            HAND2,
            MAX,
        }
    }
}
​
Define/SystemEnum.cs
/* 
 * Copyright (C) Samsung Electronics Co., Ltd., Inc - All Rights Reserved
 * Unauthorized copying of this file, via any medium is strictly prohibited
 * Proprietary and confidential
 * 
 * Written by Donghyun Ko <dh79.ko@samsung.com>, June 2022
 * Written by Sanghyeon Lee <sirano06.lee@samsung.com>, June 2022
 * 
 */
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
​
namespace Auto_Insert_Sim_Tray.Define
{
    /**
     * @brief 물류 프로그램에서 정의하고자 하는 enum 들의 정의 클래스
     */
    public static class SystemEnum
    {
        /* 
         * @brief Operation의 mode
         * @todo 제어상의 mode는 설비의 컨셉과 동작에 맞게 수정하여 진행한다
         */
        public enum OP_MODE
        {
            NONE = -1,
            READY,
            INIT,
            RUN,
            RESET,
            STOP,
            E_STOP,
            SEMI_RUN,
            ORG_RUN,
            OPP,
        }
​
        /* 
         * @brief 설비 구동 mode
         */
        public enum RUN_MODE
        {
            NONE = -1,
            AUTO_RUN,
            DRY_RUN, //SET 없이 
            BY_PASS,
            MAX
        };
​
        public enum UNIT_TYPE
        {
            NONE = -1,
            TF_LD_SET,
            TF_ULD_SET,
            JIG_LEFT,
            JIG_RIGHT,
            INTRAY_LEFT,
            INTRAY_RIGHT,
            OUTTRAY_LEFT,
            OUTTRAY_RIGHT,
            ULD_TRAY_SIM,
            TF_OUTTRAY,
            ROBOT_XYZ,
            IN_CV,
            OUT_CV,
            NG_BUFFER,
            LEFT_INTRAY_CV,
            RIGHT_INTRAY_CV,
            LEFT_OUTTRAY_CV,
            RIGHT_OUTTRAY_CV,
            RELOAD_SIMTRAY
​
        }
        public enum SET_STATUS
        {
            None,
            OK,
            NG,
            Wait,
            NoBarCode,
            DifferinModel,
            Max
        }
        public enum SEMI_OPTION
        {
            NONE = -1,
            MOVE_TOP,
            MOVE_ON_JIG
        }
        public enum MAINFORM_EVENT
        {
            NONE = -1,
            EXIT_EVENT,
            HIDE_EVENT,
            RESIZE_EVENT,
        }
​
        public enum COM_LIST
        {
            NONE = 0,
            PC1,
            PC2,
            PC3,
            PC4,
            PC5,
            PC6,
        }
        public enum LIST_ETHERNET
        {
            NONE = -1,
            VISION_1,
            VISION_2,
        }
        //public enum BUFF_STATE
        //{
        //    NONE = -1,
​
        //    ATTACH_NG,
        //    ATTACH_OK,
        //    WAIT_PLACE,
        //    WAIT_ATTACH,
        //    DONE_ATTACH,
        //}
​
        public enum REQUEST_ACTION
        {
            NONE = -1,
​
            PICK,
            PLACE,
        }
        public enum TEST_RESULT
        {
            NONE = -1,
            TESTING,
            TEST_OK,
            TEST_NG,
            RF_INSERT_FAIL,
            RETEST,
        }
​
        /* 
        * Khai báo slot các Jig có trong máy
        */
       public enum Jig_Index
        {
            NONE = 0,
            JIG_LEFT,
            JIG_RIGHT,
        }
        /* 
         * @brief TactTime 계산용 enum
         */
        public enum TT_TYPE
        {
            NONE = -1,
            IN,
            OUT
        }
​
        /* 
         * @brief 검사 결과 enum
         */
​
        public enum COMPARE_RESULT
        {
            None,
            Khác,
            Nhỏ_Hơn,
            Bằng,
            Lớn_Hơn,
        }
        public enum ECODE
        {
            NONE = -1,
            WORK_SUCCESS,
            WORK_FAIL,
​
            RUN_WITHOUT_MACHINE,
            ACTION_DENIED,
​
            SERVO_NOT_CONNECTED,
            SERVO_OFF,
            SERVO_CHECK_ERROR_ALARM,
            SERVO_ORIGIN_NOT_DONE,
            SERVO_MOVING_NOW,
            COMPARE_POSITION_FAIL,
            SERVO_MOVING_INTERPOLATION_ERROR,
            Kiểm_Tra_Tín_Hiệu_Limit,
​
​
            #region System Part
            EMERGENCY_STOP = 1000,
            DOOR_OPEN,
            ORG_MODE_RUN_TIMEOUT,
            INITIALIZE_MODE_RUN_TIMEOUT,
            SEMI_MODE_RUN_TIMEOUT,
            LIGHT_CURTAIN_ABOVE,
            LIGHT_CURTAIN_BELOW,
            SENSOR_SAFETY_RELOAD_SIM_TRAY,
            TRAY_SIM_LEFT_REVERSE,
            TRAY_SIM_RIGHT_REVERSE,
            LD_SET_DROP_SET,
            ULD_SET_DROP_SET,
            LD_SET_AXIS_X_OFF,
            LD_SET_AXIS_X_ERRROR,
            ULD_SET_AXIS_X_OFF,
            ULD_SET_AXIS_X_ERRROR,
            ULD_TRAY_AXIS_X_OFF,
            ULD_TRAY_AXIS_X_ERRROR,
            ROBOT_XYZ_AXIS_X_OFF,
            ROBOT_XYZ_AXIS_X_ERRROR,
            ROBOT_XYZ_AXIS_Y_OFF,
            ROBOT_XYZ_AXIS_Y_ERRROR,
            ROBOT_XYZ_AXIS_Z_OFF,
            ROBOT_XYZ_AXIS_Z_ERRROR,
            TF_TRAYOUT_AXIS_Z_OFF,
            TF_TRAYOUT_AXIS_Z_ERRROR,
​
            #endregion
​
            #region LD SET
            LD_SET_SOL_UP_DOWN_ERROR = 2000,
            LD_SET_SOL_ROTATE_ERROR,
            LD_SET_SOL_GRIP_ERROR,
            LD_SET_X_AXIS_MOVE_TIMEOUT,
            LD_SET_X_AXIS_DANGEROUS,
            LD_SET_SOL_GRIP_UP_DOWN_ERROR,
​
            #endregion
​
            #region ULD SET
            ULD_SET_SOL_UP_DOWN_ERROR = 3000,
            ULD_SET_SOL_ROTATE_ERROR,
            ULD_SET_SOL_GRIP_ERROR,
            ULD_SET_SOL_NG_ERROR,
            ULD_SET_X_AXIS_MOVE_TIMEOUT,
            ULD_SET_X_AXIS_DANGEROUS,
            ULD_SET_SOL_GRIP_UP_DOWN_ERROR,
            #endregion
​
            #region JIG LEFT
            JIG_LEFT_SOL_IN_OUT_ERROR = 4000,
            JIG_LEFT_SOL_FLIP_ERROR,
            JIG_LEFT_SOL_ALIGN_HORIZONTAL_ERROR,
            JIG_LEFT_SOL_ALIGN_VERTICAL_ERROR,
            JIG_LEFT_SOL_ALIGN_SIM_ERROR,
            JIG_LEFT_DANGEROUS_TO_MOVE,
            #endregion
​
            #region JIG RIGHT
            JIG_RIGHT_SOL_IN_OUT_ERROR = 5000,
            JIG_RIGHT_SOL_FLIP_ERROR,
            JIG_RIGHT_SOL_ALIGN_HORIZONTAL_ERROR,
            JIG_RIGHT_SOL_ALIGN_VERTICAL_ERROR,
            JIG_RIGHT_SOL_ALIGN_SIM_ERROR,
            JIG_RIGHT_DANGEROUS_TO_MOVE,
            #endregion
​
            #region INTRAY LEFT
            INTRAY_LEFT_SOL_HOLD_ERROR = 6000,
            INTRAY_LEFT_SOL_SEPERATE_ERROR,
            INTRAY_LEFT_SOL_ELEVATOR_1_ERROR,
            INTRAY_LEFT_SOL_ELEVATOR_2_ERROR,
            INTRAY_LEFT_SOL_STOPPER_1_ERROR,
            INTRAY_LEFT_SOL_STOPPER_2_ERROR,
            INTRAY_LEFT_SOL_REMOVE_UP_DOWN_ERROR,
            INTRAY_LEFT_SOL_REMOVE_BW_FW_ERROR,
            INTRAY_LEFT_SOL_ALIGN_ERROR,
            INTRAY_LEFT_SOL_ALIGN_TOP_ERROR,
            #endregion
​
            #region INTRAY RIGHT
            INTRAY_RIGHT_SOL_HOLD_ERROR = 7000,
            INTRAY_RIGHT_SOL_SEPERATE_ERROR,
            INTRAY_RIGHT_SOL_ELEVATOR_1_ERROR,
            INTRAY_RIGHT_SOL_ELEVATOR_2_ERROR,
            INTRAY_RIGHT_SOL_STOPPER_1_ERROR,
            INTRAY_RIGHT_SOL_STOPPER_2_ERROR,
            INTRAY_RIGHT_SOL_REMOVE_UP_DOWN_ERROR,
            INTRAY_RIGHT_SOL_REMOVE_BW_FW_ERROR,
            INTRAY_RIGHT_SOL_ALIGN_ERROR,
            INTRAY_RIGHT_SOL_ALIGN_TOP_ERROR,
            #endregion
​
            #region ROBOT XYZ
            ROBOTXYZ_SOL_ROTATE_ERROR = 8000,
            ROBOTXYZ_SOL_TURN_ERROR,
            ROBOTXYZ_SOL_GRIP_ERROR,
            ROBOTXYZ_SOL_PUSH_FRONT_ERROR,
            ROBOTXYZ_SOL_PUSH_REAR_ERROR,
            ROBOTXYZ_SOL_CHECK_NG_ERROR,
            ROBOTXYZ_SOL_CHECK_GRIP_ERROR,
            ROBOTXYZ_X_AXIS_MOVE_TIMEOUT,
            ROBOTXYZ_Y_AXIS_MOVE_TIMEOUT,
            ROBOTXYZ_Z_AXIS_MOVE_TIMEOUT,
            INSERT_TRAY_SIM_FAIL_JIG_LEFT,
            INSERT_TRAY_SIM_FAIL_JIG_RIGHT,
            ROBOTXYZ_GRIP_TRAY_SIM_FAIL,
            #endregion
​
            #region OUT TRAY
            OUT_TRAY_SOL_TRANSFER_FRONT_ERROR = 9000,
            OUT_TRAY_SOL_TRANSFER_REAR_ERROR,
            OUT_TRAY_SOL_REMOVE_ERROR,
            OUT_TRAY_SOL_PUSH_ERROR,
            OUT_TRAY_SOL_TRANSFER_STOPPER_ERROR,
            OUT_TRAY_SOL_LEFT_STOPPER_1_ERROR,
            OUT_TRAY_SOL_LEFT_STOPPER_2_ERROR,
            OUT_TRAY_SOL_RIGHT_STOPPER_1_ERROR,
            OUT_TRAY_SOL_RIGHT_STOPPER_2_ERROR,
            OUT_TRAY_Z_AXIS_MOVE_TIMEOUT,
            #endregion
​
            #region ULD TRAY + NG SHUTTLE + RELOAD
            NG_SHUTTLE_SOL_FW_BW_ERROR = 10000,
            RELOAD_SIM_R_AXIS_ERROR,
            UNLOAD_TRAY_SOL_UP_DOWN_ERROR,
            UNLOAD_TRAY_SOL_GRIP_ERROR,
            UNLOAD_TRAY_X_AXIS_MOVE_TIMEOUT,
            #endregion
        }
​
        //public enum NOTICECODE
        //{
        //    NONE,
​
        //    #region Transfer
        //    Servo_X_TRANSFER_Chưa_On,
        //    Servo_X_TRANSFER_Bị_Lỗi,
        //    Kiểm_Tra_Xy_Lanh_LD_Cylinder_Down,
        //    Kiểm_Tra_Xy_Lanh_ULD_Cylinder_Down,
        //    #endregion
​
        //    #region MC1
        //    Servo_Y_MC1_JIG1_Chưa_On,
        //    Servo_Y_MC1_JIG1_Bị_Lỗi,
        //    Servo_Y_MC1_JIG2_Chưa_On,
        //    Servo_Y_MC1_JIG2_Bị_Lỗi,
        //    Servo_R_MC1_Chưa_On,
        //    Servo_R_MC1_Bị_Lỗi,
        //    Kiểm_Tra_Xy_Lanh_JIG1,
        //    Kiểm_Tra_Xy_Lanh_JIG2,
        //    #endregion
​
        //    #region MC2
        //    Servo_Y_MC2_JIG1_Chưa_On,
        //    Servo_Y_MC2_JIG1_Bị_Lỗi,
        //    Servo_Y_MC2_JIG2_Chưa_On,
        //    Servo_Y_MC2_JIG2_Bị_Lỗi,
        //    Servo_R_MC2_Chưa_On,
        //    Servo_R_MC2_Bị_Lỗi,
        //    #endregion
        //}
​
        //public enum ORG_X_Step
        //{
        //    _1_Check,
        //    _2_SOL_Up,
        //    _3_Org_X_SOL_return,
        //    _4_Finish,
        //}
        //public enum ORG_Y_Step
        //{
        //    _1_Check,
        //    _2_J1_Up_J2_Down,
        //    _3_Up_Vinyl,
        //    _4_Org_Y_Unalign,
        //    _5_Finish,
        //}
        //public enum ORG_NG_Step
        //{
        //    _1_Check,
        //    _2_SOL_Down,
        //    _3_SOL_FW,
        //    _4_Finish,
        //}
​
        //public enum Initial_X_Step
        //{
        //    _1_Check,
        //    _2_SOL_Up,
        //    _3_Org_X_SOL_return,
        //    _4_Finish,
        //}
        //public enum Initial_Y_Step
        //{
        //    _1_Check,
        //    _2_J1_Up_J2_Down,
        //    _3_Up_Vinyl,
        //    _4_Move_Y,
        //    _5_J1_Up_J2_Down,
        //    _6_Finish
        //}
        //public enum Initial_NG_Step
        //{
        //    _1_Check,
        //    _2_SOL_Down,
        //    _3_SOL_FW,
        //    _4_Finish,
        //}
​
        //public enum Semi_X_Step
        //{
        //    _1_Check,
        //    _2_SOL_Up,
        //    _3_Move_X_SOL,
        //    _4_SOL_turn_return,
        //    _5_SOL_Down,
        //    _6_Finish,
        //}
        //public enum Semi_Lifter_Step
        //{
        //    _1_Check,
        //    _2_Move_Z,
        //    _3_Finish,
        //}
        //public enum Semi_Z_NG_Step
        //{
        //    _1_Check,
        //    _2_Move_Z,
        //    _3_Finish,
        //}
​
        //public enum Auto_Transfer_X
        //{
        //    _1_Check,
​
        //    _2_MoveX_SOL_Turn_Return_Ungrip,
        //    _3_Wait_Done_Handle,
        //    _4_Reset,
​
        //}
        //public enum Auto_Handle
        //{
        //    _1_Check,
​
        //    _2_Pick,
        //    _2_1_SOL_Down,
        //    _2_2_SOL_Grip,
        //    _2_3_SOL_Up,
        //    _2_4_Done_Pick,
​
        //    _3_Place,
        //    _3_1_SOL_Down,
        //    _3_2_SOL_Ungrip,
        //    _3_3_SOL_Up,
        //    _3_4_Done_Place,
        //}
        //public enum Auto_Jig_Attach
        //{
        //    _1_Check,
​
        //    _2_Swap_Jig,
        //    _2_1_Move_Y_Clean_End,
        //    _2_2_Jig_Down,
        //    _2_3_Move_Y_Ld_Uld,
        //    _2_4_Done_Swap_Jig,
​
        //    _3_Attach,
        //    _3_1_Align,
        //    _3_2_Move_Y_Clean_Start,
        //    _3_3_Clean_Down,
        //    _3_4_Move_Y_Clean_End,
        //    _3_5_Move_Y_Attach_Start,
        //    _3_6_Attach_Down,
        //    _3_7_Move_Y_R_Attach_End,
        //    _3_8_Jig_Down_All_SOL_Up,
        //    _3_9_Move_Y_Ld_Uld,
        //    _3_10_Done_Attach,
​
        //    _4_Unload,
        //    _4_1_Jig_Up_Unalign,
        //    _4_2_Done_Unload,
        //}
        //public enum Auto_R_Attach
        //{
        //    _1_Check,
        //    _2_Detect_Hole,
        //    _3_Detect_Vinyl,
        //    _4_Move_R_Attach_Start,
        //    _5_Wait_R_Attach_End,
        //    _6_Reset,
        //}
        //public enum Auto_Z_NG_Step
        //{
        //    _1_Check,
​
        //    _2_MoveZ_To_CV_Offset,
        //    _3_MoveZ_To_CV_OnVC,
        //    _4_MoveZ_To_Buff_NG_Offset,
        //    _5_SOL_FW,
        //    _6_MoveZ_To_Buff_NG_OffVC,
        //    _7_MoveZ_To_Wait_SOL_BW,
​
        //    _8_Reset,
​
        //}
        public enum Auto_In_CV_Step
        {
            Check,
​
            CV_Run_To_SS_Mid,
            CV_Run_To_SS_Out,
            CV_Stop_Take_Barcode,
​
            CV_Stop,
        }
        public enum Auto_Out_CV_Step
        {
            Check,
            Check_MC_Behind,
            CV_Run_To_SS_Out,
            CV_Run_To_MC_Behind,
            CV_Stop,
        }
        public enum ORG_Input_CV_Left
        {
            _1_Check,
            _2_Sol_Down,
            _3_Finish,
        }
        public enum Initial_Input_CV_Left
        {
            _1_Check,
            _2_Sol_Down,
            _3_Finish,
        }
        public enum Auto_Input_CV_Left
        {
            _1_1_Check_CV_1,
            _1_2_Sol_Stopper_1_Up,
            _1_3_Sol_Stopper_1_Down,
            _1_4_Run_Input_CV_1,
            _1_5_Stop_Input_CV_1,
​
            _2_1_Check_CV_2,
            _2_2_Sol_Stopper_2_Up,
            _2_3_Sol_Stopper_2_Down,
            _2_4_Run_Input_CV_2,
            _2_5_Stop_Input_CV_2,
        }
        public enum ORG_Input_CV_Right
        {
            _1_Check,
            _2_Sol_Down,
            _3_Finish,
        }
        public enum Initial_Input_CV_Right
        {
            _1_Check,
            _2_Sol_Down,
            _3_Finish,
        }
        public enum Auto_Input_CV_Right
        {
            _1_1_Check_CV_1,
            _1_2_Sol_Stopper_1_Up,
            _1_3_Sol_Stopper_1_Down,
            _1_4_Run_Input_CV_1,
            _1_5_Stop_Input_CV_1,
​
            _2_1_Check_CV_2,
            _2_2_Sol_Stopper_2_Up,
            _2_3_Sol_Stopper_2_Down,
            _2_4_Run_Input_CV_2,
            _2_5_Stop_Input_CV_2,
        }
        public enum ORG_Outtray_CV_Left
        {
            _1_Check,
            _2_Sol_Down,
            _3_Finish,
        }
        public enum Initial_Outtray_CV_Left
        {
            _1_Check,
            _2_Sol_Down,
            _3_Finish,
        }
        public enum Auto_Outtray_CV_Left
        {
            _1_1_Check_CV_1,
            _1_2_Sol_Stopper_1_Up,
            _1_3_Sol_Stopper_1_Down,
            _1_4_Run_Outtray_CV_1,
            _1_5_Stop_Outtray_CV_1,
​
            _2_1_Check_CV_2,
            _2_2_Sol_Stopper_2_Up,
            _2_3_Sol_Stopper_2_Down,
            _2_4_Run_Outtray_CV_2,
            _2_5_Stop_Outtray_CV_2,
        }
        public enum ORG_Outtray_CV_Right
        {
            _1_Check,
            _2_Sol_Down,
            _3_Finish,
        }
        public enum Initial_Outtray_CV_Right
        {
            _1_Check,
            _2_Sol_Down,
            _3_Finish,
        }
        public enum Auto_Outtray_CV_Right
        {
            _1_1_Check_CV_1,
            _1_2_Sol_Stopper_1_Up,
            _1_3_Sol_Stopper_1_Down,
            _1_4_Run_Outtray_CV_1,
            _1_5_Stop_Outtray_CV_1,
​
            _2_1_Check_CV_2,
            _2_2_Sol_Stopper_2_Up,
            _2_3_Sol_Stopper_2_Down,
            _2_4_Run_Outtray_CV_2,
            _2_5_Stop_Outtray_CV_2,
        }
​
        public enum ORG_TF_LD_SET
        {
            _1_Check,
            _2_Sol_Up,
            _3_Move_X,
            _4_Rotate_Middle,
            _5_Finish,
        }
        public enum Initial_TF_LD_SET
        {
            _1_Check,
            _2_Sol_Up,
            _3_Move_X,
            _4_Rotate_Middle,
            _5_Finish,
        }
        public enum Auto_TF_LD_SET
        {
            _1_Check,
            _1_2_Check_Pos_Pick,
            _1_3_Pick,
            _1_4_Check_Pos_Place,
            _1_5_Place,
            _1_6_Reset,
​
            _2_Pick_In_CV,
            _2_1_MoveX_Input,
            _2_2_Rotate_Middle,
            _2_3_Sol_Down,
            _2_4_Sol_Down_Clamp,
            _2_5_Sol_Clamp_On,
            _2_6_Sol_Up_Clamp,
            _2_7_Sol_Up,
            _2_8_Sol_Rotate_Auto,
            _2_9_MoveX_Wait,
            _2_10_Return,
​
            _3_Place_In_Jig,
            _3_2_MoveX_Jig_Left_And_Rotate,
            _3_3_MoveX_Jig_Right_And_Rotate,
            _3_4_Sol_Down_Clamp,
            _3_5_Sol_Clamp_Off,
            _3_6_Sol_Up_Clamp,
            _3_7_MoveX_Wait_And_Rotate,
            _3_8_Return,
        }
        public enum Semi_TF_LD_SET
        {
            _1_Check,
            _2_Sol_Clamp_On,
            _3_Sol_Up,
            _4_Move_X,
            _5_Finish,
​
        }
​
        public enum ORG_TF_ULD_SET
        {
            _1_Check,
            _2_Sol_Up,
            _3_Sol_NG_Pos_OK,
            _4_Move_X,
            _5_Rotate_Middle,
            _6_Finish,
        }
        public enum Initial_TF_ULD_SET
        {
            _1_Check,
            _2_Sol_Up,
            _3_Sol_NG_Pos_OK,
            _4_Move_X,
            _5_Rotate_Middle,
            _6_Finish,
        }
        public enum Auto_TF_ULD_SET
        {
            _1_Check,
            _1_2_Check_Pos_Pick,
            _1_3_Pick,
            _1_4_Check_Pos_Place,
            _1_5_Place,
            _1_6_Reset,
​
            _2_Pick_In_Jig,
            _2_2_MoveX_Jig_Left_And_Rotate,
            _2_3_MoveX_Jig_Right_And_Rotate,
            _2_4_Sol_Down_Clamp,
            _2_5_Sol_Clamp_On,
            _2_6_Sol_Up_Clamp,
            _2_7_MoveX_Wait_And_Rotate,
            _2_8_Return,
​
            _3_Place,
            _3_2_MoveX_CV_Out,
            _3_3_MoveX_NG,
            _3_4_Sol_NG_Pos_NG,
            _3_5_Sol_Down,
            _3_6_Sol_Down_Clamp,
            _3_7_Sol_Clamp_Off,
            _3_8_Sol_Up_Clamp,
            _3_9_Sol_Up,
            _3_10_Sol_NG_Pos_OK,
            _3_11_MoveX_Wait,
            _3_12_Return,
​
        }
        public enum Semi_TF_ULD_SET
        {
            _1_Check,
            _2_Sol_Clamp_On,
            _3_Sol_Up,
            _4_Sol_NG_Pos_OK,
            _5_Move_X,
            _6_Finish,
​
        }
​
        public enum ORG_Jig_Left
        {
            _1_Check,
            _2_Sol_Flip_Up,
            _3_Sol_Pos_Out,
            _4_Finish,
        }
        public enum Initial_Jig_Left
        {
            _1_Check,
            _2_Sol_Flip_Up,
            _3_Sol_Pos_Out,
            _4_UnAlign,
            _5_Finish,
        }
        public enum Auto_Jig_Left
        {
            _1_Check,
            _1_2_SET_OK,
            _1_3_SET_NG,
​
            _2_Insert_Sim_Tray,
            _2_2_Sol_Align_Hor_1,
            _2_3_Sol_Align_Ver,
            _2_4_Sol_Align_Hor_Sim,
            _2_5_Sol_Move_In,
            _2_6_Sol_Unalign_Sim,
            _2_7_Sol_Move_Out,
            _2_8_Sol_Unalign_Hor_Ver,
            _2_9_Finish,
​
            _3_SET_NG_Or_By_Pass,
            _3_2_Sol_Align_Hor_1,
            _3_3_Sol_Align_Ver,
            _3_4_Sol_Align_Hor,
            _3_5_Sol_Unalign_Hor_Ver,
            _3_6_Finish,
​
        }
​
        public enum ORG_Jig_Right
        {
            _1_Check,
            _2_Sol_Flip_Up,
            _3_Sol_Pos_Out,
            _4_Finish,
        }
        public enum Initial_Jig_Right
        {
            _1_Check,
            _2_Sol_Flip_Up,
            _3_Sol_Pos_Out,
            _4_UnAlign,
            _5_Finish,
        }
        public enum Auto_Jig_Right
        {
            _1_Check,
            _1_2_SET_OK,
            _1_3_SET_NG,
​
            _2_Insert_Sim_Tray,
            _2_2_Sol_Align_Hor_1,
            _2_3_Sol_Align_Ver,
            _2_4_Sol_Align_Hor_Sim,
            _2_5_Sol_Move_In,
            _2_6_Sol_Unalign_Sim,
            _2_7_Sol_Move_Out,
            _2_8_Sol_Unalign_Hor_Ver,
            _2_9_Finish,
​
            _3_SET_NG_Or_By_Pass,
            _3_2_Sol_Align_Hor_1,
            _3_3_Sol_Align_Ver,
            _3_4_Sol_Align_Hor,
            _3_5_Sol_Unalign_Hor_Ver,
            _3_6_Finish,
​
        }
​
        public enum Initial_Intray_Left
        {
            _1_Check,
            _2_Sol_Unalign_Tray,
            _3_Sol_Remove_Down,
            _4_Sol_Remove_BW,
            _5_Sol_Elevator_2_FW,
            _6_Sol_Separate_Off,
            _7_Sol_Hold_Off,
            _8_Sol_Elevator_1_FW,
            _9_Sol_Separate_Off_2,
            _10_Finish,
        }
        public enum Auto_Intray_Left
        {
            _1_Check_Intray,
            _1_2_Split_Tray,
            _1_3_Transfer_Tray_To_Work,
            _1_4_Transfer_Tray_To_Align,
​
            _2_Transfer_Tray_To_Work,
            _2_2_Check_Tray,
            _2_3_Run_CV_Work,
            _2_4_Stop_CV_Work,
            _2_5_Finish,
​
            _3_Transfer_Tray_To_Align,
            _3_2_Sol_Hold_On,
            _3_3_Sol_Elevator_2_BW,
            _3_4_Sol_Separate_On,
            _3_5_Sol_Elevator_1_BW,
            _3_6_Sol_Hold_Off,
            _3_7_Sol_Remove_Up,
            _3_8_Sol_Remove_FW,
            _3_9_Sol_Elevator_1_FW,
            _3_10_Sol_Elevator_2_FW,
            _3_11_Sol_Separate_Off,
            _3_12_Finish,
​
            _4_Check_Align,
            _4_2_Sol_Align,
            _4_2_1_Sol_Unalign,
            _4_2_2_Sol_Align,
            _4_3_Sol_Unalign,
            _4_4_Sol_Remove_Down,
            _4_5_Sol_Remove_BW,
            _4_6_Finish,
​
        }
​
        public enum Initial_Intray_Right
        {
            _1_Check,
            _2_Sol_Unalign_Tray,
            _3_Sol_Remove_Down,
            _4_Sol_Remove_BW,
            _5_Sol_Elevator_2_FW,
            _6_Sol_Separate_Off,
            _7_Sol_Hold_Off,
            _8_Sol_Elevator_1_FW,
            _9_Sol_Separate_Off_2,
            _10_Finish,
        }
        public enum Auto_Intray_Right
        {
            _1_Check_Intray,
            _1_2_Split_Tray,
            _1_3_Transfer_Tray_To_Work,
            _1_4_Transfer_Tray_To_Align,
​
            _2_Transfer_Tray_To_Work,
            _2_2_Check_Tray,
            _2_3_Run_CV_Work,
            _2_4_Stop_CV_Work,
            _2_5_Finish,
​
            _3_Transfer_Tray_To_Align,
            _3_2_Sol_Hold_On,
            _3_3_Sol_Elevator_2_BW,
            _3_4_Sol_Separate_On,
            _3_5_Sol_Elevator_1_BW,
            _3_6_Sol_Hold_Off,
            _3_7_Sol_Remove_Up,
            _3_8_Sol_Remove_FW,
            _3_9_Sol_Elevator_1_FW,
            _3_10_Sol_Elevator_2_FW,
            _3_11_Sol_Separate_Off,
            _3_12_Finish,
​
            _4_Check_Align,
            _4_2_Sol_Align,
            _4_2_1_Sol_Unalign,
            _4_2_2_Sol_Align,
            _4_3_Sol_Unalign,
            _4_4_Sol_Remove_Down,
            _4_5_Sol_Remove_BW,
            _4_6_Finish,
​
        }
​
        public enum ORG_ULD_Tray
        {
            _1_Check,
            _2_Sol_Up,
            _3_Move_X,
            _4_Finish,
        }
        public enum Initial_ULD_Tray
        {
            _1_Check,
            _2_Sol_Up,
            _3_MoveX_Wait,
            _4_Finish,
        }
        public enum Auto_ULD_Tray
        {
            _1_Check,
            _1_2_Check_Pos_Pick,
            _1_3_Pick,
            _1_4_Check_Pos_Place,
            _1_5_Place,
​
            _2_Pick_Tray,
            _2_2_Pick_Tray_Left,
            _2_3_Pick_Tray_Right,
            _2_4_Sol_Down,
            _2_5_Sol_Clamp_On,
            _2_6_Sol_Up,
            _2_7_Finish,
​
            _3_MoveX_Place_Tray,
            _3_2_Sol_Down,
            _3_3_Sol_Clamp_Off,
            _3_4_Sol_Up,
            _3_5_MoveX_Wait,
            _3_6_Finish,
​
        }
        public enum Semi_ULD_Tray
        {
            _1_Check,
            _2_Sol_Up,
            _3_Move_X,
            _4_Finish,
        }
        public enum ORG_TF_OutTray
        {
            _1_Check,
            _2_Move_Z,
            _3_Finish,
        }
        public enum Initial_TF_OutTray
        {
            _1_Check,
            _2_Sol_Remove_BW,
            _3_Sol_Push_Down,
            _4_MoveZ_Input_Tray,
            _5_Sol_Transfer_FW,
            _6_Finish,
        }
        public enum Auto_TF_OutTray
        {
            #region Lifter
            _1_Check_Axix_Z,
            _1_2_Off_Set_Input,
            _1_3_MoveZ_Input,
            _1_4_MoveZ_Output,
            _1_5_MoveZ_Wait,
            #endregion
​
            #region Transfer
            _2_Check_Transfer,
            _2_2_Sol_Transfer_Fornt_BW,
            _2_3_Sol_Push_Up,
            _2_4_Sol_Remove_FW,
            _2_5_Sol_Remove_BW,
            _2_6_Sol_Push_Down,
            _2_7_Sol_Transfer_Front_FW,
            _2_8_Finish,
            #endregion
​
            #region CV
            _3_Check_CV,
            _3_2_Sol_Transfer_Rear_FW,
            _3_3_Sol_Transfer_Rear_BW,
            _3_4_Sol_Stopper_Up,
            _3_5_Sol_Stopper_Down,
            _3_6_CV_Run,
            _3_7_CV_Stop,
            #endregion
​
        }
        public enum Semi_TF_OutTray
        {
            _1_Check,
            _2_Move_Z,
            _3_Finish,
        }
​
        public enum Initial_NG_Shuttle
        {
            _1_Check,
            _2_Sol_Down,
            _3_Sol_FW,
            _4_Finish,
        }
        public enum Auto_NG_Shuttle
        {
            _1_Check,
            _1_2_Run_NG_Shuttle,
            _1_3_Sol_Up,
            _1_4_Sol_BW,
            _1_5_Sol_Down,
            _1_6_Sol_FW,
            _1_7_Fisnish,
        }
​
        public enum ORG_RobotXYZ
        {
            _1_Check,
            _2_Sol_Push_Up,
            _3_MoveZ,
            _4_MoveY,
            _5_MoveX,
            _6_Finish,
        }
        public enum Initial_RobotXYZ
        {
            _1_Check,
            _2_Sol_Push_Up,
            _3_MoveZ_Wait,
            _4_MoveY_MoveX_Wait ,
            _5_MoveX_Wait,
            _6_Finish,
        }
        public enum Auto_RobotXYZ
        {
            _1_Check,
            _1_2_Check_Pick_Sim_Tray,
            _1_3_Pick_Sim_Tray,
            _1_4_Check_Insert_Sim_Tray,
            _1_5_Insert_Sim_Tray,
            _1_6_Check_Vision,
            _1_7_Vision,
​
            _2_Pick,
            _2_2_Move_Pick_Up,
            _2_3_Sol_Rotate_Off_and_Turn_On, // khong dung
            _2_4_Move_Pick_Down,
            _2_5_Sol_Grip_On,
            _2_6_MoveZ_Pick_Up,
            _2_7_Sol_Turn_Off,
            _2_8_Move_Wait,
            _2_9_Finish,
​
            _3_Place,
            _3_2_Move_Place_Up,
            _3_3_Sol_Rotate_Off,
            _3_4_Move_Place_Down_1,
            _3_5_Sol_Push_Down_Rear,
            _3_6_Sol_Push_Up_Rear_and_Grip_Off,
            _3_6_1_Sol_Push_Up_Rear_NG,
            _3_7_Move_Place_Down_2,
            _3_8_Sol_Push_Down_Front,
            _3_9_Sol_Push_Up_Front,
            _3_10_MoveZ_Jig_Insert_Up,
            _3_11_Move_Wait,
            _3_12_Finish,
​
            _4_Vision,
            _4_2_Move_Wait_Check_Vision_Left,
            _4_3_Grab_Vision_Left,
            _4_4_Move_Wait_Check_Vision_Right,
            _4_5_Grab_Vision_Right,
            _4_6_Move_Wait,
            _4_7_Finish,
​
            _5_NG,
            _5_1_Move_NG_Up,
            _5_2_Move_NG_Down,
            _5_3_Move_NG_Up,
            _5_4_Move_Wait,
            _5_5_Finish,
​
        }
        public enum Semi_RobotXYZ
        {
            _1_Check,
            _2_Sol_Push_Up,
            _3_MoveZ_Wait,
            _4_MoveY_MoveX,
            _4_1_MoveZ,
            _5_Finish,
        }
    }
}
​
HW/BarcodeReader/BarcodeReader.cs
using Auto_Insert_Sim_Tray.Communication;
using Auto_Insert_Sim_Tray.Configs;
using Auto_Insert_Sim_Tray.Configs.Model;
using Auto_Insert_Sim_Tray.Utils;
using HControlCSharp.Utils;
using System;
using System.Diagnostics;
using System.Text;
using System.Threading;
using System.Windows.Forms;
​
namespace Auto_Insert_Sim_Tray.HW.BarcodeReader
{
    public class BarcodeReader : Serial
    {
        private uint _dataLength = 10;
        private bool _isScanning = false;
        private string _strReceive = String.Empty;
        private bool _isReadFail = false;
        private string _readCommand = String.Empty;
        private uint _curRetry = 0;
        private string _newLine = "\r\n";
        protected byte ETX = 0;
        protected byte STX = 0;
​
        public BarcodeReaderConfig BarcodeReaderConfig;
​
​
        private readonly object _lockObject = new object();/*
        private EventHandler<SerialDataEventArgs> SerialReceivedHandler = null;
        public event EventHandler DataUpdated;*/
​
        private bool _isConnected { get; set; }
        public uint DataLength { get => _dataLength; private set => _dataLength = value; }
        public bool IsScanning { get => _isScanning; private set => _isScanning = value; }
        public string DataReceive
        {
            get
            {
                return _strReceive;
            }
            private set => _strReceive = value;
        }
        public bool IsReadFail { get => _isReadFail; private set => _isReadFail = value; }
        public uint RetryRead => BarcodeReaderConfig.RetryRead;
        public uint TimeoutRead => (uint)BarcodeReaderConfig.serialPortModel.ReadTimeout;
        public string ReadCommand { get => _readCommand; set => _readCommand = value; }
        public bool IsConnected => _isConnected;
        //public BarcodeReader(SerialPortModel serialPortModel, BarcodeReaderConfig config) : base(serialPortModel)
        //{
​
        //    if (!ValidationDataConfi(config))
        //        MessageBox.Show("Barcode config not vaild? ", "Barcode Notice", MessageBoxButtons.OKCancel, MessageBoxIcon.Warning, MessageBoxDefaultButton.Button1/*, MessageBoxOptions.DefaultDesktopOnly*/) == DialogResult.Cancel
        //        //DisplayUtil.ShowNotice("Barcode config not vaild", UI.Popup.NoticeBox.Query.Warning);
​
        //    DataLength = config.DataLength;
        //    //TimeoutRead = (uint)config.serialPortModel.ReadTimeout;
        //    ReadCommand = config.ReadCommand;
        //    //RetryRead = config.RetryRead;
​
        //    Connect();
        //    SerialReceivedHandler = new EventHandler<SerialDataEventArgs>(Serial_DataRecieved);
        //    SerialDataRecieved += SerialReceivedHandler;
        //}
        public BarcodeReader(BarcodeReaderConfig config) : base(config.serialPortModel)
        {
            BarcodeReaderConfig = config;
            if (!ValidationDataConfi(BarcodeReaderConfig))
                //DisplayUtil.ShowNotice("Barcode config not vaild", UI.Popup.NoticeBox.Query.Warning);
​
            DataLength = BarcodeReaderConfig.DataLength;
            //TimeoutRead = (uint)config.serialPortModel.ReadTimeout;
            ReadCommand = BarcodeReaderConfig.ReadCommand;
            //RetryRead = BarcodeReaderConfig.RetryRead;
​
            Connect();
            SerialReceivedHandler = new EventHandler<SerialDataEventArgs>(Serial_DataRecieved);
            SerialDataRecieved += SerialReceivedHandler;
        }
        private bool ValidationDataConfi(BarcodeReaderConfig config)
        {
            if (config.serialPortModel is null)
                return false;
            if (config.DataLength <= 0)
                return false;
            /*if (config.serialPortModel.ReadTimeout <= 0)
                return false;*/
            if (config.RetryRead <= 0)
                return false;
            if (String.IsNullOrWhiteSpace(config.ReadCommand))
                return false;
            return true;
        }
        private bool ValidationDataReceive(string data)
        {
            if (String.IsNullOrWhiteSpace(data))
                return false;
            if (!data.EndsWith("\n")) return false;
            data = data.Substring(0, data.IndexOf("\n"));
            if (DataLength > 0)
            {
                if (data.Length != DataLength) return false;
            }
            return true;
​
        }
        private void Serial_DataRecieved(object sender, SerialDataEventArgs e)
        {
            DataReceive += Encoding.ASCII.GetString(e._data);
            //DataUpdated?.Invoke(this, null);
            base.DataUpdate(this, e);
        }
        public bool Connect()
        {
            _isConnected = base.Open();
            return _isConnected;
        }
        public bool Disconnect()
        {
            _isConnected = !base.Close();
            return _isConnected;
        }
        private void Write()
        {
            _curRetry++;
            DataReceive = null;
            Send(ReadCommand/* + _newLine*/);
        }
        //private void Write(string data)
        //{
        //    _curRetry++;
        //    DataReceive = null;
        //    ReadCommand = data;
        //    Send(data + _newLine);
        //}
        public void Trigger()
        {
            lock (this)
            {
                if (!IsOpen)
                {
                    //DisplayUtil.ShowNotice($"Port {mSerialPortData.PortName} not connect", UI.Popup.NoticeBox.Query.Warning);
                    //if (MessageBox.Show("Scanner Barcode not connect ", "Scanner", MessageBoxButtons.OKCancel, MessageBoxIcon.Warning) == DialogResult.Cancel)
                    if (MessageBox.Show("Scanner Barcode not connect ", "Scanner", MessageBoxButtons.OKCancel, MessageBoxIcon.Warning) == DialogResult.Cancel)
                    {
                        return;
                    }
                }
                if (!_isConnected)
                {
                    //DisplayUtil.ShowNotice($"Port {mSerialPortData.PortName} not connect", UI.Popup.NoticeBox.Query.Warning);
                    if (MessageBox.Show("Scanner Barcode not connect ", "Scanner", MessageBoxButtons.OKCancel, MessageBoxIcon.Warning) == DialogResult.Cancel)
                    {
                        return;
                    }
                }
                if (IsScanning)
                {
                    return;
                }
                DataReceive = null;
                IsScanning = true;
                IsReadFail = false;
                _curRetry = 0;
                Thread th = new Thread(() =>
                {
                Loop:
                    Stopwatch watch = Stopwatch.StartNew();
                    Write();
                    bool check = false;
                    while (!check
                            && watch.ElapsedMilliseconds < TimeoutRead)
                    {
                        check = ValidationDataReceive(DataReceive);
                        Thread.Sleep(100);
                        continue;
                    }
                    if (_curRetry < RetryRead && !check)
                        goto Loop;
                    if (!check) IsReadFail = true;
                    else
                        IsReadFail = false;
                    IsScanning = false;
                });
                th.Start();
            }
        }
        public new void Dispose()
        {
            SerialDataRecieved -= SerialReceivedHandler;
            SerialReceivedHandler = null;
​
            base.Dispose();
        }
    }
​
    public class BarcodeReaderConfig
    {
        public uint DataLength { set; get; } = 10;
        public string ReadCommand { get; set; } = "T";
        public uint RetryRead { get; set; } = 3;
        public string NewLine { get; set; } = "\r\n";
​
        public SerialPortModel serialPortModel = new SerialPortModel();
    }
    public enum Baurate : int
    {
        None = -1,
        N9600 = 9600,
        N115200 = 115200
    }
}
​
HW/Common/TowerLamp.cs
using Auto_Insert_Sim_Tray.Define;
using Auto_Insert_Sim_Tray.HW.Interface;
using Auto_Insert_Sim_Tray.Manager;
using Auto_Insert_Sim_Tray.Utils;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using static Auto_Insert_Sim_Tray.Define.IODefine;
using static Auto_Insert_Sim_Tray.Define.LogDefine;
using static Auto_Insert_Sim_Tray.Define.SystemEnum;
using Timer = System.Timers.Timer;
​
namespace Auto_Insert_Sim_Tray.HW.Common
{
    /**
     * @brief Tower Lamp 색상 종류
     */
    public enum TOWERLAMP_MODE
    {
        MANUAL,
        AUTO,
        ERROR,
        OPP,
        OP_CALL,
        IDLE
    }
    public enum TOWERLAMP_ELEMENT
    {
        NONE = 0,
        G_R_Y,
        G,
        R,
        Y,
        G_R,
        G_Y,
        R_Y,
​
        NONE_B = 10,
        G_R_Y_B,
        G_B,
        R_B,
        Y_B,
        G_R_B,
        G_Y_B,
        R_Y_B
    }
    /**
     * @brief Tower Lamp 데이터 클래스
     * @details Tower Lamp에 연결되어 있는 IO의 데이터 클래스
     */
    public class TowerLampData
    {
        public object outG { get; set; }
        public object outY { get; set; }
        public object outR { get; set; }
        public object outBuzzer { get; set; }
​
        /**
         * @brief Tower Lamp 데이터 클래스 생성자
         * @param[in] green 녹색등에 연결된 IO
         * @param[in] yellow 황색등에 연결된 IO
         * @param[in] red 적색등에 연결된 IO
         * @param[in] buzzer buzzer에 연결된 IO
         */
        public TowerLampData(object green, object yellow, object red, object buzzer)
        {
            outG = green;
            outY = yellow;
            outR = red;
            outBuzzer = buzzer;
        }
    }
​
    /**
     * @brief TowerLamp 동작 제공 클래스
     */
    public class TowerLamp
    {
        private IIO iIO;
        private TowerLampData towerData;
        public Timer elapsedTimer;
​
        /**
         * @brief TowerLamp 클래스 생성자
         * @param[in] io IO interface
         * @param[in] data TowerLamp에 연결된 IO를 가진 data 클래스
         */
        public TowerLamp(IIO io, TowerLampData data)
        {
            InitializeVariable(io, data);
        }
​
        /**
         * @brief 변수 초기화 함수
         * @param[in] io IO interface
         * @param[in] data TowerLamp에 연결된 IO를 가진 data 클래스
         */
        private void InitializeVariable(IIO io, TowerLampData data)
        {
            iIO = io;
            towerData = data;
            elapsedTimer = new Timer();
            elapsedTimer.Interval = SystemDefine.BUZZER_TIMEOUT;
            elapsedTimer.AutoReset = false;
            elapsedTimer.Elapsed += ElapsedTimer_Elapsed;
        }
​
        /**
         * @brief TowerLamp 색상 출력
         * @param[in] element TOWERLAMP_ELEMT로, TOWER LAMP 색상에 관한 정의
         */
        public void SetTowerLampColor(TOWERLAMP_ELEMENT element)
        {
            if (towerData?.outG == null || towerData?.outR == null || towerData?.outY == null)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, "Please check tower lamp IO assign", CONTENT_TYPE.ERROR);
                return;
            }
​
            if (iIO == null)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, "Please assign IO interface", CONTENT_TYPE.ERROR);
                return;
            }
​
            switch (element)
            {
                case TOWERLAMP_ELEMENT.G:
                case TOWERLAMP_ELEMENT.G_B:
                    iIO.On(towerData?.outG);
                    iIO.Off(towerData?.outR);
                    iIO.Off(towerData?.outY);
                    break;
                case TOWERLAMP_ELEMENT.R:
                case TOWERLAMP_ELEMENT.R_B:
                    iIO.Off(towerData?.outG);
                    iIO.On(towerData?.outR);
                    iIO.Off(towerData?.outY);
                    break;
                case TOWERLAMP_ELEMENT.Y:
                case TOWERLAMP_ELEMENT.Y_B:
                    iIO.Off(towerData?.outG);
                    iIO.Off(towerData?.outR);
                    iIO.On(towerData?.outY);
                    break;
                case TOWERLAMP_ELEMENT.G_Y:
                case TOWERLAMP_ELEMENT.G_Y_B:
                    iIO.On(towerData?.outG);
                    iIO.Off(towerData?.outR);
                    iIO.On(towerData?.outY);
                    break;
                case TOWERLAMP_ELEMENT.G_R:
                case TOWERLAMP_ELEMENT.G_R_B:
                    iIO.On(towerData?.outG);
                    iIO.On(towerData?.outR);
                    iIO.Off(towerData?.outY);
                    break;
                case TOWERLAMP_ELEMENT.R_Y:
                case TOWERLAMP_ELEMENT.R_Y_B:
                    iIO.Off(towerData?.outG);
                    iIO.On(towerData?.outR);
                    iIO.On(towerData?.outY);
                    break;
                case TOWERLAMP_ELEMENT.NONE:
                case TOWERLAMP_ELEMENT.NONE_B:
                    iIO.Off(towerData?.outG);
                    iIO.Off(towerData?.outR);
                    iIO.Off(towerData?.outY);
                    break;
                case TOWERLAMP_ELEMENT.G_R_Y:
                case TOWERLAMP_ELEMENT.G_R_Y_B:
                    iIO.On(towerData?.outG);
                    iIO.On(towerData?.outR);
                    iIO.On(towerData?.outY);
                    break;
                default:
                    break;
            }
        }
​
        /**
         * @brief Buzzer timeout 핸들링 함수
         * @param[in] sender invoke 시킨 주체
         * @param[in] e invoke 시키면서 전달된 매개변수
         */
        private void ElapsedTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
        {
            ForceBuzzerOff();
            elapsedTimer.Stop();
        }
​
        /**
         * @brief Buzzer 컨트롤을 위한 함수
         * @details buzzer에 대한 IO 체크 후 등록된 IO가 있다면 buzzer IO를 켜고 타이머를 시작
         */
        public void BuzzerControl()
        {
            if (towerData?.outBuzzer != null)
            {
                iIO.On(towerData?.outBuzzer);
​
                elapsedTimer.Interval = SystemDefine.BUZZER_TIMEOUT;
                elapsedTimer.Start();
            }
        }
        public void BuzzerControl(TOWERLAMP_ELEMENT element)
        {
            if (towerData?.outBuzzer != null)
            {
                if (element <= TOWERLAMP_ELEMENT.R_Y)
                {
                    iIO.Off(towerData?.outBuzzer);
                }
                else if (element > TOWERLAMP_ELEMENT.R_Y)
                {
                    iIO.On(towerData?.outBuzzer);
                }
​
                elapsedTimer.Interval = SystemDefine.BUZZER_TIMEOUT;
                elapsedTimer.Start();
            }
        }
        /**
         * @brief Buzzer 컨트롤을 위한 함수
         * @details buzzer에 대한 IO 체크 후 등록된 IO가 있다면 buzzer를 켠다.
         */
        public void BuzzerOnInfinitely()
        {
            if (towerData?.outBuzzer != null && iIO != null)
            {
                elapsedTimer.Stop();
                iIO.On(towerData?.outBuzzer);
            }
        }
        public void BuzzerOnInfinitely(TOWERLAMP_ELEMENT element)
        {
            if (towerData?.outBuzzer != null && iIO != null)
            {
                elapsedTimer.Stop();
                if (element <= TOWERLAMP_ELEMENT.R_Y)
                {
                    iIO.Off(towerData?.outBuzzer);
                }
                else if (element > TOWERLAMP_ELEMENT.R_Y)
                {
                    iIO.On(towerData?.outBuzzer);
                }
            }
        }
​
        /**
         * @brief Buzzer 컨트롤을 위한 함수
         * @details buzzer에 대한 IO 체크 후 등록된 IO가 있다면 buzzer IO를 끔
         */
        public void ForceBuzzerOff()
        {
            if (towerData?.outBuzzer != null && iIO != null)
            {
                iIO.Off(towerData?.outBuzzer);
            }
        }
    }
}
​
Vendor/Fastech/Data.cs
/* 
 * Copyright (C) Samsung Electronics Co., Ltd., Inc - All Rights Reserved
 * Unauthorized copying of this file, via any medium is strictly prohibited
 * Proprietary and confidential
 * 
 * Written by Donghyun Ko <dh79.ko@samsung.com>, June 2022
 * Written by Sanghyeon Lee <sirano06.lee@samsung.com>, June 2022
 * 
 */
using Auto_Insert_Sim_Tray.Configs;
using Auto_Insert_Sim_Tray.Configs.Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static Auto_Insert_Sim_Tray.Define.IODefine;
using static Auto_Insert_Sim_Tray.HW.Vendor.Fastech.Lib.EZI_COMM_DEFINE;
​
namespace Auto_Insert_Sim_Tray.HW.Vendor.Fastech.Data
{
    public enum FASTECH_OBJECT_TYPE
    {
        NONE = 0x00,
        AXIS = 0x01,
        IO = 0x02,
        AXIS_IO = 0x03,
    }
​
    public enum FASTECH_CONNECTION_TYPE
    {
        NONE = 0,
        SERIAL,
        ETHERNET
    }
​
    public enum FASTECH_AXIS_TYPE
    {
        NONE = 0,
        EZI_SERVO_PLUS_R_V6,
        EZI_SERVO_PLUS_R_V8,
        EZI_SERVO_PLUS_E_V6,
        EZI_MOTION_LINK_PLUS_R_V6,
        EZI_MOTION_LINK_PLUS_R_V8,
        EZI_MOTION_LINK_PLUS_E_V6,
    }
​
    public enum FASTECH_IO_BOARD_TYPE
    {
        NONE = -1,
        EZI_PLUS_I6O9,
        EZI_PLUS_I9O9,
        EZI_IO_I16 = 150,
        EZI_IO_I32 = 151,
        EZI_IO_I8O8 = 155,
        EZI_IO_I16O16 = 156,
        EZI_IO_O16 = 160,
        EZI_IO_O32 = 161,
        EZI_PLUS_I12O9, //Ezi IO giống I9O9 (có thêm tín hiệu Limit, Home
    }
​
    public enum LEVEL_SPEED
    {
        SLOW,
        NORMAL,
        HIGH,
    }
​
    public class FastechObject
    {
        // AXIS, IO , AXIS|IO
        public FASTECH_OBJECT_TYPE objectType { get; }
        // Serail의 경우 SlaveID, Ethernet의 경우 Board ID
        public byte ID { get; }
        // 연결 방법
        public FASTECH_CONNECTION_TYPE connectionType { get; }
        // SerialPortModel or IPAddress
        public object connectionInfo { get; }
        // IO Board type
        public FASTECH_IO_BOARD_TYPE boardType { get; }
        // Axis Type
        public FASTECH_AXIS_TYPE axisType { get; }
​
        // 현재 Fastech 제품의 모든 상태를 업데이트한다.
        public FastechStatus fastechStatus { get; set; }
​
        // IO Board를 위해 사용한다.
        public uint inputValue;
        public uint outputValue;
​
        public FastechObject(FASTECH_OBJECT_TYPE objectType, byte ID, FASTECH_CONNECTION_TYPE connectionType, object connectionInfo, FASTECH_IO_BOARD_TYPE boardType, FASTECH_AXIS_TYPE axisType)
        {
            this.objectType = objectType;
            this.ID = ID;
            this.connectionType = connectionType;
            this.connectionInfo = connectionInfo;
            this.boardType = boardType;
            this.axisType = axisType;
​
            fastechStatus = new FastechStatus();
            inputValue = 0x00;
            outputValue = 0x00;
        }
    }
​
    // Fastech제품 상태를 지속적으로 Update하여 저장하여야 한다.
    public class FastechStatus
    {
        public uint inStatus;
        public ulong inStatusV8;
        public uint outStatus;
        public uint axisStatus;
        public int targetPos;
        public int currentPos;
        public int posError;
        public int velocity;
        public ushort posTableItemNo;
​
        public FastechStatus()
        {
            inStatus = 0;
            inStatusV8 = 0;
            outStatus = 0;
            axisStatus = 0;
            targetPos = 0;
            currentPos = 0;
            posError = 0;
            velocity = 0;
            posTableItemNo = 0;
        }
    }
}
​
Vendor/Lib/Fastech.cs
/* 
 * Copyright (C) Samsung Electronics Co., Ltd., Inc - All Rights Reserved
 * Unauthorized copying of this file, via any medium is strictly prohibited
 * Proprietary and confidential
 * 
 * Written by Donghyun Ko <dh79.ko@samsung.com>, June 2022
 * Written by Sanghyeon Lee <sirano06.lee@samsung.com>, June 2022
 * 
 */
​
using Auto_Insert_Sim_Tray.Configs.Model;
using Auto_Insert_Sim_Tray.Define;
using Auto_Insert_Sim_Tray.HW.Interface;
using Auto_Insert_Sim_Tray.HW.Vendor.Fastech.Data;
using Auto_Insert_Sim_Tray.HW.Vendor.Fastech.Lib;
using Auto_Insert_Sim_Tray.Utils;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using static Auto_Insert_Sim_Tray.Define.AxisDefine;
using static Auto_Insert_Sim_Tray.Define.IODefine;
using static Auto_Insert_Sim_Tray.Define.LogDefine;
using static Auto_Insert_Sim_Tray.HW.Vendor.Fastech.Lib.EZI_COMM_DEFINE;
using static Auto_Insert_Sim_Tray.HW.Vendor.Fastech.Lib.EziMOTIONPlusELib;
using static Auto_Insert_Sim_Tray.HW.Vendor.Fastech.Lib.EziMOTIONPlusRLib;
using static Auto_Insert_Sim_Tray.HW.Vendor.Fastech.Lib.EziMOTIONPlusRV8Lib;
​
namespace Auto_Insert_Sim_Tray.HW.Vendor.Fastech
{
    class Fastech : IAxis, IIO, NV_UI_2_0.UserIIO
    {
        private const bool ON = true;
        private const bool OFF = false;
        private const int TRUE = 1;
        private const int FALSE = 0;
​
        private int portCount = 0;
        private int ethernetCount = 0;
        private int maxPortValue = 0;
        private int maxEthernetID = 0;
        private int countRetryConnect = 0;
​
        private bool[] isPortConnected = null;
        private bool[] isEthernetConnected = null;
​
        // 연결되어 있는 fastech 제품들의 list
        // Serial의 경우 같은 Port를 사용하는 제품들로 하나의 list를 구성해야 한다.
        private List<FastechObject[]> listFastechObjects;
        private AxisParamData[] axisParamData;
​
        private Dictionary<AXIS_LIST, FastechObject> axisList;
        private List<FastechObject> ioList;
​
        private SafeThread axisThread;
        private SafeThread inputThread;
        private SafeThread outputThread;
        private object axisStatusLock;
        private object inputStatusLock;
        private object outputStatusLock;
​
        public Fastech(List<FastechObject[]> listFastechObjects)
        {
            axisStatusLock = new object();
            inputStatusLock = new object();
            outputStatusLock = new object();
​
            this.listFastechObjects = listFastechObjects;
            GetConnectNum(ref portCount, ref maxPortValue, ref ethernetCount, ref maxEthernetID);
            if (maxPortValue != 0)
            {
                isPortConnected = new bool[maxPortValue + 1];
            }
​
            if (maxEthernetID != 0)
            {
                isEthernetConnected = new bool[maxEthernetID + 1];
            }
​
            InitFastechObjectList();
            axisParamData = new AxisParamData[Convert.ToInt32(AXIS_LIST.MAX)];
​
            // 모든 Fastech object를 연결한다.
            Connect();
​
            axisThread = new SafeThread(new ThreadStart(UpdateAllStatus), 50);
            axisThread.StartThread();
​
            inputThread = new SafeThread(new ThreadStart(UpdateInputStatus), 50);
            inputThread.StartThread();
​
            outputThread = new SafeThread(new ThreadStart(UpdateOutputStatus), 50);
            outputThread.StartThread();
        }
​
        /*
         * @brief Axis와 IO만 분리하여 List 구성하며, 현재 상태 값을 저장하도록 한다.
         */
        private void InitFastechObjectList()
        {
            int axixIdx = 0;
​
            axisList = new Dictionary<AXIS_LIST, FastechObject>();
            ioList = new List<FastechObject>();
​
            foreach (var fastechObjects in listFastechObjects)
            {
                foreach (var fastech in fastechObjects)
                {
                    if ((fastech.objectType & FASTECH_OBJECT_TYPE.AXIS) != FASTECH_OBJECT_TYPE.NONE)
                    {
                        axisList.Add((AXIS_LIST)axixIdx, fastech);
                        axixIdx++;
                    }
​
                    if ((fastech.objectType & FASTECH_OBJECT_TYPE.IO) != FASTECH_OBJECT_TYPE.NONE)
                    {
                        ioList.Add(fastech);
                    }
                }
            }
        }
​
        private void GetConnectNum(ref int portCount, ref int maxPortValue, ref int ethernetCount, ref int maxEthernetID)
        {
            foreach (var fastechObjects in listFastechObjects)
            {
                foreach (var fastech in fastechObjects)
                {
                    if (fastech.connectionType == FASTECH_CONNECTION_TYPE.SERIAL)
                    {
                        SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                        string strPort = GetPortString(serial.PortName);
                        byte bytePort = byte.Parse(strPort);
​
                        if (bytePort > maxPortValue)
                        {
                            maxPortValue = bytePort;
                        }
                        portCount++;
                        break;
                    }
                    else if (fastech.connectionType == FASTECH_CONNECTION_TYPE.ETHERNET)
                    {
                        if (fastech.ID > maxEthernetID)
                        {
                            maxEthernetID = fastech.ID;
                        }
                        ethernetCount++;
                    }
                }
            }
​
            LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"GetConnectNum - Port : {portCount}, {maxPortValue}", CONTENT_TYPE.DEBUG);
            LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"GetConnectNum - Ethernet : {ethernetCount}, {maxEthernetID}", CONTENT_TYPE.DEBUG);
        }
​
        /**
         * @brief Port number를 반환하는 함수
         * @param[in] port Serial port name
         * @return Port string에 COM 제외한 포트 number를 리턴
         */
        private string GetPortString(string port)
        {
            if (port.Contains("COM"))
            {
                port = port.Remove(0, 3);
            }
            return port;
        }
​
        /**
         * @brief 원하는 Motor status를 반환하는 함수
         * @param[in] axisIdx AXIS_LIST 번호
         * @param[in] checkFlag 체크하고자 하는 축의 flag
         * @return 체크하고자 하는 상태인지 여부
         */
        private bool CheckAxisStatus(object axisIdx, uint checkFlag)
        {
            try
            {
                bool ret = false;
                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
​
                if (!IsConnected(axisIdx))
                {
                    //LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"{(AXIS_LIST)axisIdx} didn't connected!", CONTENT_TYPE.EXCEPTION);
                    return ret;
                }
​
                if ((fastech.fastechStatus.axisStatus & checkFlag) != 0)
                {
                    ret = true;
                }
​
                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }
​
        /**
         * @brief motor status를 업데이트하는 함수
         * @details 모든 slave의 motor driver의 status를 업데이트
         */
        public void UpdateAllStatus()
        {
            try
            {
                int libRet = FMM_OK;
​
                foreach (KeyValuePair<AXIS_LIST, FastechObject> var in axisList)
                {
                    FastechObject fastech = var.Value;
                    FastechStatus fastechStatus = new FastechStatus();
​
                    if (!IsConnected(var.Key))
                    {
                        Reconnect(fastech);
                        continue;
                    }
​
                    switch (fastech.connectionType)
                    {
                        case FASTECH_CONNECTION_TYPE.SERIAL:
                            SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                            string strPort = GetPortString(serial.PortName);
                            byte bytePort = byte.Parse(strPort);
​
                            switch (fastech.axisType)
                            {
                                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                    libRet = EziMOTIONPlusRV8Lib.FAS_GetAllStatus(
                                        bytePort,
                                        fastech.ID,
                                        ref fastechStatus.inStatusV8,
                                        ref fastechStatus.outStatus,
                                        ref fastechStatus.axisStatus,
                                        ref fastechStatus.targetPos,
                                        ref fastechStatus.currentPos,
                                        ref fastechStatus.posError,
                                        ref fastechStatus.velocity,
                                        ref fastechStatus.posTableItemNo);
                                    break;
​
                                default:
                                    libRet = EziMOTIONPlusRLib.FAS_GetAllStatus(
                                        bytePort,
                                        fastech.ID,
                                        ref fastechStatus.inStatus,
                                        ref fastechStatus.outStatus,
                                        ref fastechStatus.axisStatus,
                                        ref fastechStatus.targetPos,
                                        ref fastechStatus.currentPos,
                                        ref fastechStatus.posError,
                                        ref fastechStatus.velocity,
                                        ref fastechStatus.posTableItemNo);
                                    break;
                            }
                            break;
​
                        case FASTECH_CONNECTION_TYPE.ETHERNET:
                            libRet = EziMOTIONPlusELib.FAS_GetAllStatus(
                                fastech.ID,
                                ref fastechStatus.inStatus,
                                ref fastechStatus.outStatus,
                                ref fastechStatus.axisStatus,
                                ref fastechStatus.targetPos,
                                ref fastechStatus.currentPos,
                                ref fastechStatus.posError,
                                ref fastechStatus.velocity,
                                ref fastechStatus.posTableItemNo);
                            break;
                    }
​
                    lock (axisStatusLock)
                    {
                        if (libRet == FMM_OK)
                        {
                            fastech.fastechStatus = fastechStatus;
                        }
                    }
​
                    if (libRet != FMM_OK)
                    {
                        if (libRet == FMM_NOT_OPEN)
                        {
                            UpdateConnectionStatus(fastech);
                        }
                        LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, "Fastech update status error with return value : " + libRet.ToString(), CONTENT_TYPE.ERROR);
                    }
                }
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
            }
        }
​
        private void Reconnect(FastechObject fastech)
        {
            Close(fastech);
            Util.Delay(100);
            Connect(fastech);
        }
        private void UpdateConnectionStatus(FastechObject fastech)
        {
            switch (fastech.connectionType)
            {
                case FASTECH_CONNECTION_TYPE.NONE:
                    break;
                case FASTECH_CONNECTION_TYPE.SERIAL:
                    SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                    string strPort = GetPortString(serial.PortName);
                    byte bytePort = byte.Parse(strPort);
                    isPortConnected[bytePort] = false;
                    break;
                case FASTECH_CONNECTION_TYPE.ETHERNET:
                    isEthernetConnected[fastech.ID] = false;
                    break;
                default:
                    break;
            }
        }
​
        /**
         * @brief Input Value를 업데이트하는 함수
         * @details 모든 slave의 Input 값을 업데이트
         */
        public void UpdateInputStatus()
        {
            try
            {
                int libRet = FMM_OK;
                byte boardType = 0;
                string version = "";
                uint inputValue = 0;
                uint latch = 0;
                FastechStatus fastechStatus = new FastechStatus();
​
                foreach (FastechObject fastech in ioList)
                {
                    boardType = 0;
                    version = "";
                    inputValue = 0;
                    latch = 0;
​
                    switch (fastech.connectionType)
                    {
                        case FASTECH_CONNECTION_TYPE.SERIAL:
                            SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                            string strPort = GetPortString(serial.PortName);
                            byte bytePort = byte.Parse(strPort);
​
                            if (!isPortConnected[bytePort])
                            {
                                Reconnect(fastech);
                                continue;
                            }
​
                            // Motor에 IO가 달려있는 경우에는 UpdateAllStatus 함수에서 업데이트한다.
                            // 오직 IO Board type 에서만 해당 값을 업데이트 한다.
                            if (((fastech.objectType & FASTECH_OBJECT_TYPE.IO) != FASTECH_OBJECT_TYPE.NONE)
                                && ((fastech.objectType & FASTECH_OBJECT_TYPE.AXIS) == FASTECH_OBJECT_TYPE.NONE))
                            {
                                libRet = EziMOTIONPlusRLib.FAS_GetSlaveInfo(bytePort, fastech.ID, ref boardType, ref version);
                                if (libRet == FMM_OK)
                                {
                                    switch ((FASTECH_IO_BOARD_TYPE)boardType)
                                    {
                                        case FASTECH_IO_BOARD_TYPE.EZI_IO_I16:
                                        case FASTECH_IO_BOARD_TYPE.EZI_IO_I16O16:
                                        case FASTECH_IO_BOARD_TYPE.EZI_IO_I32:
                                            libRet = EziMOTIONPlusRLib.FAS_GetInput(bytePort, fastech.ID, ref inputValue, ref latch);
                                            break;
                                    }
                                }
                            }
                            break;
​
                        case FASTECH_CONNECTION_TYPE.ETHERNET:
                            if (!isEthernetConnected[fastech.ID])
                            {
                                Reconnect(fastech);
                                continue;
                            }
​
                            libRet = EziMOTIONPlusELib.FAS_GetSlaveInfo(fastech.ID, ref boardType, ref version);
                            if (libRet == FMM_OK)
                            {
                                switch ((FASTECH_IO_BOARD_TYPE)boardType)
                                {
                                    case FASTECH_IO_BOARD_TYPE.EZI_IO_I16:
                                    case FASTECH_IO_BOARD_TYPE.EZI_IO_I16O16:
                                    case FASTECH_IO_BOARD_TYPE.EZI_IO_I32:
                                        libRet = EziMOTIONPlusELib.FAS_GetInput(fastech.ID, ref inputValue, ref latch);
                                        break;
                                }
                            }
                            break;
                    }
​
                    lock (inputStatusLock)
                    {
                        if (libRet == FMM_OK)
                        {
                            fastech.inputValue = inputValue;
                        }
                    }
​
                    if (libRet != FMM_OK)
                    {
                        if (libRet == FMM_NOT_OPEN)
                        {
                            UpdateConnectionStatus(fastech);
                        }
                        LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Fastech output status error with return value : {libRet.ToString()}", CONTENT_TYPE.ERROR);
                    }
                }
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
            }
        }
​
        /**
         * @brief Output Value를 업데이트하는 함수
         * @details 모든 slave의 Output 값을 업데이트
         */
        public void UpdateOutputStatus()
        {
            try
            {
                int libRet = FMM_OK;
                byte boardType = 0;
                string version = "";
                uint outputValue = 0;
                uint latch = 0;
                FastechStatus fastechStatus = new FastechStatus();
​
                foreach (FastechObject fastech in ioList)
                {
                    boardType = 0;
                    version = "";
                    outputValue = 0;
                    latch = 0;
​
                    switch (fastech.connectionType)
                    {
                        case FASTECH_CONNECTION_TYPE.SERIAL:
                            SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                            string strPort = GetPortString(serial.PortName);
                            byte bytePort = byte.Parse(strPort);
​
                            if (!isPortConnected[bytePort])
                            {
                                Reconnect(fastech);
                                continue;
                            }
​
                            // Motor에 IO가 달려있는 경우에는 UpdateAllStatus 함수에서 업데이트한다.
                            // 오직 IO Board type 에서만 해당 값을 업데이트 한다.
                            if (((fastech.objectType & FASTECH_OBJECT_TYPE.IO) != FASTECH_OBJECT_TYPE.NONE)
                                && ((fastech.objectType & FASTECH_OBJECT_TYPE.AXIS) == FASTECH_OBJECT_TYPE.NONE))
                            {
                                libRet = EziMOTIONPlusRLib.FAS_GetSlaveInfo(bytePort, fastech.ID, ref boardType, ref version);
                                if (libRet == FMM_OK)
                                {
                                    switch ((FASTECH_IO_BOARD_TYPE)boardType)
                                    {
                                        case FASTECH_IO_BOARD_TYPE.EZI_IO_O16:
                                        case FASTECH_IO_BOARD_TYPE.EZI_IO_I16O16:
                                        case FASTECH_IO_BOARD_TYPE.EZI_IO_O32:
                                            libRet = EziMOTIONPlusRLib.FAS_GetOutput(bytePort, fastech.ID, ref outputValue, ref latch);
                                            break;
                                    }
                                }
                            }
                            break;
​
                        case FASTECH_CONNECTION_TYPE.ETHERNET:
                            if (!isEthernetConnected[fastech.ID])
                            {
                                Reconnect(fastech);
                                continue;
                            }
​
                            libRet = EziMOTIONPlusELib.FAS_GetSlaveInfo(fastech.ID, ref boardType, ref version);
                            if (libRet == FMM_OK)
                            {
                                switch ((FASTECH_IO_BOARD_TYPE)boardType)
                                {
                                    case FASTECH_IO_BOARD_TYPE.EZI_IO_O16:
                                    case FASTECH_IO_BOARD_TYPE.EZI_IO_I16O16:
                                    case FASTECH_IO_BOARD_TYPE.EZI_IO_O32:
                                        libRet = EziMOTIONPlusELib.FAS_GetOutput(fastech.ID, ref outputValue, ref latch);
                                        break;
                                }
                            }
                            break;
                    }
​
                    lock (outputStatusLock)
                    {
                        if (libRet == FMM_OK)
                        {
                            fastech.outputValue = outputValue;
                        }
                    }
​
                    if (libRet != FMM_OK)
                    {
                        if (libRet == FMM_NOT_OPEN)
                        {
                            UpdateConnectionStatus(fastech);
                        }
                        LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Fastech output status error with return value : {libRet.ToString()}", CONTENT_TYPE.ERROR);
                    }
                }
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
            }
        }
​
        private void GetBoardIOSize(FASTECH_IO_BOARD_TYPE type, ref int inputSize, ref int outputSize)
        {
            inputSize = 0;
            outputSize = 0;
​
            switch (type)
            {
                case FASTECH_IO_BOARD_TYPE.EZI_PLUS_I6O9:
                    inputSize = 6;
                    outputSize = 9;
                    break;
​
                case FASTECH_IO_BOARD_TYPE.EZI_PLUS_I9O9:
                    inputSize = 9;
                    outputSize = 9;
                    break;
​
                case FASTECH_IO_BOARD_TYPE.EZI_IO_I16:
                    inputSize = 16;
                    outputSize = 0;
                    break;
​
                case FASTECH_IO_BOARD_TYPE.EZI_IO_I32:
                    inputSize = 32;
                    outputSize = 0;
                    break;
​
                case FASTECH_IO_BOARD_TYPE.EZI_IO_I8O8:
                    inputSize = 8;
                    outputSize = 8;
                    break;
​
                case FASTECH_IO_BOARD_TYPE.EZI_IO_I16O16:
                    inputSize = 16;
                    outputSize = 16;
                    break;
​
                case FASTECH_IO_BOARD_TYPE.EZI_IO_O16:
                    inputSize = 0;
                    outputSize = 16;
                    break;
​
                case FASTECH_IO_BOARD_TYPE.EZI_IO_O32:
                    inputSize = 0;
                    outputSize = 32;
                    break;
            }
        }
​
        private UInt64 GetInputLogic(FastechObject fastech, int ioValue)
        {
            UInt64 inputLogic = 0x00;
​
            switch (fastech.axisType)
            {
                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V6:
                    switch (ioValue)
                    {
                        case 0:
                            inputLogic = (uint)EZISERVO_INLOGIC_LIST.SERVO_IN_LOGIC_USERIN0;
                            break;
                        case 1:
                            inputLogic = (uint)EZISERVO_INLOGIC_LIST.SERVO_IN_LOGIC_USERIN1;
                            break;
                        case 2:
                            inputLogic = (uint)EZISERVO_INLOGIC_LIST.SERVO_IN_LOGIC_USERIN2;
                            break;
                        case 3:
                            inputLogic = (uint)EZISERVO_INLOGIC_LIST.SERVO_IN_LOGIC_USERIN3;
                            break;
                        case 4:
                            inputLogic = (uint)EZISERVO_INLOGIC_LIST.SERVO_IN_LOGIC_USERIN4;
                            break;
                        case 5:
                            inputLogic = (uint)EZISERVO_INLOGIC_LIST.SERVO_IN_LOGIC_USERIN5;
                            break;
                    }
                    break;
​
                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                    switch (ioValue)
                    {
                        case 0:
                            inputLogic = (UInt64)EZISERVOV8_INLOGIC_LIST.SERVO_IN_LOGIC_USERIN0;
                            break;
                        case 1:
                            inputLogic = (UInt64)EZISERVOV8_INLOGIC_LIST.SERVO_IN_LOGIC_USERIN1;
                            break;
                        case 2:
                            inputLogic = (UInt64)EZISERVOV8_INLOGIC_LIST.SERVO_IN_LOGIC_USERIN2;
                            break;
                        case 3:
                            inputLogic = (UInt64)EZISERVOV8_INLOGIC_LIST.SERVO_IN_LOGIC_USERIN3;
                            break;
                        case 4:
                            inputLogic = (UInt64)EZISERVOV8_INLOGIC_LIST.SERVO_IN_LOGIC_USERIN4;
                            break;
                        case 5:
                            inputLogic = (UInt64)EZISERVOV8_INLOGIC_LIST.SERVO_IN_LOGIC_USERIN5;
                            break;
                        case 6:
                            inputLogic = (UInt64)EZISERVOV8_INLOGIC_LIST.SERVO_IN_LOGIC_USERIN6;
                            break;
                        case 7:
                            inputLogic = (UInt64)EZISERVOV8_INLOGIC_LIST.SERVO_IN_LOGIC_USERIN7;
                            break;
                        case 8:
                            inputLogic = (UInt64)EZISERVOV8_INLOGIC_LIST.SERVO_IN_LOGIC_USERIN8;
                            break;
                    }
                    break;
​
                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_E_V6:
                    switch (ioValue)
                    {
                        case 0:
                            inputLogic = (uint)EZISERVO2_INLOGIC_LIST.SERVO2_IN_LOGIC_USERIN0;
                            break;
                        case 1:
                            inputLogic = (uint)EZISERVO2_INLOGIC_LIST.SERVO2_IN_LOGIC_USERIN1;
                            break;
                        case 2:
                            inputLogic = (uint)EZISERVO2_INLOGIC_LIST.SERVO2_IN_LOGIC_USERIN2;
                            break;
                        case 3:
                            inputLogic = (uint)EZISERVO2_INLOGIC_LIST.SERVO2_IN_LOGIC_USERIN3;
                            break;
                        case 4:
                            inputLogic = (uint)EZISERVO2_INLOGIC_LIST.SERVO2_IN_LOGIC_USERIN4;
                            break;
                        case 5:
                            inputLogic = (uint)EZISERVO2_INLOGIC_LIST.SERVO2_IN_LOGIC_USERIN5;
                            break;
                        case 6:
                            inputLogic = (uint)EZISERVO2_INLOGIC_LIST.SERVO2_IN_LOGIC_USERIN6;
                            break;
                        case 7:
                            inputLogic = (uint)EZISERVO2_INLOGIC_LIST.SERVO2_IN_LOGIC_USERIN7;
                            break;
                        case 8:
                            inputLogic = (uint)EZISERVO2_INLOGIC_LIST.SERVO2_IN_LOGIC_USERIN8;
                            break;
                    }
                    break;
​
                    /*
                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V6:
                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                    switch (ioValue)
                    {
                        case 0:
                            inputLogic = (uint)EZIMOTIONLINK_INLOGIC_LIST.MOTIONLINK_IN_LOGIC_USERIN0;
                            break;
                        case 1:
                            inputLogic = (uint)EZIMOTIONLINK_INLOGIC_LIST.MOTIONLINK_IN_LOGIC_USERIN1;
                            break;
                        case 2:
                            inputLogic = (uint)EZIMOTIONLINK_INLOGIC_LIST.MOTIONLINK_IN_LOGIC_USERIN2;
                            break;
                        case 3:
                            inputLogic = (uint)EZIMOTIONLINK_INLOGIC_LIST.MOTIONLINK_IN_LOGIC_USERIN3;
                            break;
                        case 4:
                            inputLogic = (uint)EZIMOTIONLINK_INLOGIC_LIST.MOTIONLINK_IN_LOGIC_USERIN4;
                            break;
                    }
                    break;
​
                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_E_V6:
                    switch (ioValue)
                    {
                        case 0:
                            inputLogic = (uint)EZIMOTIONLINK2_INLOGIC_LIST.MOTIONLINK2_IN_LOGIC_USERIN0;
                            break;
                    }
                    break;
                    */
            }
​
            return inputLogic;
        }
​
        private UInt64 GetOutputLogic(FastechObject fastech, int ioValue)
        {
            UInt64 outputLogic = 0x00;
​
            switch (fastech.axisType)
            {
                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V6:
                    switch (ioValue)
                    {
                        case 0:
                            outputLogic = (uint)EZISERVO_OUTLOGIC_LIST.SERVO_OUT_LOGIC_USEROUT0;
                            break;
                        case 1:
                            outputLogic = (uint)EZISERVO_OUTLOGIC_LIST.SERVO_OUT_LOGIC_USEROUT1;
                            break;
                        case 2:
                            outputLogic = (uint)EZISERVO_OUTLOGIC_LIST.SERVO_OUT_LOGIC_USEROUT2;
                            break;
                        case 3:
                            outputLogic = (uint)EZISERVO_OUTLOGIC_LIST.SERVO_OUT_LOGIC_USEROUT3;
                            break;
                        case 4:
                            outputLogic = (uint)EZISERVO_OUTLOGIC_LIST.SERVO_OUT_LOGIC_USEROUT4;
                            break;
                        case 5:
                            outputLogic = (uint)EZISERVO_OUTLOGIC_LIST.SERVO_OUT_LOGIC_USEROUT5;
                            break;
                    }
                    break;
​
                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                    switch (ioValue)
                    {
                        case 0:
                            outputLogic = (UInt64)EZISERVOV8_OUTLOGIC_LIST.SERVO_OUT_LOGIC_USEROUT0;
                            break;
                        case 1:
                            outputLogic = (UInt64)EZISERVOV8_OUTLOGIC_LIST.SERVO_OUT_LOGIC_USEROUT1;
                            break;
                        case 2:
                            outputLogic = (UInt64)EZISERVOV8_OUTLOGIC_LIST.SERVO_OUT_LOGIC_USEROUT2;
                            break;
                        case 3:
                            outputLogic = (UInt64)EZISERVOV8_OUTLOGIC_LIST.SERVO_OUT_LOGIC_USEROUT3;
                            break;
                        case 4:
                            outputLogic = (UInt64)EZISERVOV8_OUTLOGIC_LIST.SERVO_OUT_LOGIC_USEROUT4;
                            break;
                        case 5:
                            outputLogic = (UInt64)EZISERVOV8_OUTLOGIC_LIST.SERVO_OUT_LOGIC_USEROUT5;
                            break;
                        case 6:
                            outputLogic = (UInt64)EZISERVOV8_OUTLOGIC_LIST.SERVO_OUT_LOGIC_USEROUT6;
                            break;
                        case 7:
                            outputLogic = (UInt64)EZISERVOV8_OUTLOGIC_LIST.SERVO_OUT_LOGIC_USEROUT7;
                            break;
                        case 8:
                            outputLogic = (UInt64)EZISERVOV8_OUTLOGIC_LIST.SERVO_OUT_LOGIC_USEROUT8;
                            break;
                    }
                    break;
​
                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_E_V6:
                    switch (ioValue)
                    {
                        case 0:
                            outputLogic = (uint)EZISERVO2_OUTLOGIC_LIST.SERVO2_OUT_LOGIC_USEROUT0;
                            break;
                        case 1:
                            outputLogic = (uint)EZISERVO2_OUTLOGIC_LIST.SERVO2_OUT_LOGIC_USEROUT1;
                            break;
                        case 2:
                            outputLogic = (uint)EZISERVO2_OUTLOGIC_LIST.SERVO2_OUT_LOGIC_USEROUT2;
                            break;
                        case 3:
                            outputLogic = (uint)EZISERVO2_OUTLOGIC_LIST.SERVO2_OUT_LOGIC_USEROUT3;
                            break;
                        case 4:
                            outputLogic = (uint)EZISERVO2_OUTLOGIC_LIST.SERVO2_OUT_LOGIC_USEROUT4;
                            break;
                        case 5:
                            outputLogic = (uint)EZISERVO2_OUTLOGIC_LIST.SERVO2_OUT_LOGIC_USEROUT5;
                            break;
                        case 6:
                            outputLogic = (uint)EZISERVO2_OUTLOGIC_LIST.SERVO2_OUT_LOGIC_USEROUT6;
                            break;
                        case 7:
                            outputLogic = (uint)EZISERVO2_OUTLOGIC_LIST.SERVO2_OUT_LOGIC_USEROUT7;
                            break;
                        case 8:
                            outputLogic = (uint)EZISERVO2_OUTLOGIC_LIST.SERVO2_OUT_LOGIC_USEROUT8;
                            break;
                    }
                    break;
​
                    /*
                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V6:
                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                    switch (ioValue)
                    {
                        case 0:
                            outputLogic = (uint)EZIMOTIONLINK_OUTLOGIC_LIST.MOTIONLINK_OUT_LOGIC_USEROUT0;
                            break;
                        case 1:
                            outputLogic = (uint)EZIMOTIONLINK_OUTLOGIC_LIST.MOTIONLINK_OUT_LOGIC_USEROUT1;
                            break;
                        case 2:
                            outputLogic = (uint)EZIMOTIONLINK_OUTLOGIC_LIST.MOTIONLINK_OUT_LOGIC_USEROUT2;
                            break;
                    }
                    break;
​
                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_E_V6:
                    switch (ioValue)
                    {
                        case 0:
                            outputLogic = (uint)EZIMOTIONLINK2_OUTLOGIC_LIST.MOTIONLINK2_OUT_LOGIC_USEROUT0;
                            break;
                    }
                    break;
                    */
            }
​
            return outputLogic;
        }
​
        /**
         * @brief IO가 켜져 있는지 확인하는 함수
         * @param[in] io DIGITAL INPUT/OUTPUT
         * @return IO 켜져 있는지 여부
         */
        public bool IsOn(object io)
        {
            try
            {
                int ioValue = Convert.ToInt32(io);
                int inputSize = 0;
                int outputSize = 0;
                bool data = false;
​
                foreach (var fastech in ioList)
                {
                    GetBoardIOSize(fastech.boardType, ref inputSize, ref outputSize);
                    if (io.GetType() == typeof(DI))
                    {
                        if (ioValue >= inputSize)
                        {
                            ioValue -= inputSize;
                        }
                        else
                        {
                            // Motor 내장형
                            if (((fastech.objectType & FASTECH_OBJECT_TYPE.IO) != FASTECH_OBJECT_TYPE.NONE)
                                && ((fastech.objectType & FASTECH_OBJECT_TYPE.AXIS) != FASTECH_OBJECT_TYPE.NONE))
                            {
                                lock (axisStatusLock)
                                {
                                    switch (fastech.axisType)
                                    {
                                        case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V6:
                                        case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_E_V6:
                                            data = ((fastech.fastechStatus.inStatus & GetInputLogic(fastech, ioValue)) != 0);
                                            break;
                                        case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                                            data = ((fastech.fastechStatus.inStatusV8 & GetInputLogic(fastech, ioValue)) != 0);
                                            break;
                                            // Motion link는 일단 보류
                                            /*
                                        case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V6:
                                        case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                        case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_E_V6:
                                            break;
                                            */
                                    }
                                }
                            }
                            else
                            {
                                lock (inputStatusLock)
                                {
                                    data = ((fastech.inputValue & (0x01 << (int)ioValue)) != 0);
                                }
                            }
                            break;
                        }
                    }
                    else if (io.GetType() == typeof(DO))
                    {
                        if (ioValue >= outputSize)
                        {
                            ioValue -= outputSize;
                        }
                        else
                        {
                            // Motor 내장형
                            if (((fastech.objectType & FASTECH_OBJECT_TYPE.IO) != FASTECH_OBJECT_TYPE.NONE)
                                && ((fastech.objectType & FASTECH_OBJECT_TYPE.AXIS) != FASTECH_OBJECT_TYPE.NONE))
                            {
                                lock (axisStatusLock)
                                {
                                    data = ((fastech.fastechStatus.outStatus & GetOutputLogic(fastech, ioValue)) != 0);
                                }
                            }
                            else
                            {
                                lock (outputStatusLock)
                                {
                                    if (fastech.boardType == FASTECH_IO_BOARD_TYPE.EZI_IO_I16O16)
                                    {
                                        data = ((fastech.outputValue & (0x01 << (int)(ioValue + 16))) != 0);
                                    }
                                    else
                                    {
                                        data = ((fastech.outputValue & (0x01 << (int)ioValue)) != 0);
                                    }
                                }
                            }
                            break;
                        }
                    }
                }
​
                return data;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }
​
        /**
         * @brief IO가 꺼져 있는지 확인하는 함수
         * @param[in] io DIGITAL INPUT/OUTPUT
         * @return IO 꺼져 있는지 여부
         */
        public bool IsOff(object io)
        {
            try
            {
                bool data = false;
                data = IsOn(io);
​
                return !data;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return true;
            }
        }
​
        /**
         * @brief IO 끄는 함수
         * @param[in] io DIGITAL INPUT/OUTPUT
         */
        public void Off(object io)
        {
            try
            {
                int ioValue = Convert.ToInt32(io);
                int inputSize = 0;
                int outputSize = 0;
                bool isConnected = false;
                byte bytePort = 0;
                uint setMask = 0x00;
                uint clrMask = 0x01;
​
                if (io.GetType() != typeof(DO))
                {
                    return;
                }
​
                foreach (var fastech in ioList)
                {
                    GetBoardIOSize(fastech.boardType, ref inputSize, ref outputSize);
                    if (ioValue >= outputSize)
                    {
                        ioValue -= outputSize;
                    }
                    else
                    {
                        switch (fastech.connectionType)
                        {
                            case FASTECH_CONNECTION_TYPE.SERIAL:
                                SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                                string strPort = GetPortString(serial.PortName);
                                bytePort = byte.Parse(strPort);
                                uint baudRate = Convert.ToUInt32(serial.BaudRate);
​
                                isConnected = isPortConnected[bytePort];
                                break;
​
                            case FASTECH_CONNECTION_TYPE.ETHERNET:
                                IPAddress ip = (IPAddress)fastech.connectionInfo;
                                isConnected = isEthernetConnected[fastech.ID];
                                break;
                        }
​
                        if (!isConnected)
                        {
                            return;
                        }
​
                        // Motor 내장형
                        if (((fastech.objectType & FASTECH_OBJECT_TYPE.IO) != FASTECH_OBJECT_TYPE.NONE)
                            && ((fastech.objectType & FASTECH_OBJECT_TYPE.AXIS) != FASTECH_OBJECT_TYPE.NONE))
                        {
                            switch (fastech.axisType)
                            {
                                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V6:
                                    EziMOTIONPlusRLib.FAS_SetIOOutput(bytePort, fastech.ID, setMask, (uint)GetOutputLogic(fastech, ioValue));
                                    break;
​
                                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                                    EziMOTIONPlusRV8Lib.FAS_SetIOOutput(bytePort, fastech.ID, setMask, (uint)GetOutputLogic(fastech, ioValue));
                                    break;
​
                                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_E_V6:
                                    EziMOTIONPlusELib.FAS_SetIOOutput(fastech.ID, setMask, (uint)GetOutputLogic(fastech, ioValue));
                                    break;
​
                                    // Motion link는 일단 보류
                                    /*
                                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V6:
                                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_E_V6:
                                    break;
                                    */
                            }
                        }
                        else
                        {
                            clrMask = clrMask << ioValue;
                            if (fastech.boardType == FASTECH_IO_BOARD_TYPE.EZI_IO_I16O16)
                            {
                                setMask = setMask << 16;
                                clrMask = clrMask << 16;
                            }
​
                            switch (fastech.connectionType)
                            {
                                case FASTECH_CONNECTION_TYPE.SERIAL:
                                    EziMOTIONPlusRLib.FAS_SetOutput(bytePort, fastech.ID, setMask, clrMask);
                                    break;
​
                                case FASTECH_CONNECTION_TYPE.ETHERNET:
                                    EziMOTIONPlusELib.FAS_SetOutput(fastech.ID, setMask, clrMask);
                                    break;
                            }
                        }
                        break;
                    }
                }
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
            }
        }
​
        /**
         * @brief IO 켜는 함수
         * @param[in] io DIGITAL INPUT/OUTPUT
         */
        public void On(object io)
        {
            try
            {
                int ioValue = Convert.ToInt32(io);
                int inputSize = 0;
                int outputSize = 0;
                bool isConnected = false;
                byte bytePort = 0;
                uint setMask = 0x01;
                uint clrMask = 0x00;
​
                if (io.GetType() != typeof(DO))
                {
                    return;
                }
​
                foreach (var fastech in ioList)
                {
                    GetBoardIOSize(fastech.boardType, ref inputSize, ref outputSize);
                    if (ioValue >= outputSize)
                    {
                        ioValue -= outputSize;
                    }
                    else
                    {
                        switch (fastech.connectionType)
                        {
                            case FASTECH_CONNECTION_TYPE.SERIAL:
                                SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                                string strPort = GetPortString(serial.PortName);
                                bytePort = byte.Parse(strPort);
                                uint baudRate = Convert.ToUInt32(serial.BaudRate);
​
                                isConnected = isPortConnected[bytePort];
                                break;
​
                            case FASTECH_CONNECTION_TYPE.ETHERNET:
                                IPAddress ip = (IPAddress)fastech.connectionInfo;
                                isConnected = isEthernetConnected[fastech.ID];
                                break;
                        }
​
                        if (!isConnected)
                        {
                            return;
                        }
​
                        // Motor 내장형
                        if (((fastech.objectType & FASTECH_OBJECT_TYPE.IO) != FASTECH_OBJECT_TYPE.NONE)
                            && ((fastech.objectType & FASTECH_OBJECT_TYPE.AXIS) != FASTECH_OBJECT_TYPE.NONE))
                        {
                            switch (fastech.axisType)
                            {
                                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V6:
                                    EziMOTIONPlusRLib.FAS_SetIOOutput(bytePort, fastech.ID, (uint)GetOutputLogic(fastech, ioValue), clrMask);
                                    break;
​
                                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                                    EziMOTIONPlusRV8Lib.FAS_SetIOOutput(bytePort, fastech.ID, (uint)GetOutputLogic(fastech, ioValue), clrMask);
                                    break;
​
                                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_E_V6:
                                    EziMOTIONPlusELib.FAS_SetIOOutput(fastech.ID, (uint)GetOutputLogic(fastech, ioValue), clrMask);
                                    break;
​
                                    // Motion link는 일단 보류
                                    /*
                                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V6:
                                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_E_V6:
                                    break;
                                    */
                            }
                        }
                        else
                        {
                            setMask = setMask << ioValue;
​
                            if (fastech.boardType == FASTECH_IO_BOARD_TYPE.EZI_IO_I16O16)
                            {
                                setMask = setMask << 16;
                                clrMask = clrMask << 16;
                            }
​
                            switch (fastech.connectionType)
                            {
                                case FASTECH_CONNECTION_TYPE.SERIAL:
                                    EziMOTIONPlusRLib.FAS_SetOutput(bytePort, fastech.ID, setMask, clrMask);
                                    break;
​
                                case FASTECH_CONNECTION_TYPE.ETHERNET:
                                    EziMOTIONPlusELib.FAS_SetOutput(fastech.ID, setMask, clrMask);
                                    break;
                            }
                        }
                        break;
                    }
                }
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
            }
        }
​
        public bool IsConnected()
        {
            try
            {
                bool ret = true;
​
                foreach (var fastechObjects in listFastechObjects)
                {
                    foreach (var fastech in fastechObjects)
                    {
                        if (fastech.connectionType == FASTECH_CONNECTION_TYPE.SERIAL)
                        {
                            SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                            string strPort = GetPortString(serial.PortName);
                            byte bytePort = byte.Parse(strPort);
                            uint baudRate = Convert.ToUInt32(serial.BaudRate);
​
                            ret &= isPortConnected[bytePort];
                            break;
                        }
                        else if (fastech.connectionType == FASTECH_CONNECTION_TYPE.ETHERNET)
                        {
                            IPAddress ip = (IPAddress)fastech.connectionInfo;
                            ret &= isEthernetConnected[fastech.ID];
                        }
                    }
                }
​
                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }
​
        /**
         * @brief 연결 되어 있는지 확인하는 함수
         * @param[in] axisIdx AXIS_LIST 번호
         * @return 연결 되어 있는지 여부
         */
        public bool IsConnected(object axisIdx)
        {
            try
            {
                bool isConnected = false;
                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
​
                switch (fastech.connectionType)
                {
                    case FASTECH_CONNECTION_TYPE.SERIAL:
                        SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                        string strPort = GetPortString(serial.PortName);
                        byte bytePort = byte.Parse(strPort);
​
                        isConnected = isPortConnected[bytePort];
                        break;
​
                    case FASTECH_CONNECTION_TYPE.ETHERNET:
                        isConnected = isEthernetConnected[fastech.ID];
                        break;
                }
​
                return isConnected;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }
​
        /**
        * @brief Servo close 명령 함수
        * @param[in] axisIdx AXIS_LIST 번호
        */
        public void Close(object axisIdx)
        {
            try
            {
                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
                Close(fastech);
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
            }
        }
​
        /**
         * @brief fastech 연결을 끊는 함수(Serial은 같이 연결된 모든 제품이 다 같이 연결이 끊어진다.)
         * @parm[in] fastech 연결을 종료할 FastechObject
         */
        public void Close(FastechObject fastech)
        {
            try
            {
                switch (fastech.connectionType)
                {
                    case FASTECH_CONNECTION_TYPE.SERIAL:
                        SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                        string strPort = GetPortString(serial.PortName);
                        byte bytePort = byte.Parse(strPort);
                        uint baudRate = Convert.ToUInt32(serial.BaudRate);
​
                        isPortConnected[bytePort] = false;
                        switch (fastech.axisType)
                        {
                            case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                            case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                EziMOTIONPlusRV8Lib.FAS_Close(bytePort);
                                break;
​
                            default:
                                EziMOTIONPlusRLib.FAS_Close(bytePort);
                                break;
                        }
                        LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Serial connection close : {serial.PortName}", CONTENT_TYPE.DEBUG);
                        break;
​
                    case FASTECH_CONNECTION_TYPE.ETHERNET:
                        IPAddress ip = (IPAddress)fastech.connectionInfo;
​
                        isEthernetConnected[fastech.ID] = false;
                        EziMOTIONPlusELib.FAS_Close(fastech.ID);
                        LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Ethernet connection close : {ip.ToString()}", CONTENT_TYPE.DEBUG);
                        break;
                }
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
            }
        }
​
        /**
         * @brief fastech 연결을 끊는 함수
         * @parm[in] fastech 연결을 종료할 FastechObjects
         */
        public void Close(FastechObject[] fastechObjects)
        {
            try
            {
                foreach (var fastech in fastechObjects)
                {
                    switch (fastech.connectionType)
                    {
                        case FASTECH_CONNECTION_TYPE.SERIAL:
                            SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                            string strPort = GetPortString(serial.PortName);
                            byte bytePort = byte.Parse(strPort);
                            uint baudRate = Convert.ToUInt32(serial.BaudRate);
​
                            isPortConnected[bytePort] = false;
                            switch (fastech.axisType)
                            {
                                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                    EziMOTIONPlusRV8Lib.FAS_Close(bytePort);
                                    break;
​
                                default:
                                    EziMOTIONPlusRLib.FAS_Close(bytePort);
                                    break;
                            }
                            LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Serial connection close : {serial.PortName}", CONTENT_TYPE.DEBUG);
                            break;
                        case FASTECH_CONNECTION_TYPE.ETHERNET:
                            IPAddress ip = (IPAddress)fastech.connectionInfo;
​
                            isEthernetConnected[fastech.ID] = false;
                            EziMOTIONPlusELib.FAS_Close(fastech.ID);
                            LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Ethernet connection close : {ip.ToString()}", CONTENT_TYPE.DEBUG);
                            break;
                    }
​
                    // Serial은 Port 하나에 대해서만 수행하면 된다.
                    if (fastech.connectionType == FASTECH_CONNECTION_TYPE.SERIAL)
                    {
                        break;
                    }
                }
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
            }
        }
​
        /**
         * @brief 모든 fastech 연결을 끊는 함수
         */
        public void Close()
        {
            try
            {
                foreach (var fastechObjects in listFastechObjects)
                {
                    foreach (var fastech in fastechObjects)
                    {
                        switch (fastech.connectionType)
                        {
                            case FASTECH_CONNECTION_TYPE.SERIAL:
                                SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                                string strPort = GetPortString(serial.PortName);
                                byte bytePort = byte.Parse(strPort);
                                uint baudRate = Convert.ToUInt32(serial.BaudRate);
​
                                isPortConnected[bytePort] = false;
                                switch (fastech.axisType)
                                {
                                    case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                                    case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                        EziMOTIONPlusRV8Lib.FAS_Close(bytePort);
                                        break;
​
                                    default:
                                        EziMOTIONPlusRLib.FAS_Close(bytePort);
                                        break;
                                }
                                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Serial connection close : {serial.PortName}", CONTENT_TYPE.DEBUG);
                                break;
​
                            case FASTECH_CONNECTION_TYPE.ETHERNET:
                                IPAddress ip = (IPAddress)fastech.connectionInfo;
​
                                isEthernetConnected[fastech.ID] = false;
                                EziMOTIONPlusELib.FAS_Close(fastech.ID);
                                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Ethernet connection close : {ip.ToString()}", CONTENT_TYPE.DEBUG);
                                break;
                        }
​
                        // Serial은 Port 하나에 대해서만 수행하면 된다.
                        if (fastech.connectionType == FASTECH_CONNECTION_TYPE.SERIAL)
                        {
                            break;
                        }
                    }
                }
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
            }
        }
​
        /**
        * @brief FastechObject에 연결하는 함수
        * @param[in] axisIdx AXIS_LIST 번호
        */
        public bool Connect(object axisIdx)
        {
            try
            {
                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
                return Connect(fastech);
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }
​
        /**
         * @brief FastechObject에 연결하는 함수
         * @details FastechData에 정의해두었던 port 정보 또는 IPAddress를 기반으로 연결 시도
         * @param[in] 연결을 시도할 fastech(Serial은 같이 연결된 모든 제품이 다 같이 연결된다.)
         */
        public bool Connect(FastechObject fastech)
        {
            try
            {
                bool ret = true;
                int connectRet = TRUE;
                bool bConnectRet = true;
​
                switch (fastech.connectionType)
                {
                    case FASTECH_CONNECTION_TYPE.SERIAL:
                        SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                        string strPort = GetPortString(serial.PortName);
                        byte bytePort = byte.Parse(strPort);
                        uint baudRate = Convert.ToUInt32(serial.BaudRate);
​
                        switch (fastech.axisType)
                        {
                            case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                            case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                if (!isPortConnected[bytePort])
                                {
                                    connectRet = EziMOTIONPlusRV8Lib.FAS_Connect(bytePort, baudRate);
                                }
​
                                if (connectRet != FALSE)
                                {
                                    connectRet = EziMOTIONPlusRV8Lib.FAS_IsSlaveExist(bytePort, fastech.ID);
                                }
                                break;
​
                            default:
                                if (!isPortConnected[bytePort])
                                {
                                    connectRet = EziMOTIONPlusRLib.FAS_Connect(bytePort, baudRate);
                                }
​
                                if (connectRet != FALSE)
                                {
                                    connectRet = EziMOTIONPlusRLib.FAS_IsSlaveExist(bytePort, fastech.ID);
                                }
                                break;
                        }
​
                        if (connectRet != FALSE)
                        {
                            countRetryConnect = 0;
                            isPortConnected[bytePort] = true;
                            LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Serial connection success : {serial.PortName}", CONTENT_TYPE.DEBUG);
                            ret = true;
                        }
                        else
                        {
                            countRetryConnect++;
                            isPortConnected[bytePort] = false;
                            if (countRetryConnect <= 20)
                            {
                                LogUtil.Instance.Log(LOG_TYPE.INFO, $"Serial connection fail : {serial.PortName}", CONTENT_TYPE.DEBUG);
                            }
                            ret = false;
                        }
                        break;
​
                    case FASTECH_CONNECTION_TYPE.ETHERNET:
                        IPAddress ip = (IPAddress)fastech.connectionInfo;
​
                        bConnectRet = EziMOTIONPlusELib.FAS_ConnectTCP(ip, fastech.ID);
                        if (bConnectRet != false)
                        {
                            connectRet = EziMOTIONPlusELib.FAS_IsSlaveExist(fastech.ID);
                        }
​
                        if ((bConnectRet != false) && (connectRet != FALSE))
                        {
                            countRetryConnect = 0;
                            isEthernetConnected[fastech.ID] = true;
                            LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Ethernet connection success : {ip.ToString()}", CONTENT_TYPE.DEBUG);
                            ret = true;
                        }
                        else
                        {
                            countRetryConnect++;
                            isEthernetConnected[fastech.ID] = false;
                            if (countRetryConnect <= 20)
                            {
                                LogUtil.Instance.Log(LOG_TYPE.INFO, $"Ethernet connection fail : {ip.ToString()}", CONTENT_TYPE.DEBUG);
                            }
                            ret = false;
                        }
                        break;
                }
​
                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }
​
        /**
         * @brief FastechObject에 연결하는 함수
         * @details FastechData에 정의해두었던 port 정보 또는 IPAddress를 기반으로 연결 시도
         * @param[in] 연결을 시도할 fastechObjects
         */
        public bool Connect(FastechObject[] fastechObjects)
        {
            try
            {
                bool ret = true;
                int connectRet = TRUE;
                bool bConnectRet = true;
​
                foreach (var fastech in fastechObjects)
                {
                    switch (fastech.connectionType)
                    {
                        case FASTECH_CONNECTION_TYPE.SERIAL:
                            SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                            string strPort = GetPortString(serial.PortName);
                            byte bytePort = byte.Parse(strPort);
                            uint baudRate = Convert.ToUInt32(serial.BaudRate);
​
                            switch (fastech.axisType)
                            {
                                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                    if (!isPortConnected[bytePort])
                                    {
                                        connectRet = EziMOTIONPlusRV8Lib.FAS_Connect(bytePort, baudRate);
                                    }
​
                                    if (connectRet != FALSE)
                                    {
                                        connectRet = EziMOTIONPlusRV8Lib.FAS_IsSlaveExist(bytePort, fastech.ID);
                                    }
                                    break;
​
                                default:
                                    if (!isPortConnected[bytePort])
                                    {
                                        connectRet = EziMOTIONPlusRLib.FAS_Connect(bytePort, baudRate);
                                    }
​
                                    if (connectRet != FALSE)
                                    {
                                        connectRet = EziMOTIONPlusRLib.FAS_IsSlaveExist(bytePort, fastech.ID);
                                    }
                                    break;
                            }
​
                            if (connectRet != FALSE)
                            {
                                isPortConnected[bytePort] = true;
                                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Serial connection success : {serial.PortName}", CONTENT_TYPE.DEBUG);
                                ret &= true;
                            }
                            else
                            {
                                isPortConnected[bytePort] = false;
                                LogUtil.Instance.Log(LOG_TYPE.INFO, $"Serial connection fail : {serial.PortName}", CONTENT_TYPE.DEBUG);
                                ret &= false;
                            }
                            break;
​
                        case FASTECH_CONNECTION_TYPE.ETHERNET:
                            IPAddress ip = (IPAddress)fastech.connectionInfo;
​
                            bConnectRet = EziMOTIONPlusELib.FAS_ConnectTCP(ip, fastech.ID);
                            if (bConnectRet != false)
                            {
                                connectRet = EziMOTIONPlusELib.FAS_IsSlaveExist(fastech.ID);
                            }
​
                            if ((bConnectRet != false) && (connectRet != FALSE))
                            {
                                isEthernetConnected[fastech.ID] = true;
                                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Ethernet connection success : {ip.ToString()}", CONTENT_TYPE.DEBUG);
                                ret &= true;
                            }
                            else
                            {
                                isEthernetConnected[fastech.ID] = false;
                                LogUtil.Instance.Log(LOG_TYPE.INFO, $"Ethernet connection fail : {ip.ToString()}", CONTENT_TYPE.DEBUG);
                                ret &= false;
                            }
                            break;
                    }
                }
​
                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }
​
        /**
         * @brief 모든 FastechObject에 연결하는 함수
         * @details FastechData에 정의해두었던 port 정보 또는 IPAddress를 기반으로 연결 시도
         */
        public bool Connect()
        {
            try
            {
                bool ret = true;
                int connectRet = TRUE;
                bool bConnectRet = true;
​
                foreach (var fastechObjects in listFastechObjects)
                {
                    foreach (var fastech in fastechObjects)
                    {
                        switch (fastech.connectionType)
                        {
                            case FASTECH_CONNECTION_TYPE.SERIAL:
                                SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                                string strPort = GetPortString(serial.PortName);
                                byte bytePort = byte.Parse(strPort);
                                uint baudRate = Convert.ToUInt32(serial.BaudRate);
​
                                switch (fastech.axisType)
                                {
                                    case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                                    case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                        if (!isPortConnected[bytePort])
                                        {
                                            connectRet = EziMOTIONPlusRV8Lib.FAS_Connect(bytePort, baudRate);
                                        }
​
                                        if (connectRet != FALSE)
                                        {
                                            connectRet = EziMOTIONPlusRV8Lib.FAS_IsSlaveExist(bytePort, fastech.ID);
                                        }
                                        break;
​
                                    default:
                                        if (!isPortConnected[bytePort])
                                        {
                                            connectRet = EziMOTIONPlusRLib.FAS_Connect(bytePort, baudRate);
                                        }
​
                                        if (connectRet != FALSE)
                                        {
                                            connectRet = EziMOTIONPlusRLib.FAS_IsSlaveExist(bytePort, fastech.ID);
                                        }
                                        break;
                                }
​
                                if (connectRet != FALSE)
                                {
                                    isPortConnected[bytePort] = true;
                                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Serial connection success : {serial.PortName}", CONTENT_TYPE.DEBUG);
                                    ret &= true;
                                }
                                else
                                {
                                    isPortConnected[bytePort] = false;
                                    LogUtil.Instance.Log(LOG_TYPE.INFO, $"Serial connection fail : {serial.PortName}", CONTENT_TYPE.DEBUG);
                                    ret &= false;
                                }
                                break;
​
                            case FASTECH_CONNECTION_TYPE.ETHERNET:
                                IPAddress ip = (IPAddress)fastech.connectionInfo;
​
                                bConnectRet = EziMOTIONPlusELib.FAS_ConnectTCP(ip, fastech.ID);
                                if (bConnectRet != false)
                                {
                                    connectRet = EziMOTIONPlusELib.FAS_IsSlaveExist(fastech.ID);
                                }
​
                                if ((bConnectRet != false) && (connectRet != FALSE))
                                {
                                    isEthernetConnected[fastech.ID] = true;
                                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Ethernet connection success : {ip.ToString()}", CONTENT_TYPE.DEBUG);
                                    ret &= true;
                                }
                                else
                                {
                                    isEthernetConnected[fastech.ID] = false;
                                    LogUtil.Instance.Log(LOG_TYPE.INFO, $"Ethernet connection fail : {ip.ToString()}", CONTENT_TYPE.DEBUG);
                                    ret &= false;
                                }
                                break;
                        }
                    }
                }
​
                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }
​
        /**
         * @brief 현재 축의 위치를 리턴하는 함수
         * @param[out] type slave 수 만큼 현재 포지션 정보를 할당 받을 인자
         * @return 정상적으로 수행 되었는 여부
         */
        public bool GetCurrentPos(ref object[] type)
        {
            try
            {
                foreach (KeyValuePair<AXIS_LIST, FastechObject> var in axisList)
                {
                    FastechObject fastech = var.Value;
                    if (!IsConnected(var.Key))
                    {
                        continue;
                    }
​
                    decimal scale = Convert.ToDecimal(axisParamData[(int)var.Key].resolution) / Convert.ToDecimal(axisParamData[(int)var.Key].distance);
                    type[(uint)var.Key] = Convert.ToDecimal(fastech.fastechStatus.currentPos) * Convert.ToDecimal(((decimal)1 / scale));
                }
​
                return true;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
​
        }
​
        /**
         * @brief 현재 축의 위치를 리턴하는 함수
         * @param[in] axisIdx AXIS_LIST 번호
         * @param[out] currentPos 인자로 넘어온 slave의 현재 축의 위치 mm
         * @return 정상적으로 수행 되었는 여부
         */
        public bool GetCurrentPos(object axisIdx, ref object currentPos)
        {
            try
            {
                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
                if (!IsConnected(axisIdx))
                {
                    return false;
                }
​
                decimal scale = Convert.ToDecimal(axisParamData[(int)axisIdx].resolution) / Convert.ToDecimal(axisParamData[(int)axisIdx].distance);
                //currentPos = Convert.ToDecimal(fastech.fastechStatus.currentPos) * Convert.ToDecimal(((decimal)1 / scale));
​
                /*
                 * Fix by hung96.tran
                 */
                //Nếu sv on thì Get số xung PGM phát ra, nếu SV off thì Get số xung Encoder phản hồi về.
                //Sử dụng trong trường hợp teaching bằng cách off sv kéo trục
                if (IsServoOn(axisIdx))
                {
                    currentPos = Convert.ToDecimal(fastech.fastechStatus.targetPos) * Convert.ToDecimal(((decimal)1 / scale));
                }
                else
                {
                    currentPos = Convert.ToDecimal(fastech.fastechStatus.currentPos) * Convert.ToDecimal(((decimal)1 / scale));
                }
​
                return true;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }
​
        /*
         * Add by hung96.tran
         */
        public decimal ScalePos(object axisIdx)
        {
            try
            {
                return Convert.ToDecimal(axisParamData[(int)axisIdx].resolution) / Convert.ToDecimal(axisParamData[(int)axisIdx].distance);
            }
            catch (Exception)
            {
                return 1;
            }
​
        }
​
        /**
         * @brief 현재 축의 위치를 리턴하는 함수
         * @param[in] axisIdx AXIS_LIST 번호
         * @param[out] currentPulse 인자로 넘어온 slave의 현재 축의 위치 pulse
         * @return 정상적으로 수행 되었는 여부
         */
        public bool GetCurrentPulse(object axisIdx, ref object currentPulse)
        {
            //try
            //{
            //    FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
            //    if (!IsConnected(axisIdx))
            //    {
            //        return false;
            //    }
            //    currentPulse = Convert.ToDouble(fastech.fastechStatus.currentPos);
​
            //    return true;
            //}
            //catch (Exception e)
            //{
            //    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
            //    return false;
            //}
​
            /*
             * Fix by hung96.tran
             */
            try
            {
                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
                if (!IsConnected(axisIdx))
                {
                    return false;
                }
                //Nếu sv on thì Get số xung PGM phát ra, nếu SV off thì Get số xung Encoder phản hồi về.
                //Sử dụng trong trường hợp teaching bằng cách off sv kéo trục
                if (IsServoOn(axisIdx))
                {
                    currentPulse = Convert.ToDecimal(fastech.fastechStatus.targetPos);
                }
                else
                {
                    currentPulse = Convert.ToDecimal(fastech.fastechStatus.currentPos);
                }
​
​
                return true;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }
​
        /**
         * @brief 축의 파라미터 값 읽어오는 함수
         * @param[in] servoParamFlag Fastech의 parameter flag 
         * @param[out] 모든 slave의 해당 flag의 축 파마리터 정보를 저장하는 매개변수
         * @return 정상적으로 수행 되었는 여부
         */
        public bool GetParameter(object servoParamFlag, ref object[] setValue)
        {
            try
            {
                byte flag = Convert.ToByte(servoParamFlag);
                int getValue = 0;
                bool ret = true;
                int libRet = FMM_OK;
​
                foreach (KeyValuePair<AXIS_LIST, FastechObject> var in axisList)
                {
                    FastechObject fastech = var.Value;
                    if (!IsConnected(var.Key))
                    {
                        ret &= false;
                        continue;
                    }
​
                    switch (fastech.connectionType)
                    {
                        case FASTECH_CONNECTION_TYPE.SERIAL:
                            SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                            string strPort = GetPortString(serial.PortName);
                            byte bytePort = byte.Parse(strPort);
​
                            switch (fastech.axisType)
                            {
                                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                    libRet = EziMOTIONPlusRV8Lib.FAS_GetParameter(bytePort, fastech.ID, flag, ref getValue);
                                    break;
​
                                default:
                                    libRet = EziMOTIONPlusRLib.FAS_GetParameter(bytePort, fastech.ID, flag, ref getValue);
                                    break;
                            }
​
                            if (libRet == FMM_OK)
                            {
                                setValue[(uint)var.Key] = (object)getValue;
                                ret &= true;
                            }
                            else
                            {
                                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"{var.Key} can't get parameter because of {libRet.ToString()}", CONTENT_TYPE.DEBUG);
                                ret &= false;
                            }
                            break;
​
                        case FASTECH_CONNECTION_TYPE.ETHERNET:
                            libRet = EziMOTIONPlusELib.FAS_GetParameter(fastech.ID, flag, ref getValue);
                            if (libRet == FMM_OK)
                            {
                                setValue[(uint)var.Key] = (object)getValue;
                                ret &= true;
                            }
                            else
                            {
                                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"{var.Key} can't get parameter because of {libRet.ToString()}", CONTENT_TYPE.DEBUG);
                                ret &= false;
                            }
                            break;
                    }
                }
​
                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }
​
        /**
         * @brief Fastech driver에서 사용하지 않음
         */
        public bool InitAxis()
        {
            throw new NotImplementedException();
        }
​
        /**
         * @brief Alarm 발생 체크 함수
         * @param[in] axisIdx AXIS_LIST 번호
         */
        public bool IsAlarmCheck(object axisIdx)
        {
            try
            {
                bool ret = false;
                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
​
                if ((fastech.objectType & FASTECH_OBJECT_TYPE.AXIS) != FASTECH_OBJECT_TYPE.NONE)
                {
                    if (!CheckAxisStatus(axisIdx, (uint)AXISSTATUS.FFLAG_ERRORALL))
                    {
                        ret = true;
                    }
                }
​
                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }
​
        /**
         * @brief Fastech driver에서 사용하지 않음
         */
        public bool IsInitAxis()
        {
            throw new NotImplementedException();
        }
​
        /**
         * @brief Fastech driver에서 사용하지 않음
         */
        public bool IsMoveDone()
        {
            throw new NotImplementedException();
        }
​
        /**
         * @brief 이동이 완료 되었는지 확인하는 함수
         * @param[in] axisIdx AXIS_LIST 번호
         * @return 해당 slave가 이동 완료 상태인지 여부
         */
        public bool IsMoveDone(object axisIdx)
        {
            try
            {
                bool ret = false;
                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
​
                /*if ((fastech.objectType & FASTECH_OBJECT_TYPE.AXIS) != FASTECH_OBJECT_TYPE.NONE)
                {
                    ret = (!CheckAxisStatus(axisIdx, (uint)AXISSTATUS.FFLAG_MOTIONING) && !CheckAxisStatus(axisIdx, (uint)AXISSTATUS.FFLAG_MOTIONACCEL)
                            && !CheckAxisStatus(axisIdx, (uint)AXISSTATUS.FFLAG_MOTIONCONST) && !CheckAxisStatus(axisIdx, (uint)AXISSTATUS.FFLAG_MOTIONDECEL));
                }*/
                if ((fastech.objectType & FASTECH_OBJECT_TYPE.AXIS) != FASTECH_OBJECT_TYPE.NONE)
                {
                    ret = (!CheckAxisStatus(axisIdx, (uint)AXISSTATUS.FFLAG_MOTIONING) && !CheckAxisStatus(axisIdx, (uint)AXISSTATUS.FFLAG_MOTIONACCEL)
                            && !CheckAxisStatus(axisIdx, (uint)AXISSTATUS.FFLAG_MOTIONCONST) && !CheckAxisStatus(axisIdx, (uint)AXISSTATUS.FFLAG_MOTIONDECEL)
                            && (axisParamData[(int)axisIdx].inpositionFlag ? CheckAxisStatus(axisIdx, (uint)AXISSTATUS.FFLAG_INPOSITION) : true));
                }
​
                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }
​
        /**
         * @brief 이동이 완료 되었는지 확인하는 함수
         * @param[out] ret 모든 AXIS_LIST에 대해 이동 완료 상태인지 확인 후 저장할 매개변수
         * @return 이동 완료 체크가 정상 수행되었는지 여부
         */
        public bool IsMoveDone(ref bool[] ret)
        {
            try
            {
                if (ret.Length == 0)
                {
                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, "Return parameter have to size bigger than 0", CONTENT_TYPE.DEBUG);
                    return false;
                }
​
                foreach (KeyValuePair<AXIS_LIST, FastechObject> var in axisList)
                {
                    FastechObject fastech = axisList[(AXIS_LIST)var.Key];
                    if ((fastech.objectType & FASTECH_OBJECT_TYPE.AXIS) != FASTECH_OBJECT_TYPE.NONE)
                    {
                        ret[(uint)var.Key] = (!CheckAxisStatus(var.Key, (uint)AXISSTATUS.FFLAG_MOTIONING) && !CheckAxisStatus(var.Key, (uint)AXISSTATUS.FFLAG_MOTIONACCEL)
                                    && !CheckAxisStatus(var.Key, (uint)AXISSTATUS.FFLAG_MOTIONCONST) && !CheckAxisStatus(var.Key, (uint)AXISSTATUS.FFLAG_MOTIONDECEL)
                                    && (axisParamData[(int)var.Key].inpositionFlag ? CheckAxisStatus(var.Key, (uint)AXISSTATUS.FFLAG_INPOSITION) : true));
                    }
                }
                return true;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }
​
        /**
         * @brief origin이 수행되었는지 확인하는 함수
         * @param[in] axisIdx AXIS_LIST 번호
         * @return origin 완료 여부
         */
        public bool IsOriginDone(object axisIdx)
        {
            try
            {
                bool ret = false;
                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
​
                if ((fastech.objectType & FASTECH_OBJECT_TYPE.AXIS) != FASTECH_OBJECT_TYPE.NONE)
                {
                    ret = CheckAxisStatus(axisIdx, (uint)AXISSTATUS.FFLAG_ORIGINRETOK);
                }
​
                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }
​
        /**
         * @brief Fastech driver에서 사용하지 않음
         */
        public bool IsOriginDone()
        {
            throw new NotImplementedException();
        }
​
        /**
         * @brief Servo가 켜져 있는지 확인하는 함수
         * @param[in] arg AXIS_LIST 번호
         * @return Servo 켜져 있는지 여부
         */
        public bool IsServoOn(object axisIdx)
        {
            try
            {
                bool ret = false;
                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
​
                if ((fastech.objectType & FASTECH_OBJECT_TYPE.AXIS) != FASTECH_OBJECT_TYPE.NONE)
                {
                    ret = CheckAxisStatus(axisIdx, (uint)AXISSTATUS.FFLAG_SERVOON);
                }
​
                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }
​
        /**
         * @brief 티칭용으로 조금씩 이동하는 명령을 수행하는 함수
         * @param[in] args [0] : AXIS_LIST 번호, [1] : direction
         * @return Jog Move 명령 정상 수행 여부
         */
        public bool JogMove(params object[] args)
        {
            try
            {
                bool ret = false;
                int libRet = FMM_OK;
​
                int axisIdx = Convert.ToInt32(args[(int)PARMS_ARG.SLAVE_NO]);
                double scale = Convert.ToDouble(axisParamData[(int)axisIdx].resolution) / Convert.ToDouble(axisParamData[(int)axisIdx].distance);
                bool direction = Convert.ToBoolean(args[(int)PARMS_ARG.FLAG]);
                uint vel = 0;
                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
​
                if (!IsConnected(axisIdx))
                {
                    return false;
                }
                if (args.Length == 3)
                {
                    LEVEL_SPEED speed = LEVEL_SPEED.SLOW;
                    //string speed = args[(int)PARMS_ARG.VALUE].ToString();
                    decimal nVel = 0;
​
                    if (decimal.TryParse(args[(int)PARMS_ARG.VALUE].ToString(), out nVel))
                    {
                        vel = (uint)nVel * (uint)scale;
                    }
                    else if (Enum.TryParse(args[(int)PARMS_ARG.VALUE].ToString().ToUpper(), out speed))
                    {
                        switch (speed)
                        {
                            case LEVEL_SPEED.SLOW:
                                vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_low);
                                break;
                            case LEVEL_SPEED.NORMAL:
                                vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_medium);
                                break;
                            case LEVEL_SPEED.HIGH:
                                vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                                break;
                            default:
                                vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                                break;
                        }
                    }
                    else
                    {
                        vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                    }
​
                }
                else
                {
                    vel = Convert.ToUInt32(axisParamData[(int)axisIdx].jogVel);
                }
​
                switch (fastech.connectionType)
                {
                    case FASTECH_CONNECTION_TYPE.SERIAL:
                        SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                        string strPort = GetPortString(serial.PortName);
                        byte bytePort = byte.Parse(strPort);
​
                        switch (fastech.axisType)
                        {
                            case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                            case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                libRet = EziMOTIONPlusRV8Lib.FAS_MoveVelocity(bytePort, fastech.ID, vel, (direction ? 1 : 0));
                                break;
​
                            default:
                                libRet = EziMOTIONPlusRLib.FAS_MoveVelocity(bytePort, fastech.ID, vel, (direction ? 1 : 0));
                                break;
                        }
                        break;
​
                    case FASTECH_CONNECTION_TYPE.ETHERNET:
                        libRet = EziMOTIONPlusELib.FAS_MoveVelocity(fastech.ID, vel, (direction ? 1 : 0));
                        break;
                }
​
                if (libRet == FMM_OK)
                {
                    ret = true;
                }
                else
                {
                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"(AXIS_LIST)axisIdx Can't move with jog control", CONTENT_TYPE.DEBUG);
                    ret = false;
                }
​
                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }
​
        /**
         * @brief 이동 정지 함수
         * @param[in] axisIdx AXIS_LIST 번호
         * @return 정상 수행 여부
         */
        public bool MoveStop(object axisIdx)
        {
            try
            {
                bool ret = false;
                int libRet = FMM_OK;
                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
​
                if (!IsConnected(axisIdx))
                {
                    return false;
                }
​
                switch (fastech.connectionType)
                {
                    case FASTECH_CONNECTION_TYPE.SERIAL:
                        SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                        string strPort = GetPortString(serial.PortName);
                        byte bytePort = byte.Parse(strPort);
​
                        switch (fastech.axisType)
                        {
                            case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                            case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                libRet = EziMOTIONPlusRV8Lib.FAS_MoveStop(bytePort, fastech.ID);
                                break;
​
                            default:
                                libRet = EziMOTIONPlusRLib.FAS_MoveStop(bytePort, fastech.ID);
                                break;
                        }
                        break;
​
                    case FASTECH_CONNECTION_TYPE.ETHERNET:
                        libRet = EziMOTIONPlusELib.FAS_MoveStop(fastech.ID);
                        break;
                }
​
                if (libRet == FMM_OK)
                {
                    ret = true;
                }
                else
                {
                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"{(AXIS_LIST)axisIdx} can't stop", CONTENT_TYPE.DEBUG);
                    ret = false;
                }
​
                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }
​
        /**
         * @brief AXIS_LIST에 등록 된 모든 축이동 정지 명령 함수
         * @return 정지명령 정상 수행 여부
         */
        public bool MoveStop()
        {
            try
            {
                bool ret = true;
                int libRet = FMM_OK;
​
                foreach (KeyValuePair<AXIS_LIST, FastechObject> var in axisList)
                {
                    FastechObject fastech = var.Value;
                    if (!IsConnected(var.Key))
                    {
                        ret &= false;
                        continue;
                    }
​
                    switch (fastech.connectionType)
                    {
                        case FASTECH_CONNECTION_TYPE.SERIAL:
                            SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                            string strPort = GetPortString(serial.PortName);
                            byte bytePort = byte.Parse(strPort);
​
                            switch (fastech.axisType)
                            {
                                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                    libRet = EziMOTIONPlusRV8Lib.FAS_MoveStop(bytePort, fastech.ID);
                                    break;
​
                                default:
                                    libRet = EziMOTIONPlusRLib.FAS_MoveStop(bytePort, fastech.ID);
                                    break;
                            }
                            break;
​
                        case FASTECH_CONNECTION_TYPE.ETHERNET:
                            libRet = EziMOTIONPlusELib.FAS_MoveStop(fastech.ID);
                            break;
                    }
​
                    if (libRet == FMM_OK)
                    {
                        ret &= true;
                    }
                    else
                    {
                        LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"{(AXIS_LIST)var.Key} can't stop", CONTENT_TYPE.DEBUG);
                        ret &= false;
                    }
                }
​
                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }
​
        /**
         * @brief 원하는 목적지로 이동 명령 함수
         * @param[in] args [0] : AXIS_LIST 번호, [1] : target position, [2] : velocity (optional)
         * @return 정지명령 정상 수행 여부
         */
        public bool MoveTargetPos(params object[] args)
        {
            #region Old Code
            //try
            //{
            //    bool ret = true;
            //    int libRet = FMM_OK;
            //    uint vel = 0;
​
            //    int axisIdx = Convert.ToInt32(args[(int)PARMS_ARG.SLAVE_NO]);
            //    double scale = Convert.ToDouble(axisParamData[(int)axisIdx].resolution) / Convert.ToDouble(axisParamData[(int)axisIdx].distance);
            //    int targetPos = Convert.ToInt32(Convert.ToDouble(args[(int)PARMS_ARG.FLAG]) * scale);
​
            //    if (args.Length == 3)
            //    {
            //        vel = Convert.ToUInt32(Convert.ToDouble(args[(int)PARMS_ARG.VALUE]) * scale);
            //    }
            //    else
            //    {
            //        vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel);
            //    }
​
            //    FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
            //    if (!IsConnected(axisIdx))
            //    {
            //        return false;
            //    }
​
            //    switch (fastech.connectionType)
            //    {
            //        case FASTECH_CONNECTION_TYPE.SERIAL:
            //            SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
            //            string strPort = GetPortString(serial.PortName);
            //            byte bytePort = byte.Parse(strPort);
​
            //            switch (fastech.axisType)
            //            {
            //                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
            //                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
            //                    libRet = EziMOTIONPlusRV8Lib.FAS_MoveSingleAxisAbsPos(bytePort, fastech.ID, targetPos, vel);
            //                    break;
​
            //                default:
            //                    libRet = EziMOTIONPlusRLib.FAS_MoveSingleAxisAbsPos(bytePort, fastech.ID, targetPos, vel);
            //                    break;
            //            }
            //            break;
​
            //        case FASTECH_CONNECTION_TYPE.ETHERNET:
            //            libRet = EziMOTIONPlusELib.FAS_MoveSingleAxisAbsPos(fastech.ID, targetPos, vel);
            //            break;
            //    }
​
            //    if (libRet == FMM_OK)
            //    {
            //        ret = true;
            //    }
            //    else
            //    {
            //        LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Fail to move {axisIdx} to {targetPos} because of {ret.ToString()}", CONTENT_TYPE.DEBUG);
            //        ret = false;
            //    }
​
            //    return ret;
            //}
            //catch (Exception e)
            //{
            //    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
            //    return false;
            //}
            #endregion
​
            try
            {
                bool ret = true;
                int libRet = FMM_OK;
                uint vel = 0;
​
                int axisIdx = Convert.ToInt32(args[(int)PARMS_ARG.SLAVE_NO]);
                double scale = Convert.ToDouble(axisParamData[(int)axisIdx].resolution) / Convert.ToDouble(axisParamData[(int)axisIdx].distance);
                int targetPos = Convert.ToInt32(Convert.ToDouble(args[(int)PARMS_ARG.FLAG]) * scale);
​
                if (args.Length == 3)
                {
                    LEVEL_SPEED speed = LEVEL_SPEED.SLOW;
                    //string speed = args[(int)PARMS_ARG.VALUE].ToString();
                    decimal nVel = 0;
​
                    if (decimal.TryParse(args[(int)PARMS_ARG.VALUE].ToString(), out nVel))
                    {
                        vel = (uint)(nVel * (decimal)scale);
                    }
                    else if (Enum.TryParse(args[(int)PARMS_ARG.VALUE].ToString().ToUpper(), out speed))
                    {
                        switch (speed)
                        {
                            case LEVEL_SPEED.SLOW:
                                vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_low);
                                break;
                            case LEVEL_SPEED.NORMAL:
                                vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_medium);
                                break;
                            case LEVEL_SPEED.HIGH:
                                vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                                break;
                            default:
                                vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                                break;
                        }
                    }
                    else
                    {
                        vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                    }
​
                }
                else
                {
                    vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                }
​
                //if (args.Length == 3)
                //{
                //    vel = Convert.ToUInt32(Convert.ToDouble(args[(int)PARMS_ARG.VALUE]) * scale);
                //}
                //else
                //{
                //    vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel);
                //}
​
                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
                if (!IsConnected(axisIdx))
                {
                    return false;
                }
​
                switch (fastech.connectionType)
                {
                    case FASTECH_CONNECTION_TYPE.SERIAL:
                        SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                        string strPort = GetPortString(serial.PortName);
                        byte bytePort = byte.Parse(strPort);
​
                        switch (fastech.axisType)
                        {
                            case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                            case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                libRet = EziMOTIONPlusRV8Lib.FAS_MoveSingleAxisAbsPos(bytePort, fastech.ID, targetPos, vel);
                                break;
​
                            default:
                                libRet = EziMOTIONPlusRLib.FAS_MoveSingleAxisAbsPos(bytePort, fastech.ID, targetPos, vel);
                                break;
                        }
                        break;
​
                    case FASTECH_CONNECTION_TYPE.ETHERNET:
                        libRet = EziMOTIONPlusELib.FAS_MoveSingleAxisAbsPos(fastech.ID, targetPos, vel);
                        break;
                }
​
                if (libRet == FMM_OK)
                {
                    ret = true;
                }
                else
                {
                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Fail to move {axisIdx} to {targetPos} because of {ret.ToString()}", CONTENT_TYPE.DEBUG);
                    ret = false;
                }
​
                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }
        public bool MoveTargetPosInc(params object[] args)
        {
            #region Old Code
            //try
            //{
            //    bool ret = true;
            //    int libRet = FMM_OK;
            //    uint vel = 0;
​
            //    int axisIdx = Convert.ToInt32(args[(int)PARMS_ARG.SLAVE_NO]);
            //    double scale = Convert.ToDouble(axisParamData[(int)axisIdx].resolution) / Convert.ToDouble(axisParamData[(int)axisIdx].distance);
            //    int targetPos = Convert.ToInt32(Convert.ToDouble(args[(int)PARMS_ARG.FLAG]) * scale);
​
            //    if (args.Length == 3)
            //    {
            //        vel = Convert.ToUInt32(Convert.ToDouble(args[(int)PARMS_ARG.VALUE]) * scale);
            //    }
            //    else
            //    {
            //        vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel);
            //    }
​
            //    FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
            //    if (!IsConnected(axisIdx))
            //    {
            //        return false;
            //    }
​
            //    switch (fastech.connectionType)
            //    {
            //        case FASTECH_CONNECTION_TYPE.SERIAL:
            //            SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
            //            string strPort = GetPortString(serial.PortName);
            //            byte bytePort = byte.Parse(strPort);
​
            //            switch (fastech.axisType)
            //            {
            //                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
            //                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
            //                    libRet = EziMOTIONPlusRV8Lib.FAS_MoveSingleAxisAbsPos(bytePort, fastech.ID, targetPos, vel);
            //                    break;
​
            //                default:
            //                    libRet = EziMOTIONPlusRLib.FAS_MoveSingleAxisAbsPos(bytePort, fastech.ID, targetPos, vel);
            //                    break;
            //            }
            //            break;
​
            //        case FASTECH_CONNECTION_TYPE.ETHERNET:
            //            libRet = EziMOTIONPlusELib.FAS_MoveSingleAxisAbsPos(fastech.ID, targetPos, vel);
            //            break;
            //    }
​
            //    if (libRet == FMM_OK)
            //    {
            //        ret = true;
            //    }
            //    else
            //    {
            //        LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Fail to move {axisIdx} to {targetPos} because of {ret.ToString()}", CONTENT_TYPE.DEBUG);
            //        ret = false;
            //    }
​
            //    return ret;
            //}
            //catch (Exception e)
            //{
            //    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
            //    return false;
            //}
            #endregion
​
            try
            {
                bool ret = true;
                int libRet = FMM_OK;
                uint vel = 0;
​
                int axisIdx = Convert.ToInt32(args[(int)PARMS_ARG.SLAVE_NO]);
                double scale = Convert.ToDouble(axisParamData[(int)axisIdx].resolution) / Convert.ToDouble(axisParamData[(int)axisIdx].distance);
                int targetPos = Convert.ToInt32(Convert.ToDouble(args[(int)PARMS_ARG.FLAG]) * scale);
​
                if (args.Length == 3)
                {
                    LEVEL_SPEED speed = LEVEL_SPEED.SLOW;
                    //string speed = args[(int)PARMS_ARG.VALUE].ToString();
                    decimal nVel = 0;
​
                    if (decimal.TryParse(args[(int)PARMS_ARG.VALUE].ToString(), out nVel))
                    {
                        vel = (uint)nVel * (uint)scale;
                    }
                    else if (Enum.TryParse(args[(int)PARMS_ARG.VALUE].ToString().ToUpper(), out speed))
                    {
                        switch (speed)
                        {
                            case LEVEL_SPEED.SLOW:
                                vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_low);
                                break;
                            case LEVEL_SPEED.NORMAL:
                                vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_medium);
                                break;
                            case LEVEL_SPEED.HIGH:
                                vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                                break;
                            default:
                                vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                                break;
                        }
                    }
                    else
                    {
                        vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                    }
​
                }
                else
                {
                    vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                }
​
                //if (args.Length == 3)
                //{
                //    vel = Convert.ToUInt32(Convert.ToDouble(args[(int)PARMS_ARG.VALUE]) * scale);
                //}
                //else
                //{
                //    vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel);
                //}
​
                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
                if (!IsConnected(axisIdx))
                {
                    return false;
                }
​
                switch (fastech.connectionType)
                {
                    //case FASTECH_CONNECTION_TYPE.SERIAL:
                    //    SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                    //    string strPort = GetPortString(serial.PortName);
                    //    byte bytePort = byte.Parse(strPort);
​
                    //    switch (fastech.axisType)
                    //    {
                    //        case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                    //        case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                    //            libRet = EziMOTIONPlusRV8Lib.FAS_MoveSingleAxisAbsPos(bytePort, fastech.ID, targetPos, vel);
                    //            break;
​
                    //        default:
                    //            libRet = EziMOTIONPlusRLib.FAS_MoveSingleAxisAbsPos(bytePort, fastech.ID, targetPos, vel);
                    //            break;
                    //    }
                    //    break;
​
                    case FASTECH_CONNECTION_TYPE.ETHERNET:
                        libRet = EziMOTIONPlusELib.FAS_MoveSingleAxisIncPos(fastech.ID, targetPos, vel);
                        break;
                }
​
                if (libRet == FMM_OK)
                {
                    ret = true;
                }
                else
                {
                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Fail to move {axisIdx} to {targetPos} because of {ret.ToString()}", CONTENT_TYPE.DEBUG);
                    ret = false;
                }
​
                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }
​
        public bool MoveTargetPos_Interpolation(object[] axisLinear, decimal[] lplAbsPos, params object[] args)
        {
            try
            {
                if (axisLinear is null || lplAbsPos is null) return false;
                if (axisLinear.Length < 2 || lplAbsPos.Length < 2) return false;
​
                bool ret = true;
                int libRet = FMM_OK;
                uint vel = 0;
​
                int axisIdx = Convert.ToInt32(axisLinear[0]);
                double scale = Convert.ToDouble(axisParamData[(int)axisIdx].resolution) / Convert.ToDouble(axisParamData[(int)axisIdx].distance);
                int[] targetPos = new int[lplAbsPos.Length];
                for (int i = 0; i < targetPos.Length; i++)
                {
                    double scaleIdx = Convert.ToDouble(axisParamData[Convert.ToInt32(axisLinear[i])].resolution) / Convert.ToDouble(axisParamData[Convert.ToInt32(axisLinear[i])].distance);
                    targetPos[i] = Convert.ToInt32(Convert.ToDouble(lplAbsPos[i]) * scaleIdx);
                }
​
                if (args.Length == 3)
                {
                    LEVEL_SPEED speed = LEVEL_SPEED.SLOW;
                    //string speed = args[(int)PARMS_ARG.VALUE].ToString();
                    decimal nVel = 0;
​
                    if (decimal.TryParse(args[(int)PARMS_ARG.VALUE].ToString(), out nVel))
                    {
                        vel = (uint)nVel * (uint)scale;
                    }
                    else if (Enum.TryParse(args[(int)PARMS_ARG.VALUE].ToString().ToUpper(), out speed))
                    {
                        switch (speed)
                        {
                            case LEVEL_SPEED.SLOW:
                                vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_low);
                                break;
                            case LEVEL_SPEED.NORMAL:
                                vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_medium);
                                break;
                            case LEVEL_SPEED.HIGH:
                                vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                                break;
                            default:
                                vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                                break;
                        }
                    }
                    else
                    {
                        vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                    }
​
                }
                else
                {
                    vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                }
​
                //if (args.Length == 3)
                //{
                //    vel = Convert.ToUInt32(Convert.ToDouble(args[(int)PARMS_ARG.VALUE]) * scale);
                //}
                //else
                //{
                //    vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel);
                //}
​
                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
                if (!IsConnected(axisIdx))
                {
                    return false;
                }
​
                switch (fastech.connectionType)
                {
                    case FASTECH_CONNECTION_TYPE.SERIAL:
                        SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                        string strPort = GetPortString(serial.PortName);
                        byte bytePort = byte.Parse(strPort);
                        byte[] iID_R = new byte[axisLinear.Length];
                        for (int i = 0; i < axisLinear.Length; i++)
                        {
                            iID_R[i] = (byte)axisList[(AXIS_LIST)(int.Parse(axisLinear[i].ToString()))].ID;
                        }
                        switch (fastech.axisType)
                        {
                            case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                            case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                libRet = EziMOTIONPlusRV8Lib.FAS_MoveLinearAbsPos(bytePort, (byte)iID_R.Length, iID_R, targetPos, vel, ushort.Parse(axisParamData[(int)axisIdx].acc.ToString()));
                                break;
​
                            default:
                                libRet = EziMOTIONPlusRV8Lib.FAS_MoveLinearAbsPos(bytePort, (byte)iID_R.Length, iID_R, targetPos, vel, ushort.Parse(axisParamData[(int)axisIdx].acc.ToString()));
                                break;
                        }
                        break;
​
                    case FASTECH_CONNECTION_TYPE.ETHERNET:
                        int[] iID_E = new int[axisLinear.Length];
                        for (int i = 0; i < axisLinear.Length; i++)
                        {
                            int idx = Convert.ToInt32(axisLinear[i]);
                            iID_E[i] = (int)axisList[(AXIS_LIST)(idx)].ID;
                        }
                        libRet = EziMOTIONPlusELib.FAS_MoveLinearAbsPos2((byte)iID_E.Length, iID_E, targetPos, vel, ushort.Parse(axisParamData[(int)axisIdx].acc.ToString()));
                        break;
                }
​
                if (libRet == FMM_OK)
                {
                    ret = true;
                }
                else
                {
                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Fail to move {axisIdx} to {targetPos} because of {ret.ToString()}", CONTENT_TYPE.DEBUG);
                    ret = false;
                }
​
                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }
​
        public bool MoveTargetPosInc_Interpolation(object[] axisLinear, decimal[] lplIncPos, params object[] args)
        {
            try
            {
                if (axisLinear is null || lplIncPos is null) return false;
                if (axisLinear.Length < 2 || lplIncPos.Length < 2) return false;
​
                bool ret = true;
                int libRet = FMM_OK;
                uint vel = 0;
​
                int axisIdx = Convert.ToInt32(axisLinear[0]);
                double scale = Convert.ToDouble(axisParamData[(int)axisIdx].resolution) / Convert.ToDouble(axisParamData[(int)axisIdx].distance);
                int[] targetPos = new int[lplIncPos.Length];
                for (int i = 0; i < targetPos.Length; i++)
                {
                    targetPos[i] = Convert.ToInt32(Convert.ToDouble(lplIncPos[i]) * scale);
                }
​
                if (args.Length == 3)
                {
                    LEVEL_SPEED speed = LEVEL_SPEED.SLOW;
                    //string speed = args[(int)PARMS_ARG.VALUE].ToString();
                    decimal nVel = 0;
​
                    if (decimal.TryParse(args[(int)PARMS_ARG.VALUE].ToString(), out nVel))
                    {
                        vel = (uint)nVel * (uint)scale;
                    }
                    else if (Enum.TryParse(args[(int)PARMS_ARG.VALUE].ToString().ToUpper(), out speed))
                    {
                        switch (speed)
                        {
                            case LEVEL_SPEED.SLOW:
                                vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_low);
                                break;
                            case LEVEL_SPEED.NORMAL:
                                vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_medium);
                                break;
                            case LEVEL_SPEED.HIGH:
                                vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                                break;
                            default:
                                vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                                break;
                        }
                    }
                    else
                    {
                        vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                    }
​
                }
                else
                {
                    vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                }
​
                //if (args.Length == 3)
                //{
                //    vel = Convert.ToUInt32(Convert.ToDouble(args[(int)PARMS_ARG.VALUE]) * scale);
                //}
                //else
                //{
                //    vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel);
                //}
​
                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
                if (!IsConnected(axisIdx))
                {
                    return false;
                }
​
                switch (fastech.connectionType)
                {
                    //case FASTECH_CONNECTION_TYPE.SERIAL:
                    //    SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                    //    string strPort = GetPortString(serial.PortName);
                    //    byte bytePort = byte.Parse(strPort);
​
                    //    switch (fastech.axisType)
                    //    {
                    //        case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                    //        case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                    //            libRet = EziMOTIONPlusRV8Lib.FAS_MoveSingleAxisAbsPos(bytePort, fastech.ID, targetPos, vel);
                    //            break;
​
                    //        default:
                    //            libRet = EziMOTIONPlusRLib.FAS_MoveSingleAxisAbsPos(bytePort, fastech.ID, targetPos, vel);
                    //            break;
                    //    }
                    //    break;
​
                    case FASTECH_CONNECTION_TYPE.ETHERNET:
                        int[] iID_E = new int[axisLinear.Length];
                        for (int i = 0; i < axisLinear.Length; i++)
                        {
                            iID_E[i] = (int)axisLinear[i];
                        }
                        libRet = EziMOTIONPlusELib.FAS_MoveLinearIncPos2(fastech.ID, iID_E, targetPos, vel, ushort.Parse(axisParamData[(int)axisIdx].acc.ToString()));
                        break;
                }
​
                if (libRet == FMM_OK)
                {
                    ret = true;
                }
                else
                {
                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Fail to move {axisIdx} to {targetPos} because of {ret.ToString()}", CONTENT_TYPE.DEBUG);
                    ret = false;
                }
​
                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }
​
        /*
         * Add by hung96.tran
         * PARMS_ARG.VALUE = true: Run LowSpeed,
         * PARMS_ARG.VALUE = false or Not set: Run HighSpeed
         * PARMS_ARG.VALUE = 12345: Run with value input
         */
        public bool MoveTargetPulse(params object[] args)
        {
            try
            {
                bool ret = true;
                int libRet = FMM_OK;
                uint vel = 0;
​
                int axisIdx = Convert.ToInt32(args[(int)PARMS_ARG.SLAVE_NO]);
                double scale = Convert.ToDouble(axisParamData[(int)axisIdx].resolution) / Convert.ToDouble(axisParamData[(int)axisIdx].distance);
                int targetPos = Convert.ToInt32(Convert.ToDouble(args[(int)PARMS_ARG.FLAG]));
​
                if (args.Length == 3)
                {
                    string speed = args[(int)PARMS_ARG.VALUE].ToString();
                    //uint nVel = 0;
​
                    switch (speed)
                    {
                        case "SLOW":
                            vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_low);
                            break;
                        case "NORMAL":
                            vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_medium);
                            break;
                        case "HIGH":
                            vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                            break;
                        default:
                            vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_low);
                            break;
                    }
                    //bool bVel_low = false;
                    //uint nVel = 0;
                    //if (bool.TryParse(args[(int)PARMS_ARG.VALUE].ToString(), out bVel_low))
                    //{
                    //    if (Convert.ToBoolean(args[(int)PARMS_ARG.VALUE]))
                    //    {
                    //        vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_low);
                    //    }
                    //    else
                    //    {
                    //        vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                    //    }
                    //}
                    //else if (uint.TryParse(args[(int)PARMS_ARG.VALUE].ToString(), out nVel))
                    //{
                    //    vel = nVel * (uint)scale;
                    //}
                    //else
                    //{
                    //    vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                    //}
​
                }
                else
                {
                    vel = Convert.ToUInt32(axisParamData[(int)axisIdx].vel_high);
                }
​
                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
                if (!IsConnected(axisIdx))
                {
                    return false;
                }
​
                switch (fastech.connectionType)
                {
                    case FASTECH_CONNECTION_TYPE.SERIAL:
                        SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                        string strPort = GetPortString(serial.PortName);
                        byte bytePort = byte.Parse(strPort);
​
                        switch (fastech.axisType)
                        {
                            case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                            case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                libRet = EziMOTIONPlusRV8Lib.FAS_MoveSingleAxisAbsPos(bytePort, fastech.ID, targetPos, vel);
                                break;
​
                            default:
                                libRet = EziMOTIONPlusRLib.FAS_MoveSingleAxisAbsPos(bytePort, fastech.ID, targetPos, vel);
                                break;
                        }
                        break;
​
                    case FASTECH_CONNECTION_TYPE.ETHERNET:
                        libRet = EziMOTIONPlusELib.FAS_MoveSingleAxisAbsPos(fastech.ID, targetPos, vel);
                        break;
                }
​
                if (libRet == FMM_OK)
                {
                    ret = true;
                }
                else
                {
                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Fail to move {axisIdx} to {targetPos} because of {ret.ToString()}", CONTENT_TYPE.DEBUG);
                    ret = false;
                }
​
                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }
​
​
        /**
         * @brief Origin 이동 함수
         * @param[in] axisIdx AXIS_LIST 번호
         * @return Origin 명령 정상 수행 여부
         */
        public bool MoveToOrigin(object axisIdx)
        {
            try
            {
                bool ret = true;
                int libRet = FMM_OK;
​
                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
                if (!IsConnected(axisIdx))
                {
                    return false;
                }
​
                switch (fastech.connectionType)
                {
                    case FASTECH_CONNECTION_TYPE.SERIAL:
                        SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                        string strPort = GetPortString(serial.PortName);
                        byte bytePort = byte.Parse(strPort);
​
                        switch (fastech.axisType)
                        {
                            case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                            case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                libRet = EziMOTIONPlusRV8Lib.FAS_MoveOriginSingleAxis(bytePort, fastech.ID);
                                break;
​
                            default:
                                libRet = EziMOTIONPlusRLib.FAS_MoveOriginSingleAxis(bytePort, fastech.ID);
                                break;
                        }
                        break;
​
                    case FASTECH_CONNECTION_TYPE.ETHERNET:
                        libRet = EziMOTIONPlusELib.FAS_MoveOriginSingleAxis(fastech.ID);
                        break;
                }
​
                if (libRet == FMM_OK)
                {
                    ret = true;
                }
                else
                {
                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Fail to move {axisIdx} to Origin because of {ret.ToString()}", CONTENT_TYPE.DEBUG);
                    ret = false;
                }
​
                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }
​
        /**
         * @brief Origin 이동 함수
         * @details 모든 축 origin 이동
         * @return Origin 명령 정상 수행 여부
         */
        public bool MoveToOrigin()
        {
            try
            {
                bool ret = true;
                int libRet = FMM_OK;
​
                foreach (KeyValuePair<AXIS_LIST, FastechObject> var in axisList)
                {
                    FastechObject fastech = var.Value;
                    if (!IsConnected(var.Key))
                    {
                        ret &= false;
                        continue;
                    }
​
                    switch (fastech.connectionType)
                    {
                        case FASTECH_CONNECTION_TYPE.SERIAL:
                            SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                            string strPort = GetPortString(serial.PortName);
                            byte bytePort = byte.Parse(strPort);
​
                            switch (fastech.axisType)
                            {
                                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                    libRet = EziMOTIONPlusRV8Lib.FAS_MoveOriginSingleAxis(bytePort, fastech.ID);
                                    break;
​
                                default:
                                    libRet = EziMOTIONPlusRLib.FAS_MoveOriginSingleAxis(bytePort, fastech.ID);
                                    break;
                            }
​
                            if (libRet == FMM_OK)
                            {
                                ret &= true;
                            }
                            else
                            {
                                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Fail to move {var.Key} to Origin because of {libRet.ToString()}", CONTENT_TYPE.DEBUG);
                                ret &= false;
                            }
                            break;
​
                        case FASTECH_CONNECTION_TYPE.ETHERNET:
                            libRet = EziMOTIONPlusELib.FAS_MoveOriginSingleAxis(fastech.ID);
                            if (libRet == FMM_OK)
                            {
                                ret &= true;
                            }
                            else
                            {
                                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Fail to move {var.Key} to Origin because of {libRet.ToString()}", CONTENT_TYPE.DEBUG);
                                ret &= false;
                            }
                            break;
                    }
                }
​
                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }
​
        /**
         * @brief Alarm clear 함수
         * @param[in] axisIdx AXIS_LIST 번호
         * @return Alarm clear 명령 정상 수행 여부
         */
        public bool ResetServoAlarm(object axisIdx = null)
        {
            try
            {
                bool ret = true;
                int libRet = FMM_OK;
​
                if (axisIdx == null)
                {
                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, "Axis index is null", CONTENT_TYPE.DEBUG);
                    return false;
                }
​
                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
                if (!IsConnected(axisIdx))
                {
                    return false;
                }
​
                switch (fastech.connectionType)
                {
                    case FASTECH_CONNECTION_TYPE.SERIAL:
                        SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                        string strPort = GetPortString(serial.PortName);
                        byte bytePort = byte.Parse(strPort);
​
                        switch (fastech.axisType)
                        {
                            case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                            case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                libRet = EziMOTIONPlusRV8Lib.FAS_ServoAlarmReset(bytePort, fastech.ID);
                                break;
​
                            default:
                                libRet = EziMOTIONPlusRLib.FAS_ServoAlarmReset(bytePort, fastech.ID);
                                break;
                        }
                        break;
​
                    case FASTECH_CONNECTION_TYPE.ETHERNET:
                        libRet = EziMOTIONPlusELib.FAS_ServoAlarmReset(fastech.ID);
                        break;
                }
​
                if (libRet == FMM_OK)
                {
                    ret = true;
                }
                else
                {
                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Fail to reset {(AXIS_LIST)axisIdx} servo alarm because of {libRet.ToString()}", CONTENT_TYPE.DEBUG);
                    ret = false;
                }
​
                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }
​
        /**
         * @brief Alarm clear 함수
         * @details 모든 축 alarm clear 
         * @return Alarm clear 명령 정상 수행 여부
         */
        public bool ResetServoAlarm()
        {
            try
            {
                bool ret = true;
                int libRet = FMM_OK;
​
                foreach (KeyValuePair<AXIS_LIST, FastechObject> var in axisList)
                {
                    FastechObject fastech = var.Value;
                    if (!IsConnected(var.Key))
                    {
                        continue;
                    }
​
                    switch (fastech.connectionType)
                    {
                        case FASTECH_CONNECTION_TYPE.SERIAL:
                            SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                            string strPort = GetPortString(serial.PortName);
                            byte bytePort = byte.Parse(strPort);
​
                            switch (fastech.axisType)
                            {
                                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                    libRet = EziMOTIONPlusRV8Lib.FAS_ServoAlarmReset(bytePort, fastech.ID);
                                    break;
​
                                default:
                                    libRet = EziMOTIONPlusRLib.FAS_ServoAlarmReset(bytePort, fastech.ID);
                                    break;
                            }
                            break;
​
                        case FASTECH_CONNECTION_TYPE.ETHERNET:
                            libRet = EziMOTIONPlusELib.FAS_ServoAlarmReset(fastech.ID);
                            break;
                    }
​
                    if (libRet == FMM_OK)
                    {
                        ret &= true;
                    }
                    else
                    {
                        LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Fail to reset {(AXIS_LIST)var.Key} servo alarm because of {libRet.ToString()}", CONTENT_TYPE.DEBUG);
                        ret &= false;
                    }
                }
​
                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }
​
        /**
         * @brief Servo off 함수
         * @param[in] axisIdx AXIS_LIST 번호
         * @return Servo off 명령 정상 수행 여부
         */
        public bool ServoOff(object axisIdx)
        {
            try
            {
                bool ret = true;
                int libRet = FMM_OK;
​
                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
                if (!IsConnected(axisIdx))
                {
                    return false;
                }
​
                switch (fastech.connectionType)
                {
                    case FASTECH_CONNECTION_TYPE.SERIAL:
                        SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                        string strPort = GetPortString(serial.PortName);
                        byte bytePort = byte.Parse(strPort);
​
                        switch (fastech.axisType)
                        {
                            case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                            case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                libRet = EziMOTIONPlusRV8Lib.FAS_ServoEnable(bytePort, fastech.ID, FALSE);
                                break;
​
                            default:
                                libRet = EziMOTIONPlusRLib.FAS_ServoEnable(bytePort, fastech.ID, FALSE);
                                break;
                        }
                        break;
​
                    case FASTECH_CONNECTION_TYPE.ETHERNET:
                        libRet = EziMOTIONPlusELib.FAS_ServoEnable(fastech.ID, FALSE);
                        break;
                }
​
                if (libRet == FMM_OK)
                {
                    ret = true;
                }
                else
                {
                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Fail to turn off {(AXIS_LIST)axisIdx} servo because of {libRet.ToString()}", CONTENT_TYPE.DEBUG);
                    ret = false;
                }
​
                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }
​
        /**
         * @brief Servo off 함수
         * @details 모든 축 servo off 수행
         * @return Servo off 명령 정상 수행 여부
         */
        public bool ServoOff()
        {
            try
            {
                bool ret = true;
                int libRet = FMM_OK;
​
                foreach (KeyValuePair<AXIS_LIST, FastechObject> var in axisList)
                {
                    FastechObject fastech = var.Value;
                    if (!IsConnected(var.Key))
                    {
                        continue;
                    }
​
                    switch (fastech.connectionType)
                    {
                        case FASTECH_CONNECTION_TYPE.SERIAL:
                            SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                            string strPort = GetPortString(serial.PortName);
                            byte bytePort = byte.Parse(strPort);
​
                            switch (fastech.axisType)
                            {
                                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                    libRet = EziMOTIONPlusRV8Lib.FAS_ServoEnable(bytePort, fastech.ID, FALSE);
                                    break;
​
                                default:
                                    libRet = EziMOTIONPlusRLib.FAS_ServoEnable(bytePort, fastech.ID, FALSE);
                                    break;
                            }
                            break;
​
                        case FASTECH_CONNECTION_TYPE.ETHERNET:
                            libRet = EziMOTIONPlusELib.FAS_ServoEnable(fastech.ID, FALSE);
                            break;
                    }
​
                    if (libRet == FMM_OK)
                    {
                        ret &= true;
                    }
                    else
                    {
                        LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Fail to turn off {(AXIS_LIST)var.Key} servo because of {libRet.ToString()}", CONTENT_TYPE.DEBUG);
                        ret &= false;
                    }
                }
​
                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }
​
        /**
         * @brief Servo on 함수
         * @param[in] axisIdx AXIS_LIST 번호
         * @return Servo on 명령 정상 수행 여부
         */
        public bool ServoOn(object axisIdx)
        {
            try
            {
                bool ret = true;
                int libRet = FMM_OK;
​
                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
                if (!IsConnected(axisIdx))
                {
                    return false;
                }
​
                switch (fastech.connectionType)
                {
                    case FASTECH_CONNECTION_TYPE.SERIAL:
                        SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                        string strPort = GetPortString(serial.PortName);
                        byte bytePort = byte.Parse(strPort);
​
                        switch (fastech.axisType)
                        {
                            case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                            case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                libRet = EziMOTIONPlusRV8Lib.FAS_ServoEnable(bytePort, fastech.ID, TRUE);
                                break;
​
                            default:
                                libRet = EziMOTIONPlusRLib.FAS_ServoEnable(bytePort, fastech.ID, TRUE);
                                break;
                        }
                        break;
​
                    case FASTECH_CONNECTION_TYPE.ETHERNET:
                        libRet = EziMOTIONPlusELib.FAS_ServoEnable(fastech.ID, TRUE);
                        libRet = EziMOTIONPlusELib.FAS_SetCommandPos(fastech.ID, fastech.fastechStatus.currentPos);
                        break;
                }
​
                if (libRet == FMM_OK)
                {
                    ret = true;
                }
                else
                {
                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Fail to turn on {(AXIS_LIST)axisIdx} servo because of {libRet.ToString()}", CONTENT_TYPE.DEBUG);
                    ret = false;
                }
​
                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }
​
        /**
         * @brief Servo on 함수
         * @details 모든 축 servo on 수행
         * @return Servo on 명령 정상 수행 여부
         */
        public bool ServoOn()
        {
            try
            {
                bool ret = true;
                int libRet = FMM_OK;
​
                foreach (KeyValuePair<AXIS_LIST, FastechObject> var in axisList)
                {
                    FastechObject fastech = var.Value;
                    if (!IsConnected(var.Key))
                    {
                        continue;
                    }
​
                    switch (fastech.connectionType)
                    {
                        case FASTECH_CONNECTION_TYPE.SERIAL:
                            SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                            string strPort = GetPortString(serial.PortName);
                            byte bytePort = byte.Parse(strPort);
​
                            switch (fastech.axisType)
                            {
                                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                    libRet = EziMOTIONPlusRV8Lib.FAS_ServoEnable(bytePort, fastech.ID, TRUE);
                                    break;
​
                                default:
                                    libRet = EziMOTIONPlusRLib.FAS_ServoEnable(bytePort, fastech.ID, TRUE);
                                    break;
                            }
                            break;
​
                        case FASTECH_CONNECTION_TYPE.ETHERNET:
                            libRet = EziMOTIONPlusELib.FAS_ServoEnable(fastech.ID, TRUE);
                            break;
                    }
​
                    if (libRet == FMM_OK)
                    {
                        ret &= true;
                    }
                    else
                    {
                        LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Fail to turn on {(AXIS_LIST)var.Key} servo because of {libRet.ToString()}", CONTENT_TYPE.DEBUG);
                        ret &= false;
                    }
                }
​
                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }
​
        /**
         * @brief Axis에 사용될 속도 관련 파라미터 저장 함수
         * @param[in] [0]:axisIdx AXIS_LIST 번호, [1]: AxisParamData
         */
        public bool SetAxisParams(object axisIdx, object data)
        {
            try
            {
                bool ret = true;
                int libRet = FMM_OK;
​
                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
                /*
                if (!IsConnected(axisIdx))
                {
                    return false;
                }
                */
​
                if (axisParamData[(int)axisIdx] is null)
                {
                    axisParamData[(int)axisIdx] = new AxisParamData();
                }
                axisParamData[(int)axisIdx].resolution = ((AxisParamData)data).resolution;
                axisParamData[(int)axisIdx].distance = ((AxisParamData)data).distance;
                axisParamData[(int)axisIdx].vel_high = ((AxisParamData)data).vel_high;
                axisParamData[(int)axisIdx].vel_medium = ((AxisParamData)data).vel_medium;
                axisParamData[(int)axisIdx].vel_low = ((AxisParamData)data).vel_low;
                axisParamData[(int)axisIdx].acc = ((AxisParamData)data).acc;
                axisParamData[(int)axisIdx].dec = ((AxisParamData)data).dec;
                axisParamData[(int)axisIdx].jogVel = ((AxisParamData)data).jogVel;
                axisParamData[(int)axisIdx].jogAcc = ((AxisParamData)data).jogAcc;
                axisParamData[(int)axisIdx].jogDec = ((AxisParamData)data).jogDec;
                axisParamData[(int)axisIdx].oriVel = ((AxisParamData)data).oriVel;
                axisParamData[(int)axisIdx].oriDec = ((AxisParamData)data).oriDec;
                axisParamData[(int)axisIdx].oriReturn = ((AxisParamData)data).oriReturn;
                axisParamData[(int)axisIdx].inpositionFlag = ((AxisParamData)data).inpositionFlag;
​
                if (axisParamData[(int)axisIdx].resolution is null || axisParamData[(int)axisIdx].distance is null)
                {
                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, "Please assign gear ratio data", CONTENT_TYPE.ERROR);
                    return false;
                }
                double scale = Convert.ToDouble(axisParamData[(int)axisIdx].resolution) / Convert.ToDouble(axisParamData[(int)axisIdx].distance);
​
                axisParamData[(int)axisIdx].vel_high = Convert.ToDouble(axisParamData[(int)axisIdx].vel_high) * scale;
                axisParamData[(int)axisIdx].vel_medium = Convert.ToDouble(axisParamData[(int)axisIdx].vel_medium) * scale;
                axisParamData[(int)axisIdx].vel_low = Convert.ToDouble(axisParamData[(int)axisIdx].vel_low) * scale;
                axisParamData[(int)axisIdx].jogVel = Convert.ToDouble(axisParamData[(int)axisIdx].jogVel) * scale;
                axisParamData[(int)axisIdx].oriVel = Convert.ToDouble(axisParamData[(int)axisIdx].oriVel) * scale;
​
                int accTime = Convert.ToInt32(axisParamData[(int)axisIdx].acc);
                int decTime = Convert.ToInt32(axisParamData[(int)axisIdx].dec);
​
                int jogVelocity = Convert.ToInt32(axisParamData[(int)axisIdx].jogVel);
                int jogAccDecTime = Convert.ToInt32(axisParamData[(int)axisIdx].jogAcc);
​
                int originVelocity = Convert.ToInt32(axisParamData[(int)axisIdx].oriVel);
                int originAccDecTime = Convert.ToInt32(axisParamData[(int)axisIdx].oriAcc);
​
                switch (fastech.connectionType)
                {
                    case FASTECH_CONNECTION_TYPE.SERIAL:
                        SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                        string strPort = GetPortString(serial.PortName);
                        byte bytePort = byte.Parse(strPort);
​
                        switch (fastech.axisType)
                        {
                            case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V6:
                                libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVO_PARAM.SERVO_AXISACCTIME, accTime);
                                libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVO_PARAM.SERVO_AXISDECTIME, decTime);
​
                                libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVO_PARAM.SERVO_JOGSPEED, jogVelocity);
                                libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVO_PARAM.SERVO_JOGACCDECTIME, jogAccDecTime);
​
                                libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVO_PARAM.SERVO_ORGSPEED, originVelocity);
                                libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVO_PARAM.SERVO_ORGACCDECTIME, originAccDecTime);
                                break;
​
                            case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                                libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVOV8_PARAM.SERVO_AXISACCTIME, accTime);
                                libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVOV8_PARAM.SERVO_AXISDECTIME, decTime);
​
                                libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVOV8_PARAM.SERVO_JOGSPEED, jogVelocity);
                                libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVOV8_PARAM.SERVO_JOGACCDECTIME, jogAccDecTime);
​
                                libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVOV8_PARAM.SERVO_ORGSPEED, originVelocity);
                                libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVOV8_PARAM.SERVO_ORGACCDECTIME, originAccDecTime);
                                break;
​
                            case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V6:
                                libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINK_PARAM.MOTIONLINK_AXISACCTIME, accTime);
                                libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINK_PARAM.MOTIONLINK_AXISDECTIME, decTime);
​
                                libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINK_PARAM.MOTIONLINK_JOGSPEED, jogVelocity);
                                libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINK_PARAM.MOTIONLINK_JOGACCDECTIME, jogAccDecTime);
​
                                libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINK_PARAM.MOTIONLINK_ORGSPEED, originVelocity);
                                libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINK_PARAM.MOTIONLINK_ORGACCDECTIME, originAccDecTime);
                                break;
​
                            case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINKV8_PARAM.MOTIONLINK_AXISACCTIME, accTime);
                                libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINKV8_PARAM.MOTIONLINK_AXISDECTIME, decTime);
​
                                libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINKV8_PARAM.MOTIONLINK_JOGSPEED, jogVelocity);
                                libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINKV8_PARAM.MOTIONLINK_JOGACCDECTIME, jogAccDecTime);
​
                                libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINKV8_PARAM.MOTIONLINK_ORGSPEED, originVelocity);
                                libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINKV8_PARAM.MOTIONLINK_ORGACCDECTIME, originAccDecTime);
                                break;
                        }
                        break;
​
                    case FASTECH_CONNECTION_TYPE.ETHERNET:
                        switch (fastech.axisType)
                        {
                            case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_E_V6:
                                libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZISERVO2_PARAM.SERVO2_AXISACCTIME, accTime);
                                libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZISERVO2_PARAM.SERVO2_AXISDECTIME, decTime);
​
                                libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZISERVO2_PARAM.SERVO2_JOGSPEED, jogVelocity);
                                libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZISERVO2_PARAM.SERVO2_JOGACCDECTIME, jogAccDecTime);
​
                                libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZISERVO2_PARAM.SERVO2_ORGSPEED, originVelocity);
                                libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZISERVO2_PARAM.SERVO2_ORGACCDECTIME, originAccDecTime);
                                break;
​
                            case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_E_V6:
                                libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZIMOTIONLINK2_PARAM.MOTIONLINK2_AXISACCTIME, accTime);
                                libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZIMOTIONLINK2_PARAM.MOTIONLINK2_AXISDECTIME, decTime);
​
                                libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZIMOTIONLINK2_PARAM.MOTIONLINK2_JOGSPEED, jogVelocity);
                                libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZIMOTIONLINK2_PARAM.MOTIONLINK2_JOGACCDECTIME, jogAccDecTime);
​
                                libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZIMOTIONLINK2_PARAM.MOTIONLINK2_ORGSPEED, originVelocity);
                                libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZIMOTIONLINK2_PARAM.MOTIONLINK2_ORGACCDECTIME, originAccDecTime);
                                break;
                        }
                        break;
                }
​
                if (libRet == FMM_OK)
                {
                    ret = true;
                }
                else
                {
                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Fail to set parameter to {(AXIS_LIST)axisIdx}", CONTENT_TYPE.DEBUG);
                    ret = false;
                }
​
                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }
​
        /**
         * @brief Axis에 사용될 속도 관련 파라미터 저장 함수
         * @param[in] [0] : axis parameter data array
         */
        public bool SetAxisParams(params object[] args)
        {
            try
            {
                bool ret = true;
                int libRet = FMM_OK;
​
                axisParamData = (AxisParamData[])args;
​
                foreach (KeyValuePair<AXIS_LIST, FastechObject> var in axisList)
                {
                    FastechObject fastech = axisList[(AXIS_LIST)var.Key];
                    if (!IsConnected((AXIS_LIST)var.Key))
                    {
                        return false;
                    }
​
                    double scale = Convert.ToDouble(axisParamData[(int)var.Key].resolution) / Convert.ToDouble(axisParamData[(int)var.Key].distance);
​
                    axisParamData[(int)var.Key].vel_high = Convert.ToDouble(axisParamData[(int)var.Key].vel_high) * scale;
                    axisParamData[(int)var.Key].vel_medium = Convert.ToDouble(axisParamData[(int)var.Key].vel_medium) * scale;
                    axisParamData[(int)var.Key].vel_low = Convert.ToDouble(axisParamData[(int)var.Key].vel_low) * scale;
                    axisParamData[(int)var.Key].jogVel = Convert.ToDouble(axisParamData[(int)var.Key].jogVel) * scale;
                    axisParamData[(int)var.Key].oriVel = Convert.ToDouble(axisParamData[(int)var.Key].oriVel) * scale;
​
                    int velocity = Convert.ToInt32(axisParamData[(int)var.Key].vel_high);
                    int accTime = Convert.ToInt32(axisParamData[(int)var.Key].acc);
                    int decTime = Convert.ToInt32(axisParamData[(int)var.Key].dec);
​
                    int jogVelocity = Convert.ToInt32(axisParamData[(int)var.Key].jogVel);
                    int jogAccDecTime = Convert.ToInt32(axisParamData[(int)var.Key].jogAcc);
​
                    int originVelocity = Convert.ToInt32(axisParamData[(int)var.Key].oriVel);
                    int originAccDecTime = Convert.ToInt32(axisParamData[(int)var.Key].oriAcc);
​
                    switch (fastech.connectionType)
                    {
                        case FASTECH_CONNECTION_TYPE.SERIAL:
                            SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                            string strPort = GetPortString(serial.PortName);
                            byte bytePort = byte.Parse(strPort);
​
                            switch (fastech.axisType)
                            {
                                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V6:
                                    libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVO_PARAM.SERVO_AXISACCTIME, accTime);
                                    libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVO_PARAM.SERVO_AXISDECTIME, decTime);
​
                                    libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVO_PARAM.SERVO_JOGSPEED, jogVelocity);
                                    libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVO_PARAM.SERVO_JOGACCDECTIME, jogAccDecTime);
​
                                    libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVO_PARAM.SERVO_ORGSPEED, originVelocity);
                                    libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVO_PARAM.SERVO_ORGACCDECTIME, originAccDecTime);
                                    break;
​
                                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                                    libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVOV8_PARAM.SERVO_AXISACCTIME, accTime);
                                    libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVOV8_PARAM.SERVO_AXISDECTIME, decTime);
​
                                    libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVOV8_PARAM.SERVO_JOGSPEED, jogVelocity);
                                    libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVOV8_PARAM.SERVO_JOGACCDECTIME, jogAccDecTime);
​
                                    libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVOV8_PARAM.SERVO_ORGSPEED, originVelocity);
                                    libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZISERVOV8_PARAM.SERVO_ORGACCDECTIME, originAccDecTime);
                                    break;
​
                                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V6:
                                    libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINK_PARAM.MOTIONLINK_AXISACCTIME, accTime);
                                    libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINK_PARAM.MOTIONLINK_AXISDECTIME, decTime);
​
                                    libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINK_PARAM.MOTIONLINK_JOGSPEED, jogVelocity);
                                    libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINK_PARAM.MOTIONLINK_JOGACCDECTIME, jogAccDecTime);
​
                                    libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINK_PARAM.MOTIONLINK_ORGSPEED, originVelocity);
                                    libRet |= EziMOTIONPlusRLib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINK_PARAM.MOTIONLINK_ORGACCDECTIME, originAccDecTime);
                                    break;
​
                                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                    libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINKV8_PARAM.MOTIONLINK_AXISACCTIME, accTime);
                                    libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINKV8_PARAM.MOTIONLINK_AXISDECTIME, decTime);
​
                                    libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINKV8_PARAM.MOTIONLINK_JOGSPEED, jogVelocity);
                                    libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINKV8_PARAM.MOTIONLINK_JOGACCDECTIME, jogAccDecTime);
​
                                    libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINKV8_PARAM.MOTIONLINK_ORGSPEED, originVelocity);
                                    libRet |= EziMOTIONPlusRV8Lib.FAS_SetParameter(bytePort, fastech.ID, (byte)FM_EZIMOTIONLINKV8_PARAM.MOTIONLINK_ORGACCDECTIME, originAccDecTime);
                                    break;
                            }
                            break;
​
                        case FASTECH_CONNECTION_TYPE.ETHERNET:
                            switch (fastech.axisType)
                            {
                                case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_E_V6:
                                    libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZISERVO2_PARAM.SERVO2_AXISACCTIME, accTime);
                                    libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZISERVO2_PARAM.SERVO2_AXISDECTIME, decTime);
​
                                    libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZISERVO2_PARAM.SERVO2_JOGSPEED, jogVelocity);
                                    libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZISERVO2_PARAM.SERVO2_JOGACCDECTIME, jogAccDecTime);
​
                                    libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZISERVO2_PARAM.SERVO2_ORGSPEED, originVelocity);
                                    libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZISERVO2_PARAM.SERVO2_ORGACCDECTIME, originAccDecTime);
                                    break;
​
                                case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_E_V6:
                                    libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZIMOTIONLINK2_PARAM.MOTIONLINK2_AXISACCTIME, accTime);
                                    libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZIMOTIONLINK2_PARAM.MOTIONLINK2_AXISDECTIME, decTime);
​
                                    libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZIMOTIONLINK2_PARAM.MOTIONLINK2_JOGSPEED, jogVelocity);
                                    libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZIMOTIONLINK2_PARAM.MOTIONLINK2_JOGACCDECTIME, jogAccDecTime);
​
                                    libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZIMOTIONLINK2_PARAM.MOTIONLINK2_ORGSPEED, originVelocity);
                                    libRet |= EziMOTIONPlusELib.FAS_SetParameter(fastech.ID, (byte)FM_EZIMOTIONLINK2_PARAM.MOTIONLINK2_ORGACCDECTIME, originAccDecTime);
                                    break;
                            }
                            break;
                    }
​
                    if (libRet == FMM_OK)
                    {
                        ret &= true;
                    }
                    else
                    {
                        LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Fail to set parameter to {(AXIS_LIST)var.Key}", CONTENT_TYPE.DEBUG);
                        ret &= false;
                    }
                }
​
                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }
​
        /**
         * @brief Origin sensor가 감지되었는지 확인하는 함수
         * @param[in] axisIdx AXIS_LIST 번호
         * @return Origin sensor 감지 여부
         */
        public bool IsOnOriginSensor(object axisIdx)
        {
            return CheckAxisStatus(axisIdx, (uint)AXISSTATUS.FFLAG_ORIGINSENSOR);
        }
​
        /**
         * @brief 긴급 정지 명령 함수
         * @param[in] axisIdx AXIS_LIST 번호
         * @return 긴급 정지 명령 정상 수행 여부
         */
        public void EmergencyMoveStop(object axisIdx)
        {
            try
            {
                int libRet = FMM_OK;
​
                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
                if (!IsConnected(axisIdx))
                {
                    return;
                }
​
                switch (fastech.connectionType)
                {
                    case FASTECH_CONNECTION_TYPE.SERIAL:
                        SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                        string strPort = GetPortString(serial.PortName);
                        byte bytePort = byte.Parse(strPort);
​
                        switch (fastech.axisType)
                        {
                            case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                            case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                libRet = EziMOTIONPlusRV8Lib.FAS_EmergencyStop(bytePort, fastech.ID);
                                break;
                            default:
                                libRet = EziMOTIONPlusRLib.FAS_EmergencyStop(bytePort, fastech.ID);
                                break;
                        }
                        break;
​
                    case FASTECH_CONNECTION_TYPE.ETHERNET:
                        libRet = EziMOTIONPlusELib.FAS_EmergencyStop(fastech.ID);
                        break;
                }
​
                if (libRet != FMM_OK)
                {
                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Fail to emergency stop {(AXIS_LIST)axisIdx} servo because of {libRet.ToString()}", CONTENT_TYPE.DEBUG);
                }
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
            }
        }
​
        /**
         * Fastech driver에서 사용하지 않음
         */
        public bool InitIO()
        {
            throw new NotImplementedException();
        }
        public bool ClearPosition(object axisIdx)
        {
            try
            {
                bool ret = true;
                int libRet = FMM_OK;
​
                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
                if (!IsConnected(axisIdx))
                {
                    return false;
                }
​
                switch (fastech.connectionType)
                {
                    case FASTECH_CONNECTION_TYPE.SERIAL:
                        SerialPortModel serial = (SerialPortModel)fastech.connectionInfo;
                        string strPort = GetPortString(serial.PortName);
                        byte bytePort = byte.Parse(strPort);
​
                        switch (fastech.axisType)
                        {
                            case FASTECH_AXIS_TYPE.EZI_SERVO_PLUS_R_V8:
                            case FASTECH_AXIS_TYPE.EZI_MOTION_LINK_PLUS_R_V8:
                                libRet = EziMOTIONPlusRV8Lib.FAS_ClearPosition(bytePort, fastech.ID);
                                break;
​
                            default:
                                libRet = EziMOTIONPlusRLib.FAS_ClearPosition(bytePort, fastech.ID);
                                break;
                        }
                        break;
​
                    case FASTECH_CONNECTION_TYPE.ETHERNET:
                        libRet = EziMOTIONPlusELib.FAS_ClearPosition(fastech.ID);
                        break;
                }
​
                if (libRet == FMM_OK)
                {
                    ret = true;
                }
                else
                {
                    LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, $"Fail to clear position {(AXIS_LIST)axisIdx} servo because of {libRet.ToString()}", CONTENT_TYPE.DEBUG);
                    ret = false;
                }
​
                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }
        //Bổ sung phương thức kiểm tra sensor limit
        public bool IsLowerLimit(object axisIdx)
        {
            try
            {
                bool ret = false;
                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
​
                if ((fastech.objectType & FASTECH_OBJECT_TYPE.AXIS) != FASTECH_OBJECT_TYPE.NONE)
                {
                    ret = CheckAxisStatus(axisIdx, (uint)AXISSTATUS.FFLAG_HWNEGALMT);
                }
​
                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }
​
        public bool IsUpperLimit(object axisIdx)
        {
            try
            {
                bool ret = false;
                FastechObject fastech = axisList[(AXIS_LIST)axisIdx];
​
                if ((fastech.objectType & FASTECH_OBJECT_TYPE.AXIS) != FASTECH_OBJECT_TYPE.NONE)
                {
                    ret = CheckAxisStatus(axisIdx, (uint)AXISSTATUS.FFLAG_HWPOSILMT);
                }
​
                return ret;
            }
            catch (Exception e)
            {
                LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, e.ToString(), CONTENT_TYPE.EXCEPTION);
                return false;
            }
        }
    }
}
​
​
Vendor/HoneywellBarcodeReader.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Auto_Insert_Sim_Tray.Configs.Model;
using Auto_Insert_Sim_Tray.HW.BarcodeReader;
​
namespace Auto_Insert_Sim_Tray.HW.Vendor.Honeywell
{
    public class HoneywellBarcodeReader : BarcodeReader.BarcodeReader
    {
        string StopCommand = String.Empty;
        public HoneywellBarcodeReader(BarcodeReaderConfig config, byte STX = 0x16, byte ETX = 0x0D) : base(config)
        {
            this.STX = STX;
            //this.ETX = ETX;
            //this.ReadCommand = $"{((char)this.STX)}{this.ReadCommand}";
            //this.StopCommand = $"{((char)this.STX)}U";
            this.ReadCommand = $"T";
            this.StopCommand = $"{((char)this.STX)}U";
        }
​
        public void StartRead()
        {
            base.Trigger();
        }
        public void StopRead()
        {
            base.Send(this.StopCommand);
        }
​
    }
}
​
Manager/SystemManager.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Auto_Insert_Sim_Tray.Configs;
using Auto_Insert_Sim_Tray.Define;
using Auto_Insert_Sim_Tray.Utils;
using static Auto_Insert_Sim_Tray.Define.LogDefine;
using static Auto_Insert_Sim_Tray.Define.SystemEnum;
​
namespace Auto_Insert_Sim_Tray.Manager
{
    public struct OpMsg
    {
        public OP_MODE opMode;
        public int errCode;
​
        public OpMsg(OP_MODE op, int message = -1)
        {
            opMode = op;
            errCode = message;
        }
    }
    /**
     * @brief Operation Mode를 관리하는 클래스 
     */
    public class SystemManager : IObservable<OpMsg>
    {
        private IList<IObserver<OpMsg>> listObserver;
        private OpMsg opMsg;
        private OpMsg prevOpMode;
        public bool IsRunning { get; set; }
        private MainForm mainForm;
        private ManualResetEvent pauseEvent;
        private object idleLock;
        private bool isIdle;
        private object outOfStockWarningLock;
        private bool isOutOfStockWarning;
        private object outOfStockLock;
        private bool isOutOfStock;
        private object inputStopLock;
        private object outputStopLock;
        private bool isInputStop;
        private bool isOutputStop;
        private RUN_MODE runMode;
        private Stack<OpMsg> opStack;
        private Stack<OpMsg> tempStack;
        public SynchronizationContext syncContext { get; set; }
​
        public delegate void IsOpCallChange(bool isCall);
        public event IsOpCallChange IsOpCalled;
​
        /**
         * @brief 생성자
         * @param[in] main Mainform 
         */
        public SystemManager(MainForm main)
        {
            LogUtil.Instance.Log(LOG_TYPE.DEVELOPMENT, "Init system manager", CONTENT_TYPE.DEBUG);
            InitializeVariable(main);
        }
​
        /**
         * @brief 변수 초기화 해주는 함수
         * @param[in] main Mainform 
         */
        private void InitializeVariable(MainForm main)
        {
            pauseEvent = new ManualResetEvent(true);
            listObserver = new List<IObserver<OpMsg>>();
            syncContext = SynchronizationContext.Current;
            mainForm = main;
            opMsg.opMode = OP_MODE.NONE;
            prevOpMode.opMode = OP_MODE.NONE;
            runMode = RUN_MODE.NONE;
            isIdle = false;
            isOutOfStockWarning = false;
            isOutOfStock = false;
            idleLock = new object();
            outOfStockWarningLock = new object();
            outOfStockLock = new object();
            inputStopLock = new object();
            outputStopLock = new object();
            opStack = new Stack<OpMsg>();
            tempStack = new Stack<OpMsg>();
​
            TacktimeManager = JsonHelper.Instance.logisticModel.TackTime;
​
            initializeChecker = new InitializeChecker(TacktimeManager);
        }
        public RUN_MODE RunMode
        {
            set
            {
                runMode = value;
            }
            get
            {
                return runMode;
            }
        }
​
        public ManualResetEvent PauseEvent
        {
            set
            {
                pauseEvent = value;
            }
            get
            {
                return pauseEvent;
            }
        }
​
        /**
         * @brief observer를 observer list에 넣어주는 함수
         * @return Dispose 하기 용이하도록 Unsubscriber 객체
         */
        public IDisposable Subscribe(IObserver<OpMsg> observer)
        {
            if (!listObserver.Contains(observer))
            {
                listObserver.Add(observer);
                return new UnSubscriber<OpMsg>(listObserver, observer);
            }
            else
            {
                return null;
            }
        }
​
        bool isOpCall = false;
        public bool IsOpCall
        {
            get => isOpCall;
            set
            {
                isOpCall = value;
                IsOpCalled?.Invoke(isOpCall);
            }
        }
        public bool IsIdleEnter
        {
            get
            {
                lock (idleLock)
                {
                    return isIdle;
                }
            }
            set
            {
                lock (idleLock)
                {
                    isIdle = value;
                }
            }
        }
​
        public bool IsOutOfStockWarning
        {
            get
            {
                lock (outOfStockWarningLock)
                {
                    return isOutOfStockWarning;
                }
            }
            set
            {
                lock (outOfStockWarningLock)
                {
                    isOutOfStockWarning = value;
                }
            }
        }
        public bool IsOutOfStock
        {
            get
            {
                lock (outOfStockLock)
                {
                    return isOutOfStock;
                }
            }
            set
            {
                lock (outOfStockLock)
                {
                    isOutOfStock = value;
                }
            }
        }
        public bool IsInputStop
        {
            get
            {
                lock (inputStopLock)
                {
                    return isInputStop;
                }
            }
            set
            {
                lock (inputStopLock)
                {
                    isInputStop = value;
                }
            }
        }
        public bool IsOutputStop
        {
            get
            {
                lock (outputStopLock)
                {
                    return isOutputStop;
                }
            }
            set
            {
                lock (outputStopLock)
                {
                    isOutputStop = value;
                }
            }
        }
        public void StackPush(OpMsg msg)
        {
            bool find = false;
            if (opStack.Count() > 0)
            {
                for (int i = 0; i < opStack.Count(); i++)
                {
                    if ((opStack.ElementAt(i).opMode == msg.opMode) && (opStack.ElementAt(i).errCode == msg.errCode))
                    {
                        find = true;
                    }
                }
            }
            if (!find)
            {
                opStack.Push(msg);
            }
        }
        public void StackClear()
        {
            opStack.Clear();
            tempStack.Clear();
        }
        public OpMsg StackPop(OpMsg msg)
        {
            OpMsg check;
            while (!IsEmpty())
            {
                check = opStack.Peek();
                if (check.opMode == msg.opMode && check.errCode == msg.errCode)
                {
                    if (tempStack.Count > 0)
                    {
                        opStack.Pop();
                        while (tempStack.Count > 0)
                        {
                            opStack.Push(tempStack.Pop());
                        }
                    }
                    else
                    {
                        opStack.Pop();
                    }
                    break;
                }
                else
                {
                    tempStack.Push(opStack.Pop());
                }
            }
            return IsEmpty() ? new OpMsg(OP_MODE.NONE) : opStack.Peek();
        }
        private bool IsEmpty()
        {
            return (opStack.Count == 0);
        }
        /**
         * @brief 각 Observer들이 Operation mode를 변경하고자 할 때 호출 하는 함수
         * @details Operation mode 규칙에 따라 여러 요청이 와도 무시당할 수 있다
         * @param[in] op operation mode
         * @param[in] errCode error 발생 코드
         */
        public void SetOPModeWithAsync(OP_MODE op, int errCode = -1)
        {
            syncContext.Post(
            delegate
            {
                opMsg = new OpMsg(op, errCode);
                switch (op)
                {
                    case OP_MODE.READY:
                    case OP_MODE.INIT:
                    case OP_MODE.RESET:
                    case OP_MODE.SEMI_RUN:
                    case OP_MODE.ORG_RUN:
                        OpMsg = opMsg;
                        break;
                    case OP_MODE.RUN:
                        mainForm.autoPanel.login = null;
                        mainForm.login = null;
                        if (mainForm.CheckStartCondition())
                        {
                            mainForm.selected_Unit = UNIT_TYPE.NONE;
                            IsRunning = true;
                            OpMsg = opMsg;
                        }
                        else
                        {
                            opMsg = new OpMsg(OP_MODE.STOP);
                            OpMsg = opMsg;
                            SetOPModeWithAsync(OP_MODE.STOP, SystemDefine.ERRCODE_STOP_YELLOW);
                        }
                        break;
                    case OP_MODE.STOP:
                        if (mainForm.alarmForm != null)
                        {
                            mainForm.alarmForm = null;
                        }
                        //if (prevOpMode.opMode == OP_MODE.STOP)
                        //{
                        //    if (prevOpMode.errCode != opMsg.errCode)
                        //    {
                        //        OpMsg = opMsg;
                        //    }
                        //    OpMsg = opMsg; //add
                        //}
                        //else
                        //{
                        //    OpMsg = opMsg;
                        //}
                        OpMsg = opMsg;
                        break;
                    case OP_MODE.E_STOP:
                        if (prevOpMode.opMode == OP_MODE.E_STOP)
                        {
                            if (prevOpMode.errCode != opMsg.errCode)
                            {
                                OpMsg = opMsg;
                            }
                        }
                        else
                        {
                            OpMsg = opMsg;
                        }
                        break;
                }
                prevOpMode = opMsg;
                mainForm.nV_Mainform_TOP1.SetMachineStatus(op.ToString());
            }, null);
​
        }
​
        public OpMsg OpMsg
        {
            set
            {
                opMsg = value;
                Update(opMsg);
            }
            get
            {
                return opMsg;
            }
        }
​
        /**
         * @brief 구독하고 있는 observer들에게 broad cast 시켜주는 함수
         * @param[in] data Operation Mode와 error code를 지닌 객체
         */
        public TactTimeUtil TacktimeManager { get; set; }
​
        public InitializeChecker initializeChecker { get; private set; }
​
        protected void Update(OpMsg data)
        {
            foreach (var ob in listObserver)
            {
                ob.OnNext(data);
            }
            Notify();
        }
​
        /**
         * @brief 구독하고 있는 observer들에게 업데이트가 완료됨을 알려주는 함수
         */
        public void Notify()
        {
            foreach (var ob in listObserver)
            {
                ob.OnCompleted();
            }
            if (opMsg.opMode == OP_MODE.RUN || opMsg.opMode == OP_MODE.RESET || opMsg.opMode == OP_MODE.SEMI_RUN
                || opMsg.opMode == OP_MODE.ORG_RUN || opMsg.opMode == OP_MODE.INIT)
            {
                PauseEvent.Set();
            }
            else if (opMsg.opMode == OP_MODE.STOP || opMsg.opMode == OP_MODE.E_STOP)
            {
                PauseEvent.Reset();
            }
        }
​
    }
}
​
Manager/UnSubscriber.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
​
namespace Auto_Insert_Sim_Tray.Manager
{
    /**
     * @brief Obser에서 구독 해지하기 위한 클래스
     */
    class UnSubscriber<OP_MODE> : IDisposable
    {
        private IList<IObserver<OP_MODE>> listObserver;
        private IObserver<OP_MODE> observer;
​
        /**
         * @brief 생성자
         * @param[in] listOb observer 관리 리스트
         * @param[in] ob observer
         */
        public UnSubscriber(IList<IObserver<OP_MODE>> listOb, IObserver<OP_MODE> ob)
        {
            listObserver = listOb;
            observer = ob;
        }
​
        /**
         * @brief Dispose 될 때, observer list에서 observer 제거
         */
        public void Dispose()
        {
            if (listObserver.Contains(observer))
            {
                listObserver.Remove(observer);
            }
        }
    }
}
​
Mechanical/CV/MIn_CV.cs
using Auto_Insert_Sim_Tray.HW.Interface;
using Auto_Insert_Sim_Tray.Mechanical;
using Auto_Insert_Sim_Tray.Utils;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static Auto_Insert_Sim_Tray.Define.IODefine;
using static Auto_Insert_Sim_Tray.Define.SystemEnum;
​
namespace Auto_Insert_Sim_Tray.Mechanical
{
    public class MIn_CV : M_Base
    {
        public IConveyor iCV_In;
​
        sSETInfo set = new sSETInfo();
​
        public bool IsReadyPick, IsReadyPlace;
        public bool IsHaveSet_CV_In;
        public bool IsTriggerScanner = false;
        public MIn_CV(IIO iIO, IAxis iAxis)
        {
            this.iIO = iIO;
            this.iAxis = iAxis;
​
            Unit_Type = UNIT_TYPE.IN_CV;
​
            SetConveyor(DO._13_CV_INPUT, null, DI._14_SS_CV_IN_DETECT_1, DI._14_SS_CV_IN_DETECT_2, DI._14_SS_CV_IN_DETECT_3, ref iCV_In);
        }
​
        internal sSETInfo SET { get => set; set => set = value; }
​
        //IF
        public bool isIFForntReady { get; set; }
        public bool isIFForntBusy { get; set; }
        public void SetIFBusyToFrontMachine(bool isNormalCloseSignal)
        {
            if (!isNormalCloseSignal)
            {
                iIO.On(DO._13_IF_FRONT_BUSY);
            }
            else
            {
                iIO.Off(DO._13_IF_FRONT_BUSY);
            }
        }
        public void ClearIFBusyToFrontMachine(bool isNormalCloseSignal)
        {
            if (!isNormalCloseSignal)
            {
                iIO.Off(DO._13_IF_FRONT_BUSY);
            }
            else
            {
                iIO.On(DO._13_IF_FRONT_BUSY);
            }
        }
​
        //Khai báo biến X
        public bool bDetect_In_Chk => iCV_In.IsInSensor();
​
        public bool bDetect_Mid_Chk => iCV_In.IsMiddleSensor();
        public bool bDetect_Out_Chk => iCV_In.IsOutSensor();
​
        //Khai báo biến Y
        public bool bCV_In_Run => iCV_In.IsRunCW();
        public bool bCV_In_Stop => !iCV_In.IsRunCW();
​
        //Set biến Y        
        public ECODE Run_CV_In()
        {
            iCV_In.RunCW();
            return ECODE.WORK_SUCCESS;
        }
​
        public ECODE Stop_CV_In()
        {
            iCV_In.Stop();
            return ECODE.WORK_SUCCESS;
        }
    }
}
​
Mechanical/CV/MInput_Left_CV.cs
using Auto_Insert_Sim_Tray.HW.Interface;
using Auto_Insert_Sim_Tray.Mechanical;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static Auto_Insert_Sim_Tray.Define.IODefine;
using static Auto_Insert_Sim_Tray.Define.SystemEnum;
​
namespace Auto_Insert_Sim_Tray.Mechanical.CV
{
    public class MInput_Left_CV : M_Base
    {
        public IConveyor iCV_Input_Left_1;
        public IConveyor iCV_Input_Left_2;
        public ICylinder iStopper_1_Sol;
        public ICylinder iStopper_2_Sol;
​
        public bool IsEmpty_CV_1, IsEmpty_CV_2;
​
        public bool IsHaveTray_CV_Input_1, IsHaveTray_CV_Input_2;
​
        public MInput_Left_CV(IIO iIO, IAxis iAxis)
        {
            this.iIO = iIO;
            this.iAxis = iAxis;
​
            Unit_Type = UNIT_TYPE.LEFT_INTRAY_CV;
​
            SetConveyor(DO._13_CV_INTRAY_LEFT_INPUT_1, null, null, null, DI._11_SS_INTRAY_LEFT_DETECT_1, ref iCV_Input_Left_1);
            SetConveyor(DO._13_CV_INTRAY_LEFT_INPUT_2, null, null, null, DI._11_SS_INTRAY_LEFT_DETECT_2, ref iCV_Input_Left_2);
            SetSingleCylinder(DO._11_SOL_INTRAY_LEFT_STOPPER_1_DOWN, null, DI._11_SS_INTRAY_LEFT_STOPPER_1_UP, DI._11_SS_INTRAY_LEFT_STOPPER_1_DOWN, ref iStopper_1_Sol);
            SetSingleCylinder(DO._11_SOL_INTRAY_LEFT_STOPPER_2_DOWN, null, DI._11_SS_INTRAY_LEFT_STOPPER_2_UP, DI._11_SS_INTRAY_LEFT_STOPPER_2_DOWN, ref iStopper_2_Sol);
        }
​
        //Khai báo biến X
        public bool bDetect_Input_1_Chk => iCV_Input_Left_1.IsOutSensor();
        public bool bStopper_Input_1_Up_Chk => iStopper_1_Sol.IsActive();
        public bool bStopper_Input_1_Down_Chk => iStopper_1_Sol.IsDeactive();
        public bool bDetect_Input_2_Chk => iCV_Input_Left_2.IsOutSensor();
        public bool bStopper_Input_2_Up_Chk => iStopper_2_Sol.IsActive();
        public bool bStopper_Input_2_Down_Chk => iStopper_2_Sol.IsDeactive();
​
        //Khai báo biến Y
        public bool bCV_Input_Left_1_Run => iCV_Input_Left_1.IsRunCW();
        public bool bCV_Input_Left_1_Stop => !iCV_Input_Left_1.IsRunCW();
        public bool bStopper_Input_1_Up_Sol => iStopper_1_Sol.IsSolActive();
        public bool bStopper_Input_1_Down_Sol => iStopper_1_Sol.IsSolDeactive();
        public bool bCV_Input_Left_2_Run => iCV_Input_Left_2.IsRunCW();
        public bool bCV_Input_Left_2_Stop => !iCV_Input_Left_2.IsRunCW();
        public bool bStopper_Input_2_Up_Sol => iStopper_2_Sol.IsSolActive();
        public bool bStopper_Input_2_Down_Sol => iStopper_2_Sol.IsSolDeactive();
​
        //Set biến Y
        public ECODE Run_CV_Input_Left_1()
        {
            iCV_Input_Left_1.RunCW();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stop_CV_Input_Left_1()
        {
            iCV_Input_Left_1.Stop();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stopper_Input_1_Up()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iStopper_1_Sol.Active();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stopper_Input_1_Down()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iStopper_1_Sol.Deactive();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Run_CV_Input_Left_2()
        {
            iCV_Input_Left_2.RunCW();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stop_CV_Input_Left_2()
        {
            iCV_Input_Left_2.Stop();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stopper_Input_2_Up()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iStopper_2_Sol.Active();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stopper_Input_2_Down()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iStopper_2_Sol.Deactive();
            return ECODE.WORK_SUCCESS;
        }
    }
}
​
Mechanical/CV/MInput_Right_CV.cs
using Auto_Insert_Sim_Tray.HW.Interface;
using Auto_Insert_Sim_Tray.Mechanical;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static Auto_Insert_Sim_Tray.Define.IODefine;
using static Auto_Insert_Sim_Tray.Define.SystemEnum;
​
namespace Auto_Insert_Sim_Tray.Mechanical.CV
{
    public class MInput_Right_CV : M_Base
    {
        public IConveyor iCV_Input_Right_1;
        public IConveyor iCV_Input_Right_2;
        public ICylinder iStopper_1_Sol;
        public ICylinder iStopper_2_Sol;
​
        public bool IsEmpty_CV_1, IsEmpty_CV_2;
​
        public bool IsHaveTray_CV_Input_1, IsHaveTray_CV_Input_2;
​
        public MInput_Right_CV(IIO iIO, IAxis iAxis)
        {
            this.iIO = iIO;
            this.iAxis = iAxis;
​
            Unit_Type = UNIT_TYPE.RIGHT_INTRAY_CV;
​
            SetConveyor(DO._13_CV_INTRAY_RIGHT_INPUT_1, null, null, null, DI._12_SS_INTRAY_RIGHT_DETECT_1, ref iCV_Input_Right_1);
            SetConveyor(DO._13_CV_INTRAY_RIGHT_INPUT_2, null, null, null, DI._12_SS_INTRAY_RIGHT_DETECT_2, ref iCV_Input_Right_2);
            SetSingleCylinder(DO._11_SOL_INTRAY_RIGHT_STOPPER_1_DOWN, null, DI._12_SS_INTRAY_RIGHT_STOPPER_1_UP, DI._12_SS_INTRAY_RIGHT_STOPPER_1_DOWN, ref iStopper_1_Sol);
            SetSingleCylinder(DO._11_SOL_INTRAY_RIGHT_STOPPER_2_DOWN, null, DI._12_SS_INTRAY_RIGHT_STOPPER_2_UP, DI._12_SS_INTRAY_RIGHT_STOPPER_2_DOWN, ref iStopper_2_Sol);
        }
​
        // IF
        public bool isReadyTransferFromAGV { get; set; }
        public bool isBusyTransferFromAGV { get; set; }
        public void SetIFReadytoAGV()
        {
            iIO.On(DO._13_OUT_AGV_2_5);
        }
        public void ClearIFReadytoAGV()
        {
            iIO.Off(DO._13_OUT_AGV_2_5);
        }
​
        //Khai báo biến X
        public bool bDetect_Input_1_Chk => iCV_Input_Right_1.IsOutSensor();
        public bool bStopper_Input_1_Up_Chk => iStopper_1_Sol.IsActive();
        public bool bStopper_Input_1_Down_Chk => iStopper_1_Sol.IsDeactive();
        public bool bDetect_Input_2_Chk => iCV_Input_Right_2.IsOutSensor();
        public bool bStopper_Input_2_Up_Chk => iStopper_2_Sol.IsActive();
        public bool bStopper_Input_2_Down_Chk => iStopper_2_Sol.IsDeactive();
​
        //Khai báo biến Y
        public bool bCV_Input_Right_1_Run => iCV_Input_Right_1.IsRunCW();
        public bool bCV_Input_Right_1_Stop => !iCV_Input_Right_1.IsRunCW();
        public bool bStopper_Input_1_Up_Sol => iStopper_1_Sol.IsSolActive();
        public bool bStopper_Input_1_Down_Sol => iStopper_1_Sol.IsSolDeactive();
        public bool bCV_Input_Right_2_Run => iCV_Input_Right_2.IsRunCW();
        public bool bCV_Input_Right_2_Stop => !iCV_Input_Right_2.IsRunCW();
        public bool bStopper_Input_2_Up_Sol => iStopper_2_Sol.IsSolActive();
        public bool bStopper_Input_2_Down_Sol => iStopper_2_Sol.IsSolDeactive();
​
        //Set biến Y
        public ECODE Run_CV_Input_Right_1()
        {
            iCV_Input_Right_1.RunCW();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stop_CV_Input_Right_1()
        {
            iCV_Input_Right_1.Stop();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stopper_Input_1_Up()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iStopper_1_Sol.Active();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stopper_Input_1_Down()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iStopper_1_Sol.Deactive();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Run_CV_Input_Right_2()
        {
            iCV_Input_Right_2.RunCW();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stop_CV_Input_Right_2()
        {
            iCV_Input_Right_2.Stop();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stopper_Input_2_Up()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iStopper_2_Sol.Active();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stopper_Input_2_Down()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iStopper_2_Sol.Deactive();
            return ECODE.WORK_SUCCESS;
        }
    }
}
​
Mechanical/CV/MOut_CV.cs
using Auto_Insert_Sim_Tray.HW.Interface;
using Auto_Insert_Sim_Tray.Utils;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static Auto_Insert_Sim_Tray.Define.AxisDefine;
using static Auto_Insert_Sim_Tray.Define.IODefine;
using static Auto_Insert_Sim_Tray.Define.SystemEnum;
​
namespace Auto_Insert_Sim_Tray.Mechanical
{
    public class MOut_CV : M_Base
    {
        public IConveyor iCV_Out;
​
        sSETInfo set = new sSETInfo();
​
        public bool IsReadyPick, IsReadyPlace;
        public bool isHaveSet_CV_Out= false;
        public MOut_CV(IIO iIO, IAxis iAxis)
        {
            this.iIO = iIO;
            this.iAxis = iAxis;
​
            Unit_Type = UNIT_TYPE.OUT_CV;
​
            SetConveyor(DO._13_CV_OUTPUT, null, DI._14_SS_CV_OUT_DETECT_1 , null, DI._14_SS_CV_OUT_DETECT_2, ref iCV_Out);
        }
​
        internal sSETInfo SET { get => set; set => set = value; }
​
        //IF
        public bool isIFBehindBusy { get; set; }
        public bool isIFBehindReady { get; set; }
        public void SetIFReadyToBehindMachine(bool isNormalCloseSignal)
        {
            if (!isNormalCloseSignal)
            {
                iIO.On(DO._13_IF_BEHIND_READY);
            }
            else
            {
                iIO.Off(DO._13_IF_BEHIND_READY);
            }
        }
        public void ClearIFReadyToBehindMachine(bool isNormalCloseSignal)
        {
            if (!isNormalCloseSignal)
            {
                iIO.Off(DO._13_IF_BEHIND_READY);
            }
            else
            {
                iIO.On(DO._13_IF_BEHIND_READY);
            }
        }
​
        //Khai báo biến X
​
        public bool bDetect_In_Chk => iCV_Out.IsInSensor();
        public bool bDetect_Out_Chk => iCV_Out.IsOutSensor();
​
        //Khai báo biến Y
        public bool bCV_Out_Run => iCV_Out.IsRunCW();
        public bool bCV_Out_Stop => !iCV_Out.IsRunCW();
​
        //Set biến Y        
        public ECODE Run_CV_Out()
        {
            iCV_Out.RunCW();
            return ECODE.WORK_SUCCESS;
        }
​
        public ECODE Stop_CV_Out()
        {
            iCV_Out.Stop();
            return ECODE.WORK_SUCCESS;
        }
    }
}
​
Mechanical/CV/MOuttray_Left_CV.cs
using Auto_Insert_Sim_Tray.HW.Interface;
using Auto_Insert_Sim_Tray.Mechanical;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static Auto_Insert_Sim_Tray.Define.IODefine;
using static Auto_Insert_Sim_Tray.Define.SystemEnum;
​
namespace Auto_Insert_Sim_Tray.Mechanical.CV
{
    public class MOuttray_Left_CV : M_Base
    {
        public IConveyor iCV_Outtray_Left_1;
        public IConveyor iCV_Outtray_Left_2;
        public ICylinder iStopper_1_Sol;
        public ICylinder iStopper_2_Sol;
​
        public bool IsEmpty_CV_1, IsEmpty_CV_2;
​
        public bool IsHaveTray_CV_Outtray_1, IsHaveTray_CV_Outtray_2;
​
        public MOuttray_Left_CV(IIO iIO, IAxis iAxis)
        {
            this.iIO = iIO;
            this.iAxis = iAxis;
​
            Unit_Type = UNIT_TYPE.LEFT_OUTTRAY_CV;
​
            SetConveyor(DO._13_CV_OUTTRAY_LEFT_OUTPUT_1, null, null, null, DI._13_SS_OUTTRAY_LEFT_DETECT_1, ref iCV_Outtray_Left_1);
            SetConveyor(DO._13_CV_OUTTRAY_LEFT_OUTPUT_2, null, null, null, DI._13_SS_OUTTRAY_LEFT_DETECT_2, ref iCV_Outtray_Left_2);
            SetSingleCylinder(DO._12_SOL_OUTTRAY_STOPPER_LEFT_DOWN_1, null, DI._14_SS_OUTTRAY_LEFT_STOPPER_1_UP, DI._14_SS_OUTTRAY_LEFT_STOPPER_1_DOWN, ref iStopper_1_Sol);
            SetSingleCylinder(DO._12_SOL_OUTTRAY_STOPPER_LEFT_DOWN_2, null, DI._14_SS_OUTTRAY_LEFT_STOPPER_2_UP, DI._14_SS_OUTTRAY_LEFT_STOPPER_2_DOWN, ref iStopper_2_Sol);
        }
​
        //Khai báo biến X
        public bool bDetect_Outtray_1_Chk => iCV_Outtray_Left_1.IsOutSensor();
        public bool bStopper_Outtray_1_Up_Chk => iStopper_1_Sol.IsActive();
        public bool bStopper_Outtray_1_Down_Chk => iStopper_1_Sol.IsDeactive();
        public bool bDetect_Outtray_2_Chk => iCV_Outtray_Left_2.IsOutSensor();
        public bool bStopper_Outtray_2_Up_Chk => iStopper_2_Sol.IsActive();
        public bool bStopper_Outtray_2_Down_Chk => iStopper_2_Sol.IsDeactive();
​
        //Khai báo biến Y
        public bool bCV_Outtray_Left_1_Run => iCV_Outtray_Left_1.IsRunCW();
        public bool bCV_Outtray_Left_1_Stop => !iCV_Outtray_Left_1.IsRunCW();
        public bool bStopper_Outtray_1_Up_Sol => iStopper_1_Sol.IsSolActive();
        public bool bStopper_Outtray_1_Down_Sol => iStopper_1_Sol.IsSolDeactive();
        public bool bCV_Outtray_Left_2_Run => iCV_Outtray_Left_2.IsRunCW();
        public bool bCV_Outtray_Left_2_Stop => !iCV_Outtray_Left_2.IsRunCW();
        public bool bStopper_Outtray_2_Up_Sol => iStopper_2_Sol.IsSolActive();
        public bool bStopper_Outtray_2_Down_Sol => iStopper_2_Sol.IsSolDeactive();
​
        //Set biến Y
        public ECODE Run_CV_Outtray_Left_1()
        {
            iCV_Outtray_Left_1.RunCW();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stop_CV_Outtray_Left_1()
        {
            iCV_Outtray_Left_1.Stop();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stopper_Outtray_1_Up()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iStopper_1_Sol.Active();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stopper_Outtray_1_Down()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iStopper_1_Sol.Deactive();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Run_CV_Outtray_Left_2()
        {
            iCV_Outtray_Left_2.RunCW();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stop_CV_Outtray_Left_2()
        {
            iCV_Outtray_Left_2.Stop();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stopper_Outtray_2_Up()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iStopper_2_Sol.Active();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stopper_Outtray_2_Down()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iStopper_2_Sol.Deactive();
            return ECODE.WORK_SUCCESS;
        }
    }
}
​
Mechanical/CV/MOuttray_Right_CV.cs
using Auto_Insert_Sim_Tray.HW.Interface;
using Auto_Insert_Sim_Tray.Mechanical;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static Auto_Insert_Sim_Tray.Define.IODefine;
using static Auto_Insert_Sim_Tray.Define.SystemEnum;
​
namespace Auto_Insert_Sim_Tray.Mechanical.CV
{
    public class MOuttray_Right_CV : M_Base
    {
        public IConveyor iCV_Outtray_Right_1;
        public IConveyor iCV_Outtray_Right_2;
        public ICylinder iStopper_1_Sol;
        public ICylinder iStopper_2_Sol;
​
        public bool IsEmpty_CV_1, IsEmpty_CV_2;
​
        public bool IsHaveTray_CV_Outtray_1, IsHaveTray_CV_Outtray_2;
​
        public MOuttray_Right_CV(IIO iIO, IAxis iAxis)
        {
            this.iIO = iIO;
            this.iAxis = iAxis;
​
            Unit_Type = UNIT_TYPE.RIGHT_OUTTRAY_CV;
​
            SetConveyor(DO._13_CV_OUTTRAY_RIGHT_OUTPUT_1, null, null, null, DI._13_SS_OUTTRAY_RIGHT_DETECT_1, ref iCV_Outtray_Right_1);
            SetConveyor(DO._13_CV_OUTTRAY_RIGHT_OUTPUT_2, null, null, null, DI._13_SS_OUTTRAY_RIGHT_DETECT_2, ref iCV_Outtray_Right_2);
            SetSingleCylinder(DO._12_SOL_OUTTRAY_STOPPER_RIGHT_DOWN_1, null, DI._14_SS_OUTTRAY_RIGHT_STOPPER_1_UP, DI._14_SS_OUTTRAY_RIGHT_STOPPER_1_DOWN, ref iStopper_1_Sol);
            SetSingleCylinder(DO._12_SOL_OUTTRAY_STOPPER_RIGHT_DOWN_2, null, DI._14_SS_OUTTRAY_RIGHT_STOPPER_2_UP, DI._14_SS_OUTTRAY_RIGHT_STOPPER_2_DOWN, ref iStopper_2_Sol);
        }
​
​
        //Khai báo biến X
        public bool bDetect_Outtray_1_Chk => iCV_Outtray_Right_1.IsOutSensor();
        public bool bStopper_Outtray_1_Up_Chk => iStopper_1_Sol.IsActive();
        public bool bStopper_Outtray_1_Down_Chk => iStopper_1_Sol.IsDeactive();
        public bool bDetect_Outtray_2_Chk => iCV_Outtray_Right_2.IsOutSensor();
        public bool bStopper_Outtray_2_Up_Chk => iStopper_2_Sol.IsActive();
        public bool bStopper_Outtray_2_Down_Chk => iStopper_2_Sol.IsDeactive();
​
        //Khai báo biến Y
        public bool bCV_Outtray_Right_1_Run => iCV_Outtray_Right_1.IsRunCW();
        public bool bCV_Outtray_Right_1_Stop => !iCV_Outtray_Right_1.IsRunCW();
        public bool bStopper_Outtray_1_Up_Sol => iStopper_1_Sol.IsSolActive();
        public bool bStopper_Outtray_1_Down_Sol => iStopper_1_Sol.IsSolDeactive();
        public bool bCV_Outtray_Right_2_Run => iCV_Outtray_Right_2.IsRunCW();
        public bool bCV_Outtray_Right_2_Stop => !iCV_Outtray_Right_2.IsRunCW();
        public bool bStopper_Outtray_2_Up_Sol => iStopper_2_Sol.IsSolActive();
        public bool bStopper_Outtray_2_Down_Sol => iStopper_2_Sol.IsSolDeactive();
​
        //Set biến Y
        public ECODE Run_CV_Outtray_Right_1()
        {
            iCV_Outtray_Right_1.RunCW();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stop_CV_Outtray_Right_1()
        {
            iCV_Outtray_Right_1.Stop();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stopper_Outtray_1_Up()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iStopper_1_Sol.Active();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stopper_Outtray_1_Down()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iStopper_1_Sol.Deactive();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Run_CV_Outtray_Right_2()
        {
            iCV_Outtray_Right_2.RunCW();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stop_CV_Outtray_Right_2()
        {
            iCV_Outtray_Right_2.Stop();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stopper_Outtray_2_Up()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iStopper_2_Sol.Active();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stopper_Outtray_2_Down()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iStopper_2_Sol.Deactive();
            return ECODE.WORK_SUCCESS;
        }
    }
}
​
Mechanical/Intray/MIntray_Base.cs
using Auto_Insert_Sim_Tray.HW.Interface;
using Auto_Insert_Sim_Tray.Utils;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static Auto_Insert_Sim_Tray.Define.AxisDefine;
using static Auto_Insert_Sim_Tray.Define.IODefine;
using static Auto_Insert_Sim_Tray.Define.SystemEnum;
​
namespace Auto_Insert_Sim_Tray.Mechanical.Intray
{
    public abstract class MIntray_Base : M_Base
    {
        public object Intray_Detect_4_Chk;
​
        public ICylinder iHold_Sol;
        public ICylinder iSeperate_Sol;
        public ICylinder iElevator_1_Sol;
        public ICylinder iElevator_2_Sol;
        public ICylinder iRemove_Down_Sol;
        public ICylinder iRemove_BW_Sol;
        public ICylinder iAlign_Sol;
        public ICylinder iAlign_Top_Sol;
​
        public IConveyor iCV_Work;
​
        public bool IsHaveTray_Work_Left, IsHaveTray_Align_Left, IsHaveTray_Work_Right, IsHaveTray_Align_Right;
        public bool IsAlign_Done_Left, IsAlign_Done_Right;
​
        public PulseIO PulseTray;
        //public PulseFlag Pulse_Tray = new PulseFlag();
​
        public bool IsHaveNew_Tray;
        //Khai báo biến X
        public bool bHold_On_Chk => iHold_Sol.IsActive();
        public bool bHold_Off_Chk => iHold_Sol.IsDeactive();
        public bool bSeparate_On_Chk => iSeperate_Sol.IsActive();
        public bool bSeparate_Off_Chk => iSeperate_Sol.IsDeactive();
        public bool bElevator_1_FW_Chk => iElevator_1_Sol.IsActive();
        public bool bElevator_1_BW_Chk => iElevator_1_Sol.IsDeactive();
        public bool bElevator_2_FW_Chk => iElevator_2_Sol.IsActive();
        public bool bElevator_2_BW_Chk => iElevator_2_Sol.IsDeactive();
        public bool bRemove_Up_Chk => iRemove_Down_Sol.IsActive();
        public bool bRemove_Down_Chk => iRemove_Down_Sol.IsDeactive();
        public bool bRemove_FW_Chk => iRemove_BW_Sol.IsActive();
        public bool bRemove_BW_Chk => iRemove_BW_Sol.IsDeactive();
        public bool bAlign_On_Chk => iAlign_Sol.IsActive();
        public bool bAlign_Off_Chk => iAlign_Sol.IsDeactive();
        public bool bAlign_Top_On_Chk => iAlign_Top_Sol.IsActive();
        //public bool bAlign_Top_Off_Chk => iAlign_Top_Sol.IsDeactive();
​
        public bool bIntray_Detect_4 => iIO.IsOn(Intray_Detect_4_Chk); //Khai báo ss thường mở
​
        public bool bIntray_Detect_3 => iCV_Work.IsOutSensor();
​
        //Khai báo biến Y
        public bool bHold_On_Sol => iHold_Sol.IsSolActive();
        public bool bHold_Off_Sol => iHold_Sol.IsSolDeactive();
        public bool bSeparate_On_Sol => iSeperate_Sol.IsSolActive();
        public bool bSeparate_Off_Sol => iSeperate_Sol.IsSolDeactive();
        public bool bElevator_1_FW_Sol => iElevator_1_Sol.IsSolActive();
        public bool bElevator_1_BW_Sol => iElevator_1_Sol.IsSolDeactive();
        public bool bElevator_2_FW_Sol => iElevator_2_Sol.IsSolActive();
        public bool bElevator_2_BW_Sol => iElevator_2_Sol.IsSolDeactive();
        public bool bRemove_Up_Sol => iRemove_Down_Sol.IsSolActive();
        public bool bRemove_Down_Sol => iRemove_Down_Sol.IsSolDeactive();
        public bool bRemove_FW_Sol => iRemove_BW_Sol.IsSolActive();
        public bool bRemove_BW_Sol => iRemove_BW_Sol.IsSolDeactive();
        public bool bAlign_On_Sol => iAlign_Sol.IsSolActive();
        public bool bAlign_Off_Sol => iAlign_Sol.IsSolDeactive();
        public bool bAlign_Top_On_Sol => iAlign_Top_Sol.IsSolActive();
        public bool bAlign_Top_Off_Sol => iAlign_Top_Sol.IsSolDeactive();
​
        public bool bCV_Work_Run => iCV_Work.IsRunCW();
        public bool bCV_Work_Stop => !iCV_Work.IsRunCW();
​
        //Set biến Y
        public ECODE Hold_On()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iHold_Sol.Active();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Hold_Off()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iHold_Sol.Deactive();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Separate_On()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iSeperate_Sol.Active();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Separate_Off()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iSeperate_Sol.Deactive();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Elevator_1_FW()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iElevator_1_Sol.Active();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Elevator_1_BW()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iElevator_1_Sol.Deactive();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Elevator_2_FW()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iElevator_2_Sol.Active();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Elevator_2_BW()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iElevator_2_Sol.Deactive();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Remove_Up()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iRemove_Down_Sol.Active();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Remove_Down()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iRemove_Down_Sol.Deactive();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Remove_FW()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iRemove_BW_Sol.Active();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Remove_BW()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iRemove_BW_Sol.Deactive();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Align_On()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iAlign_Sol.Active();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Align_Off()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iAlign_Sol.Deactive();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Align_Top_On()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iAlign_Top_Sol.Active();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Align_Top_Off()
        {
            if (IsManualMode)
            {
                IsInitialFinish = false;
            }
            iAlign_Top_Sol.Deactive();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Run_CV_Work()
        {
            iCV_Work.RunCW();
            return ECODE.WORK_SUCCESS;
        }
        public ECODE Stop_CV_Work()
        {
            iCV_Work.Stop();
            return ECODE.WORK_SUCCESS;
        }
    }
}
​
Mechanical/Intray/MIntray_Left.cs
using Auto_Insert_Sim_Tray.HW.Interface;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static Auto_Insert_Sim_Tray.Define.AxisDefine;
using static Auto_Insert_Sim_Tray.Define.IODefine;
using static Auto_Insert_Sim_Tray.Define.SystemEnum;
​
namespace Auto_Insert_Sim_Tray.Mechanical.Intray
{
    public class MIntray_Left : MIntray_Base
    {
        public MIntray_Left(IIO iIO, IAxis iAxis)
        {
            this.iIO = iIO;
            this.iAxis = iAxis;
​
            Unit_Type = UNIT_TYPE.INTRAY_LEFT;
​
            SetDoubleCylinder(DO._11_SOL_INTRAY_LEFT_HOLD_ON, 
                              DO._11_SOL_INTRAY_LEFT_HOLD_OFF, 
                              DI._11_SS_INTRAY_LEFT_HOLD_ON, 
                              DI._11_SS_INTRAY_LEFT_HOLD_OFF, ref iHold_Sol);
            SetDoubleCylinder(DO._11_SOL_INTRAY_LEFT_SEPERATE_ON, 
                              DO._11_SOL_INTRAY_LEFT_SEPERATE_OFF, 
                              DI._11_SS_INTRAY_LEFT_SEPERATE_ON, 
                              DI._11_SS_INTRAY_LEFT_SEPERATE_OFF, ref iSeperate_Sol);
            SetDoubleCylinder(DO._11_SOL_INTRAY_LEFT_ELEVATOR_1_FW, 
                              DO._11_SOL_INTRAY_LEFT_ELEVATOR_1_BW, 
                              DI._11_SS_INTRAY_LEFT_ELEVATOR_1_FW, 
                              DI._11_SS_INTRAY_LEFT_ELEVATOR_1_BW, ref iElevator_1_Sol);
            SetDoubleCylinder(DO._11_SOL_INTRAY_LEFT_ELEVATOR_2_FW,
                              DO._11_SOL_INTRAY_LEFT_ELEVATOR_2_BW,
                              DI._11_SS_INTRAY_LEFT_ELEVATOR_2_FW,
                              DI._11_SS_INTRAY_LEFT_ELEVATOR_2_BW, ref iElevator_2_Sol);
            SetDoubleCylinder(DO._11_SOL_INTRAY_LEFT_REMOVE_UP,
                              DO._11_SOL_INTRAY_LEFT_REMOVE_DOWN,
                              DI._11_SS_INTRAY_LEFT_REMOVE_UP,
                              DI._11_SS_INTRAY_LEFT_REMOVE_DOWN, ref iRemove_Down_Sol);
            SetDoubleCylinder(DO._11_SOL_INTRAY_LEFT_REMOVE_FW,
                              DO._11_SOL_INTRAY_LEFT_REMOVE_BW,
                              DI._11_SS_INTRAY_LEFT_REMOVE_FW,
                              DI._11_SS_INTRAY_LEFT_REMOVE_BW, ref iRemove_BW_Sol);
            SetSingleCylinder(DO._11_SOL_INTRAY_LEFT_ALIGN_OFF, 
                              null, 
                              DI._11_SS_INTRAY_LEFT_ALIGN_ON, 
                              DI._11_SS_INTRAY_LEFT_ALIGN_OFF, ref iAlign_Sol);
            SetSingleCylinder(DO._11_SOL_INTRAY_LEFT_ALIGN_TOP_OFF,
                              null,
                              DI._11_SS_INTRAY_LEFT_ALIGN_TOP_ON,
                              null, ref iAlign_Top_Sol);
​
            Set_IO_Value(DI._11_SS_INTRAY_LEFT_DETECT_4, ref Intray_Detect_4_Chk);
​
            SetConveyor(DO._13_CV_INTRAY_LEFT_WORK, null, null, null, DI._11_SS_INTRAY_LEFT_DETECT_3, ref iCV_Work);
​
            PulseTray = new Utils.PulseIO(this.iIO, DI._11_SS_INTRAY_LEFT_DETECT_4);
        }
    }
}
​
Mechanical/Intray/MIntray_Right.cs
using Auto_Insert_Sim_Tray.HW.Interface;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static Auto_Insert_Sim_Tray.Define.AxisDefine;
using static Auto_Insert_Sim_Tray.Define.IODefine;
using static Auto_Insert_Sim_Tray.Define.SystemEnum;
​
namespace Auto_Insert_Sim_Tray.Mechanical.Intray
{
    public class MIntray_Right : MIntray_Base
    {
        public MIntray_Right(IIO iIO, IAxis iAxis)
        {
            this.iIO = iIO;
            this.iAxis = iAxis;
​
            Unit_Type = UNIT_TYPE.INTRAY_RIGHT;
​
            SetDoubleCylinder(DO._11_SOL_INTRAY_RIGHT_HOLD_ON,
                              DO._11_SOL_INTRAY_RIGHT_HOLD_OFF,
                              DI._12_SS_INTRAY_RIGHT_HOLD_ON,
                              DI._12_SS_INTRAY_RIGHT_HOLD_OFF, ref iHold_Sol);
            SetDoubleCylinder(DO._11_SOL_INTRAY_RIGHT_SEPERATE_ON,
                              DO._11_SOL_INTRAY_RIGHT_SEPERATE_OFF,
                              DI._12_SS_INTRAY_RIGHT_SEPERATE_ON,
                              DI._12_SS_INTRAY_RIGHT_SEPERATE_OFF, ref iSeperate_Sol);
            SetDoubleCylinder(DO._11_SOL_INTRAY_RIGHT_ELEVATOR_1_FW,
                              DO._11_SOL_INTRAY_RIGHT_ELEVATOR_1_BW,
                              DI._12_SS_INTRAY_RIGHT_ELEVATOR_1_FW,
                              DI._12_SS_INTRAY_RIGHT_ELEVATOR_1_BW, ref iElevator_1_Sol);
            SetDoubleCylinder(DO._11_SOL_INTRAY_RIGHT_ELEVATOR_2_FW,
                              DO._11_SOL_INTRAY_RIGHT_ELEVATOR_2_BW,
                              DI._12_SS_INTRAY_RIGHT_ELEVATOR_2_FW,
                              DI._12_SS_INTRAY_RIGHT_ELEVATOR_2_BW, ref iElevator_2_Sol);
            SetDoubleCylinder(DO._11_SOL_INTRAY_RIGHT_REMOVE_UP,
                              DO._11_SOL_INTRAY_RIGHT_REMOVE_DOWN,
                              DI._12_SS_INTRAY_RIGHT_REMOVE_UP,
                              DI._12_SS_INTRAY_RIGHT_REMOVE_DOWN, ref iRemove_Down_Sol);
            SetDoubleCylinder(DO._11_SOL_INTRAY_RIGHT_REMOVE_FW,
                              DO._11_SOL_INTRAY_RIGHT_REMOVE_BW,
                              DI._12_SS_INTRAY_RIGHT_REMOVE_FW,
                              DI._12_SS_INTRAY_RIGHT_REMOVE_BW, ref iRemove_BW_Sol);
            SetSingleCylinder(DO._11_SOL_INTRAY_RIGHT_ALIGN_OFF,
                              null,
                              DI._12_SS_INTRAY_RIGHT_ALIGN_ON,
                              DI._12_SS_INTRAY_RIGHT_ALIGN_OFF, ref iAlign_Sol);
            SetSingleCylinder(DO._11_SOL_INTRAY_RIGHT_ALIGN_TOP_OFF,
                              null,
                              DI._12_SS_INTRAY_RIGHT_ALIGN_TOP_ON,
                              null, ref iAlign_Top_Sol);
​
            Set_IO_Value(DI._12_SS_INTRAY_RIGHT_DETECT_4, ref Intray_Detect_4_Chk);
​
            SetConveyor(DO._13_CV_INTRAY_RIGHT_WORK, null, null, null, DI._12_SS_INTRAY_RIGHT_DETECT_3, ref iCV_Work);
​
            PulseTray = new Utils.PulseIO(this.iIO, DI._12_SS_INTRAY_RIGHT_DETECT_4);
​
        }
    }
}
​
​
​
​

El valor del area es 673.332999999996

Cached Result
Last Run:	9:39:00 pm
Compile:	0.11s
Execute:	0s
Memory:	0b
CPU:	0.016s

View IL Code