using Aurora.Api;
using Aurora.Api.Devices;
using Aurora.Api.Manager;
using AuroraIO;
using Hermes;
using System;
using System.Threading;
using System.Windows;
using static AuroraIO.Vendor.PAIX.PAIXIO;

namespace AuroraMotionBoard.Ajin
{
    public class AJINDevice : Device
    {
        private readonly Logger Log = new Logger("AjinMotion");
        public AJINDeviceConfig _config;
        private IODevice _IO;

        private int _MotorCount;
        private bool _isSimulBySetting;
        private bool _XPosInterlockType;

        private double _currentPosition;
        private double _targetPosition;

        //var systemParameterILSOS = AuroraEnv.SettingEntry[SettingIds.SystemParameter] as SystemParameter;
        //systemParameterILSOS.MachineType == eMachineType.PRIBAT_L1

        //public AJINDevice(bool XPosInterlock,  string deviceId, bool isSimul = false)
        public AJINDevice(bool XPosInterlockType, IDeviceManager deviceManager, string deviceId, bool isSimul = false)
        {
            _isSimulBySetting = isSimul;
            //_devManager = deviceManager;
            _XPosInterlockType = XPosInterlockType;
            _IO = deviceManager["IO_Board"] as IODevice;
        }

        protected override int DoActivate(IDeviceConfig config)
        {
            _config = config as AJINDeviceConfig;

            IsSimul = _config.IsSimul || _isSimulBySetting;
            if (IsSimul) {
                return E1.OK;
            }

            _MotorCount = _config.TotalMotorCount;
            if (!Init())
                return E1.NETWORK;


            // Motion Param Setting File Load
            //if (!string.IsNullOrEmpty(_config.MotionSettingsPath)) {
            //    var res = CAXM.AxmMotLoadParaAll(_config.MotionSettingsPath);
            //    if (res != (uint)AXT_FUNC_RESULT.AXT_RT_SUCCESS) {
            //        Log.E($"AXM AxmMotLoadParaAll Error : {Enum.GetName(typeof(AXT_FUNC_RESULT), res)}");
            //        return E2.ABORTED;
            //    }
            //}
            return E1.OK;
        }

        protected override int DoDeactivate()
        {
            if (!IsSimul) {
                if (!Close())
                    return E1.NETWORK;
            }
            return E1.OK;
        }

        public bool Init()
        {
            try {
                uint res = 0;
                int count = 0;

                // 객체 초기화
                if (CAXL.AxlIsOpened() == (int)AXT_BOOLEAN.FALSE) {
                    res = CAXL.AxlOpen(0);
                    if (res != (uint)AXT_FUNC_RESULT.AXT_RT_SUCCESS) {
                        Log.E($"AXM AxlOpen Error : {Enum.GetName(typeof(AXT_FUNC_RESULT), res)}");
                        return false;
                    }
                }

                // Board Count 추가
                res = CAXL.AxlGetBoardCount(ref count);
                if (count < 1 || (res != (uint)AXT_FUNC_RESULT.AXT_RT_SUCCESS)) {
                    Log.E($"AXM AxlGetBoardCount Error : {Enum.GetName(typeof(AXT_FUNC_RESULT), res)}");
                    return false;
                }

            } catch (Exception e) {
                Log.FuncE(e.Message);
                return false;
            }
            return true;
        }

        public bool CheckModuleInit()
        {
            uint res = CAXL.AxlGetBoardStatus(_config.UseBoardNo);
            if (res != (uint)AXT_FUNC_RESULT.AXT_RT_SUCCESS) {
                Log.E($"AXL AxlGetBoardStatus Error : {Enum.GetName(typeof(AXT_FUNC_RESULT), res)}");
                return false;
            }

            for (int nodeIndex = 0; nodeIndex < _config.TotalMotorCount; nodeIndex++) {
                res = CAXL.AxlGetModuleNodeStatus(_config.UseBoardNo, nodeIndex);
                if(res != (uint)AXT_FUNC_RESULT.AXT_RT_SUCCESS) {
                    Log.E($"AXL AxlGetModuleNodeStatus Error : {Enum.GetName(typeof(AXT_FUNC_RESULT), res)}");
                    return false;
                }
            }
            return true;
        }
        public bool Close()
        {
            try {
                int res = 0;

                var IsOpen = CAXL.AxlIsOpened();
                if (IsOpen  != (int)AXT_BOOLEAN.TRUE)
                    return true;

                res = CAXL.AxlClose();
                if (res != (int)AXT_BOOLEAN.TRUE) {
                    Log.E($"AXM AxlClose Error");
                    return false;
                }

            } catch (Exception ex) {
                Log.FuncE(ex.Message);
                return false;
            }
            return true;
        }
        public bool AmpDisable(int Axis)
        {
            try {
                uint res = 0;
                double Decel = 0.0;

                res = CAXM.AxmMoveStop(Axis, Decel);
                if (res != (uint)AXT_FUNC_RESULT.AXT_RT_SUCCESS) {
                    Log.E($"AXM AxmMoveStop Error : {Enum.GetName(typeof(AXT_FUNC_RESULT), res)}");
                    return false;
                }

                if (ServoOnOff(Axis, (uint)AXT_MOTION_SIGNAL_LEVEL.INACTIVE))
                    return false;

                if (AlarmReset(Axis))
                    return false;

            } catch (Exception ex) {
                Log.FuncE(ex.Message);
                return false;
            }
            return true;
        }

        #region Home Func
        public int SetHomeVelocity(int AxisNo, double VelFirst, double VelSecond, double VelThird, double velLast, double AccFirst, double AccSecond)
        {
            try {
                uint res = 0;
                res = CAXM.AxmHomeSetVel(AxisNo, VelFirst, VelSecond, VelThird, velLast, AccFirst, AccSecond);
                if (res != (uint)AXT_FUNC_RESULT.AXT_RT_SUCCESS) {
                    Log.E($"AXM SetHomeVelocity Error : {Enum.GetName(typeof(AXT_FUNC_RESULT), res)}");
                    return E2.ABORTED;
                }
            } catch (Exception ex) {
                Log.FuncE(ex.Message);
                return E2.ABORTED;
            }
            return E1.OK;
        }
        public int SetHomeMethod(int AxisNo, int HmDir, uint HomeSignal, uint Zphas, double HomeClrTime, double HomeOffset)
        {
            try {
                uint res = 0;
                res = CAXM.AxmHomeSetMethod(AxisNo, HmDir, HomeSignal, Zphas, HomeClrTime, HomeOffset);
                if (res != (uint)AXT_FUNC_RESULT.AXT_RT_SUCCESS) {
                    Log.E($"AXM AxmHomeSetMethod Error : {Enum.GetName(typeof(AXT_FUNC_RESULT), res)}");
                    return E2.ABORTED;
                }
            } catch (Exception ex) {
                Log.FuncE(ex.Message);
                return E2.ABORTED;
            }
            return E1.OK;
        }
        public int StartHome(int Axis)
        {
            try {
                if (GetAlarmStatus(Axis) || !IsServoOn(Axis)) return E2.ABORTED;

                if (CheckXPosInterlock(_XPosInterlockType, Axis) == false)
                    return E2.ABORTED;
                else {
                    uint res = 0;
                    res = CAXM.AxmHomeSetStart(Axis);
                    if (res != (uint)AXT_FUNC_RESULT.AXT_RT_SUCCESS) {
                        Log.E($"AXM Home Error : {Enum.GetName(typeof(AXT_FUNC_RESULT), res)}");
                        return E2.ABORTED;
                    }
                }
            } catch (Exception ex) {
                Log.FuncE(ex.Message);
                return E2.ABORTED;
            }
            return E1.OK;
        }

        public uint GetHomeResult(int Axis)
        {
            if (IsSimul)
                return (uint)AXT_MOTION_HOME_RESULT.HOME_SUCCESS;

            uint status = 0;
            try {
                uint res = 0;
                res = CAXM.AxmHomeGetResult(Axis, ref status);
                if (res != (uint)AXT_FUNC_RESULT.AXT_RT_SUCCESS) {
                    Log.E($"AXM AxmHomeGetResult Error : {Enum.GetName(typeof(AXT_FUNC_RESULT), res)}");
                    return status;
                }
            } catch (Exception ex) {
                Log.FuncE(ex.Message);
                return E1.OK;
            }
            return status;
        }
        #endregion

        #region Move Func
        public int MoveABS(int Axis, double Pos, double Vel, double Accel, double Decel)
        {
            try {
                _targetPosition = Pos;
                if ((uint)AXT_MOTION_HOME_RESULT.HOME_SUCCESS != GetHomeResult(Axis) || GetAlarmStatus(Axis) || !IsServoOn(Axis))
                    return E2.ABORTED;

                if (CheckXPosInterlock(_XPosInterlockType, Axis) == false)
                    return E2.ABORTED;
                else {
                    double curr = GetCurrentPosition(Axis);
                    if (double.IsNaN(curr))
                        return E2.ABORTED;

                    if (Math.Abs(curr - Pos) < 0.001)
                        return E1.OK;

                    uint res = CAXM.AxmMotSetAbsRelMode(Axis, (uint)AXT_MOTION_ABSREL.POS_ABS_MODE);
                    if (res != (uint)AXT_FUNC_RESULT.AXT_RT_SUCCESS) {
                        Log.E($"AXM AxmMotSetAbsRelMode Error : {Enum.GetName(typeof(AXT_FUNC_RESULT), res)}");
                        return E2.ABORTED;
                    }

                    if (Move(Axis, Pos, Vel, Accel, Decel) < 0)
                        return E2.ABORTED;
                }
            } catch (Exception ex) {
                Log.FuncE(ex.Message);
                return E1.ARGUMENT;
            }

            return E1.OK;
        }
        public int MoveREL(int Axis, double Pos, double Vel, double Accel, double Decel)
        {
            try {
                _targetPosition = Pos;
                if ((uint)AXT_MOTION_HOME_RESULT.HOME_SUCCESS != GetHomeResult(Axis) || GetAlarmStatus(Axis) || !IsServoOn(Axis))
                    return E2.ABORTED;

                if (CheckXPosInterlock(_XPosInterlockType, Axis) == false)
                    return E2.ABORTED;
                else {
                    double curr = GetCurrentPosition(Axis);
                    if (double.IsNaN(curr))
                        return E2.ABORTED;

                    if (Math.Abs(curr + Pos) < 0.001)
                        return E1.OK;

                    uint res = CAXM.AxmMotSetAbsRelMode(Axis, (uint)AXT_MOTION_ABSREL.POS_REL_MODE);
                    if (res != (uint)AXT_FUNC_RESULT.AXT_RT_SUCCESS) {
                        Log.E($"AXM AxmMotSetAbsRelMode Error : {Enum.GetName(typeof(AXT_FUNC_RESULT), res)}");
                        return E2.ABORTED;
                    }

                    if (Move(Axis, Pos, Vel, Accel, Decel) < 0)
                        return E2.ABORTED;
                }
            } catch (Exception ex) {
                Log.FuncE(ex.Message);
                return E1.ARGUMENT;
            }

            return E1.OK;
        }

        internal int Move(int Axis, double Pos, double Vel, double Accel, double Decel)
        {
            try {
                _targetPosition = Pos;
                if ((uint)AXT_MOTION_HOME_RESULT.HOME_SUCCESS != GetHomeResult(Axis) || GetAlarmStatus(Axis) || !IsServoOn(Axis)) return E2.ABORTED;
                if (CheckXPosInterlock(_XPosInterlockType, Axis) == false)
                    return E2.ABORTED;
                uint res = 0;
                res = CAXM.AxmMoveStartPos(Axis, Pos, Vel, Accel, Decel);
                if (res != (uint)AXT_FUNC_RESULT.AXT_RT_SUCCESS) {
                    Log.E($"AxmMoveStartPos Error : {Enum.GetName(typeof(AXT_FUNC_RESULT), res)}");
                    return E2.ABORTED;
                }
                //res = CAXM.AxmMotSetAccelJerk(Axis, Accel * 5);
                //if (res != (uint)AXT_FUNC_RESULT.AXT_RT_SUCCESS) {
                //    Log.E($"AxmMotSetAccelJerk Error : {Enum.GetName(typeof(AXT_FUNC_RESULT), res)}");
                //    return E2.ABORTED;
                //}

            } catch (Exception ex) {
                Log.FuncE(ex.Message);
                return E2.ABORTED;
            }
            return E1.OK;
        }
        public int MoveJog(int Axis, int direction, double velocity, double Accel, double Decel)
        {
            try {
                if ((uint)AXT_MOTION_HOME_RESULT.HOME_SUCCESS != GetHomeResult(Axis) || GetAlarmStatus(Axis) || !IsServoOn(Axis)) return E2.ABORTED;
                if (CheckXPosInterlock(_XPosInterlockType, Axis) == false)
                    return E2.ABORTED;
                uint res = 0;
                res = CAXM.AxmMoveVel(Axis, direction * velocity, Accel, Decel);
                if (res != (uint)AXT_FUNC_RESULT.AXT_RT_SUCCESS) {
                    Log.E($"AXM Jog Error : {Enum.GetName(typeof(AXT_FUNC_RESULT), res)}");
                    return E2.ABORTED;
                }
            } catch (Exception ex) {
                Log.FuncE(ex.Message);
                return E2.ABORTED;
            }
            return E1.OK;
        }

        public int Stop(int Axis)
        {
            try {
                uint res = 0;
                res = CAXM.AxmMoveSStop(Axis);
                if (res != (uint)AXT_FUNC_RESULT.AXT_RT_SUCCESS) {
                    Log.E($"AXM Stop Error : {Enum.GetName(typeof(AXT_FUNC_RESULT), res)}");
                    return E2.ABORTED;
                }
            } catch (Exception ex) {
                Log.FuncE(ex.Message);
                return E2.ABORTED;
            }
            return E1.OK;
        }
        #endregion

        #region Getter Func
        public (int boardNo, int modulePos, int ModuleId) ReadAxisInfo(int Axis)
        {
            int BoardNo = 0, ModulePos = 0;
            uint ModuleID = 0;
            try {
                uint res = 0;
                res = CAXM.AxmInfoGetAxis(Axis, ref BoardNo, ref ModulePos, ref ModuleID);
                if (res != (uint)AXT_FUNC_RESULT.AXT_RT_SUCCESS) {
                    Log.E($"AXM AxmInfoGetAxis Error : {Enum.GetName(typeof(AXT_FUNC_RESULT), res)}");
                    return (BoardNo, ModulePos, (int)ModuleID);
                }
            } catch (Exception ex) {
                Log.FuncE(ex.Message);
                return (BoardNo, ModulePos, (int)ModuleID);
            }
            return (BoardNo, ModulePos, (int)ModuleID);
        }
        public double GetTargetPosition(int Axis)
        {
            double pos = 0.0;
            try {
                uint res = 0;
                res = CAXM.AxmStatusGetCmdPos(Axis, ref pos);
                if (res != (uint)AXT_FUNC_RESULT.AXT_RT_SUCCESS) {
                    Log.E($"AXM GetTargetPosition Error : {Enum.GetName(typeof(AXT_FUNC_RESULT), res)}");
                    return double.NaN;
                }
            } catch (Exception ex) {
                Log.FuncE(ex.Message);
                return double.NaN;
            }
            return pos;
        }
        public double GetCurrentPosition(int Axis)
        {
            if (IsSimul)
                return _currentPosition;

            if (!IsActivated)
                return double.NaN;

            try {
                uint res = 0;
                res = CAXM.AxmStatusGetActPos(Axis, ref _currentPosition);
                if (res != (uint)AXT_FUNC_RESULT.AXT_RT_SUCCESS) {
                    Log.E($"AXM GetCurrentPosition Error : {Enum.GetName(typeof(AXT_FUNC_RESULT), res)}");
                    return double.NaN;
                }
            } catch (Exception ex) {
                Log.FuncE(ex.Message);
                return double.NaN;
            }
            return _currentPosition;
        }
        public bool CheckInside(double Target, double cur)
        {
            if (Target - 0.1 < cur && cur < Target + 0.1)
                return true;
            return false;
        }

        public bool ReadInPosition(int Axis)
        {
            if (IsSimul)
                return _targetPosition == _currentPosition;

            if (!IsActivated)
                return false;

            uint status = 0;
            try {
                uint res = 0;
                res = CAXM.AxmSignalReadInpos(Axis, ref status);
                if (res != (uint)AXT_FUNC_RESULT.AXT_RT_SUCCESS) {
                    Log.E($"AXM ReadInposition Error : {Enum.GetName(typeof(AXT_FUNC_RESULT), res)}");
                    return false;
                }
            } catch (Exception ex) {
                Log.FuncE(ex.Message);
                return false;
            }
            return status == (uint)AXT_MOTION_SIGNAL_LEVEL.ACTIVE ? true : false;
        }

        public bool ReadInMotion(int Axis)
        {
            if (IsSimul)
                return true;

            if (!IsActivated)
                return false;

            uint status = 0;
            try {
                uint res = 0;
                res = CAXM.AxmStatusReadInMotion(Axis, ref status);
                if (res != (uint)AXT_FUNC_RESULT.AXT_RT_SUCCESS) {
                    Log.E($"AXM ReadInMotion Error : {Enum.GetName(typeof(AXT_FUNC_RESULT), res)}");
                    return false;
                }
            } catch (Exception ex) {
                Log.FuncE(ex.Message);
                return false;
            }
            return status == (uint)AXT_MOTION_SIGNAL_LEVEL.ACTIVE ? true : false;
        }

        public double ReadServoLoadRatio(int Axis)
        {
            if (!IsActivated)
                return double.NaN;

            double status = 0;
            try {
                uint res = 0;
                res = CAXM.AxmStatusReadServoLoadRatio(Axis, ref status);
                if (res != (uint)AXT_FUNC_RESULT.AXT_RT_SUCCESS) {
                    Log.E($"AXM AxmStatusReadServoLoadRatio Error : {Enum.GetName(typeof(AXT_FUNC_RESULT), res)}");
                    return double.NaN;
                }
            } catch (Exception ex) {
                Log.FuncE(ex.Message);
                return double.NaN;
            }
            return double.NaN;
        }

        public (bool HwPos, bool HwNeg) ReadLimit(int Axis)
        {
            if (!IsActivated)
                return (false, false);

            uint posStatus = 0, negStatus = 0;
            try {
                uint res = 0;
                res = CAXM.AxmSignalReadLimit(Axis, ref posStatus, ref negStatus);
                if (res != (uint)AXT_FUNC_RESULT.AXT_RT_SUCCESS) {
                    Log.E($"AXM ReadLimit Error : {Enum.GetName(typeof(AXT_FUNC_RESULT), res)}");
                    return (true, true);
                }
            } catch (Exception ex) {
                Log.FuncE(ex.Message);
                return (true, true);
            }
            return (posStatus == (uint)AXT_MOTION_SIGNAL_LEVEL.ACTIVE ? true : false,
                    negStatus == (uint)AXT_MOTION_SIGNAL_LEVEL.ACTIVE ? true : false);
        }
        #endregion

        public bool ServoOnOff(int Axis, uint onoff)
        {
            if (IsSimul)
                return true;

            if (!IsActivated)
                return false;

            try {
                uint res = 0;
                res = CAXM.AxmSignalServoOn(Axis, onoff);
                if (res != (uint)AXT_FUNC_RESULT.AXT_RT_SUCCESS) {
                    Log.E($"AXM ServoOnOff Error : {Enum.GetName(typeof(AXT_FUNC_RESULT), res)}");
                    return false;
                }
            } catch (Exception ex) {
                Log.FuncE(ex.Message);
                return false;
            }
            return true;
        }
        public bool IsServoOn(int Axis)
        {
            if (IsSimul)
                return true;

            if (!IsActivated)
                return false;

            uint status = 0;
            try {
                uint res = 0;
                res = CAXM.AxmSignalIsServoOn(Axis, ref status);
                if (res != (uint)AXT_FUNC_RESULT.AXT_RT_SUCCESS) {
                    Log.E($"AXM ReadInMotion Error : {Enum.GetName(typeof(AXT_FUNC_RESULT), res)}");
                    return false;
                }
            } catch (Exception ex) {
                Log.FuncE(ex.Message);
                return false;
            }
            return status == (uint)AXT_MOTION_SIGNAL_LEVEL.ACTIVE ? true : false;
        }
        public bool AlarmReset(int Axis)
        {
            if (IsSimul)
                return true;

            if (!IsActivated)
                return false;
            try {
                uint res = 0;
                res = CAXM.AxmSignalServoAlarmReset(Axis, (uint)AXT_USE.ENABLE);
                if (res != (uint)AXT_FUNC_RESULT.AXT_RT_SUCCESS) {
                    Log.E($"AXM AxmSignalServoAlarmReset Error : {Enum.GetName(typeof(AXT_FUNC_RESULT), res)}");
                    return false;
                }
            } catch (Exception ex) {
                Log.FuncE(ex.Message);
                return false;
            }
            return true;
        }

        public double ReadCurrentVelocity(int Axis)
        {
            if (IsSimul)
                return double.NaN;

            if (!IsActivated)
                return double.NaN;

            double status = 0;
            try {
                uint res = 0;
                res = CAXM.AxmStatusReadVel(Axis, ref status);
                if (res != (uint)AXT_FUNC_RESULT.AXT_RT_SUCCESS) {
                    Log.E($"AXM AxmStatusReadServoLoadRatio Error : {Enum.GetName(typeof(AXT_FUNC_RESULT), res)}");
                    return double.NaN;
                }
            } catch (Exception ex) {
                Log.FuncE(ex.Message);
                return double.NaN;
            }
            return status;
        }
        public bool GetAlarmStatus(int Axis)
        {
            if (IsSimul)
                return false;

            if (!IsActivated)
                return false;

            try {
                //res는 함수의 실행 결과 여부고 alarmCode에 따라서 알람 유무를 확인해야 함
                //Return True : Alarm 상태
                uint res = 0;
                uint alarmCode = 0;
                res = CAXM.AxmStatusReadServoAlarm(Axis, 0, ref alarmCode);
                if (res != (uint)AXT_FUNC_RESULT.AXT_RT_SUCCESS) {
                    Log.E($"AXM AxmStatusRequestServoAlarm Func Error : {Enum.GetName(typeof(AXT_FUNC_RESULT), res)}");
                    return true;
                } else {
                    if (alarmCode != 0) {
                        Log.E($"AXM AxmStatusRequestServoAlarm Error : {Enum.GetName(typeof(AXT_FUNC_RESULT), alarmCode)}");
                        return true;
                    } else
                        return false;
                }
            } catch (Exception ex) {
                Log.FuncE(ex.Message);
                return false;
            }
        }
        public const uint DPRAM_COMMON_CMD_SIIIH_SCAN = 0x74;

        public bool CheckXPosInterlock(bool XPosInterlockType, int Axis)
        {
            if (XPosInterlockType) {
                if (Axis == 1) {
                    bool bSuctionUp = false;
                    bool bSuctionDown = false;

                    bSuctionUp = _IO._iOUnit.ReadDiBit((Convert.ToInt32(ePTDIAddress.SUCTION_UP_CY)));
                    bSuctionDown = _IO._iOUnit.ReadDiBit((Convert.ToInt32(ePTDIAddress.SUCTION_DOWN_CY)));

                    if (bSuctionUp == true && bSuctionDown == false) {
                        return true;
                    } else
                        return false;
                } else
                    return true;

            } else
                return true;
        }
        public uint SSCNET_DeviceRescan(int Axis = -1)
        {
            int nBoardCnt = 0;
            double dCmdPos = 0;
            int nOldTick = 0, nNewTick = 0, nTickTime = 0;
            uint[] uSendData = new uint[22];
            uint uReturn;

            CAXL.AxlOpenNoReset(7);
            CAXL.AxlGetBoardCount(ref nBoardCnt);

            if (nBoardCnt < 1)
                return (uint)AXT_FUNC_RESULT.AXT_RT_OPEN_ERROR;

            System.Array.Clear(uSendData, 0, 22);

            //'AxlSetSendBoardCommand' 함수의 첫 번째 인자는 보드 넘버입니다.
            //PC에 장착한 순서에 따라 보드 넘버는 변경됩니다.
            //EzConfig UC을 통해 보드 넘버를 알 수 있습니다.
            uReturn = CAXDev.AxlSetSendBoardCommand(0, DPRAM_COMMON_CMD_SIIIH_SCAN, ref uSendData[21], 0);

            nOldTick = Environment.TickCount;
            if(Axis != -1) {
                while (true) {
                    //TimeOut Check
                    nNewTick = Environment.TickCount;

                    nTickTime = nNewTick - nOldTick;
                    if (nTickTime > 20000) {
                        MessageBox.Show("Scan Error");
                        return (uint)AXT_FUNC_RESULT.AXT_RT_OPEN_ERROR;
                    }

                    //Network Connect Check
                    uReturn = CAXM.AxmStatusGetCmdPos(Axis, ref dCmdPos);
                    if (uReturn == 0) {
                        break;
                    }
                }
            }

            //CAXM.AxmMotLoadParaAll(_config.MotionSettingsPath);

            CAXL.AxlClose();
            CAXL.AxlOpenNoReset(7);

            return (uint)AXT_FUNC_RESULT.AXT_RT_SUCCESS;
        }

        public int DeviceRescan()
        {
            try {
                int nBoardCnt = 0;
                uint[] uSendData = new uint[22];
                uint uReturn;

                CAXL.AxlOpenNoReset(7);
                CAXL.AxlGetBoardCount(ref nBoardCnt);

                if (nBoardCnt < 1)
                    throw new Exception("Board Count < 1");

                Array.Clear(uSendData, 0, 22);

                //'AxlSetSendBoardCommand' 함수의 첫 번째 인자는 보드 넘버입니다.
                //PC에 장착한 순서에 따라 보드 넘버는 변경됩니다.
                //EzConfig UC을 통해 보드 넘버를 알 수 있습니다.
                uReturn = CAXDev.AxlSetSendBoardCommand(0, DPRAM_COMMON_CMD_SIIIH_SCAN, ref uSendData[21], 0);
                if (uReturn != (uint)AXT_FUNC_RESULT.AXT_RT_SUCCESS) {
                    throw new Exception("Board Command Setting Fail");
                }

                return E1.OK;
            }
            catch (Exception ex) {
                Log.FuncE($"{ex.Message}");
                return E2.ABORTED;
            }
        }

        public bool CheckDeviceLive()
        {
            double dCmdPos = 0.0;
            uint uReturn = CAXM.AxmStatusGetCmdPos(0, ref dCmdPos);
            if ((uReturn != (uint)AXT_FUNC_RESULT.AXT_RT_SUCCESS)) {
                Log.E($"AXL CheckDeviceLive Error : {Enum.GetName(typeof(AXT_FUNC_RESULT), uReturn)}");
                return false;
            }

            return true;
        }
        public bool ReInitialize()
        {
            if (!Close())
                return false;

            var uReturn = CAXL.AxlOpenNoReset(7);
            if (uReturn != (uint)AXT_FUNC_RESULT.AXT_RT_SUCCESS) {
                Log.E($"AXL CheckDeviceRescan Error : {Enum.GetName(typeof(AXT_FUNC_RESULT), uReturn)}");
                return false;
            }

            return true;
        }
        public bool CheckRescan()
        {
            int boardNo = 0;
            int modulePos = 0;
            uint moduleId = 0;
            for(int i = 0; i<_config.TotalMotorCount; i++) {
                var rt = CAXM.AxmInfoGetAxis(i, ref boardNo, ref modulePos, ref moduleId);
                if (rt != (uint)AXT_FUNC_RESULT.AXT_RT_SUCCESS) {
                    return false;
                }

                if (boardNo != _config.UseBoardNo)
                    return false;

                if (0 > modulePos || modulePos > _config.TotalMotorCount)
                    return false;
            }

            return true;
        }
        public bool Rescan()
        {
            if (IsSimul)
                return true;

            if (!IsActivated)
                return true;

            try {
                // 객체 초기화
                if (CAXL.AxlIsOpened() == (int)AXT_BOOLEAN.FALSE) {
                    var res = CAXL.AxlOpen(0);
                    if (res != (uint)AXT_FUNC_RESULT.AXT_RT_SUCCESS) {
                        Log.E($"AXM AxlOpen Error : {Enum.GetName(typeof(AXT_FUNC_RESULT), res)}");
                        return false;
                    }
                }

                _SCAN_RESULT result = new _SCAN_RESULT();
                uint ret = CAXL.AxlScanStartSIIIH(ref result);
                if (ret != (uint)AXT_FUNC_RESULT.AXT_RT_SUCCESS) {
                    Log.E($"AXL AxlScanStartSIIIH Error : {Enum.GetName(typeof(AXT_FUNC_RESULT), ret)}");
                    return false;
                }

                if (result.lTotalBoardCount < 1) {
                    Log.E($"인식한 보드의 갯수가 {result.lTotalBoardCount}개입니다.");
                    return false;
                }

                if (result.BoardInfo[_config.UseBoardNo].lNodeCount != _config.TotalMotorCount) {
                    Log.E($"Config 모터 갯수({_config.TotalMotorCount})와 실제 모터 갯수({result.BoardInfo[_config.UseBoardNo].lNodeCount})가 다릅니다.");
                    return false;
                }
            }
            catch (Exception ex) {
                Log.FuncE(ex.Message);
                return false;
            }

            return true;
        }
        public int LoadMotFile()
        {
            if (IsSimul)
                return E1.OK;

            if (!IsActivated)
                return E1.OK;

            try {
                // Motion Param Setting File Load
                if (!string.IsNullOrEmpty(_config.MotionSettingsPath)) {
                    var res = CAXM.AxmMotLoadParaAll(_config.MotionSettingsPath);
                    if (res != (uint)AXT_FUNC_RESULT.AXT_RT_SUCCESS) {
                        Log.E($"AXM AxmMotLoadParaAll Error : {Enum.GetName(typeof(AXT_FUNC_RESULT), res)}");
                        return E2.ABORTED;
                    }
                    return E1.OK;
                }
                return E2.ABORTED;
            } catch (Exception ex) {
                Log.FuncE(ex.Message);
                return E2.ABORTED;
            }
        }
    }
}