ZZ-EFEM/Framework/AitexSorterRT/SorterCommonFrame/EfemRoutine/EfemInitRoutine.cs

using System;
using Aitex.Core.Common;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.Device.Unit;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.Routine;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Util;
using Aitex.Sorter.Common;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.Robot;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.SubstrateTrackings;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.LoadPorts;
using SorterCommon;
using Aitex.Sorter.RT.SorterCommonFrame.Devices;
using Aitex.Sorter.RT.SorterCommonFrame.SorterJobControl;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.Aligners.AlignersBase;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.Robots.RobotBase;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.LoadPorts.LoadPortBase;
using MECF.Framework.FA.Core.FAControl;
using Aitex.Core.RT.Log;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.Flipper.FlipperBase;

namespace Aitex.Sorter.RT.SorterCommonFrame.Routines
{
    public class EfemInitRoutine : CommonRoutineSorter, IRoutine
    {
        private enum Home
        {
            DeviceReset,

            RobotClear,        

            RobotHome,
            WaitingRobotHome,

            RobotSet,

            AlignClear,

            AlignerInit,
            WaitingAlignerInit,

            AlignerHome,
            WaitingAlignerHome,
            AlignerMoveUp,
            WaitingAlignerUp,
            
            TurnoverHome,
            WaitTurnoverHome,
            TurnOverTurnTo0,
            WaitTurnOverTurnTo0,
            TurnOverUngrip,
            WaitTurnOverUnGrip,

            LoadportAClear,
            LoadportAHome,
            WaitingLoadportAHome,

            LoadportBClear,
            LoadportBHome,
            WaitingLoadportBHome,
            
            LoadportCClear,
            LoadportCHome,
            WaitingLoadportCHome,
            
            LoadportDClear,
            LoadportDHome,
            WaitingLoadportDHome,

            LoadportEClear,
            LoadportEHome,
            WaitingLoadportEHome,

            LoadportFClear,
            LoadportFHome,
            WaitingLoadportFHome,

            LoadportGClear,
            LoadportGHome,
            WaitingLoadportGHome,

            LoadportHClear,
            LoadportHHome,
            WaitingLoadportHHome,

            LoadportIClear,
            LoadportIHome,
            WaitingLoadportIHome,

            LoadportJClear,
            LoadportJHome,
            WaitingLoadportJHome,

        }


        private int _timeoutTurnover = 0;
        private int _timeoutRobot = 0;
        private int _lpcount = 0;
        private int _timeoutaligner;

        public bool IsResetOnly { get; set; }

        public ModuleName InitModuleName { get; set; }

        public EfemInitRoutine(string module, string name)
        {
            Module = module;
            Name = name;           
            
            _lpcount = SorterJobManager.Instance.SorterDeviceManagerCallBack.GetAllLoadPorts().Length;
        }


        public bool Initalize()
        {
            Reset();
            IsRoutineActive = false;
            return true;
        }


        public void Terminate()
        {
            
        }


        public Result Start(params object[] objs)
        {
            Name = "Init";
            Reset();

            _timeoutRobot = Robot.RobotCommandTimeout;
            _timeoutaligner = Aligner!=null?Aligner.TimeLimitAlignerHome:60;
            _timeoutTurnover = _ioTurnOver!=null? _ioTurnOver.TimelimitAction:60;
            EV.PostMessage(ModuleName.System.ToString(), EventEnum.HomeBegins, ModuleName.System.ToString());
            Robot = DEVICE.GetDevice<RobotBaseDevice>(DeviceName.Robot);
            _lpcount = SorterJobManager.Instance.SorterDeviceManagerCallBack.GetAllLoadPorts().Length;
            if (_ioTurnOver != null)
            {
                if (_ioTurnOver.IsPlacement)
                {
                    if (WaferManager.Instance.CheckNoWafer(ModuleName.TurnOverStation, 0))
                        WaferManager.Instance.CreateWafer(ModuleName.TurnOverStation, 0, WaferStatus.Normal);
                }
            }
            if(ModuleHelper.IsLoadPort(InitModuleName))
            {
                var lp = DEVICE.GetDevice<LoadPortBaseDevice>(InitModuleName.ToString());

                if (lp == null) return Result.FAIL;

            }

            if (ModuleHelper.IsAligner(InitModuleName))
            {
                var pa = DEVICE.GetDevice<AlignerBaseDevice>(InitModuleName.ToString());

                if (pa == null) return Result.FAIL;

            }
            if (ModuleHelper.IsRobot(InitModuleName))
            {
                var robot = DEVICE.GetDevice<RobotBaseDevice>(InitModuleName.ToString());

                if (robot == null) return Result.FAIL;

            }


            IsRoutineActive = true;
            return Result.RUN;
        }


        public Result Monitor()
        {
            if (!IsRoutineActive)
                return Result.DONE;
            var ret = MonitorRoutine();
            if (ret == Result.FAIL)
            {
                Initalize();
                IsRoutineActive = false;
            }
            if (ret == Result.DONE)
            {
                IsRoutineActive = false;
            }
            return ret;
            
        }
        private Result MonitorRoutine()
        {
            try
            {
                //RtDeviceReset((int)Home.DeviceReset, "Device Reset", 1, Notify, Stop);
                //if (ExecuteResult.Item1)
                //{
                //    if (ExecuteResult.Item2 == Result.RUN) return Result.RUN;
                //    if (ExecuteResult.Item2 == Result.FAIL) return Result.FAIL;
                //    if (ExecuteResult.Item2 == Result.TIMEOUT) return Result.FAIL;
                //    if (ExecuteResult.Item2 == Result.DONE) return Result.RUN;
                //}

                if (InitModuleName == ModuleName.System)
                {
                    RtRobotReset((int)Home.RobotClear, Robot, _timeoutRobot, Notify, Stop);
                    if (ExecuteResult.Item1)
                    {
                        if (ExecuteResult.Item2 == Result.RUN) return Result.RUN;
                        if (ExecuteResult.Item2 == Result.FAIL) return Result.FAIL;
                        if (ExecuteResult.Item2 == Result.TIMEOUT) return Result.FAIL;
                        if (ExecuteResult.Item2 == Result.DONE) return Result.RUN;
                    }                    

                    RtRobotHome((int)Home.RobotHome, Robot, _timeoutRobot, Notify, Stop);
                    if (ExecuteResult.Item1)
                    {
                        if (ExecuteResult.Item2 == Result.RUN) return Result.RUN;
                        if (ExecuteResult.Item2 == Result.FAIL) return Result.FAIL;
                        if (ExecuteResult.Item2 == Result.TIMEOUT) return Result.FAIL;
                        if (ExecuteResult.Item2 == Result.DONE) return Result.RUN;
                    }



                    if (Aligner != null)
                    {
                        RtAlignerInit((int)Home.AlignerInit, Aligner, "Aligner initialize", _timeoutRobot, Notify, Stop);
                        if (ExecuteResult.Item1)
                        {
                            if (ExecuteResult.Item2 == Result.RUN) return Result.RUN;
                            if (ExecuteResult.Item2 == Result.FAIL) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.TIMEOUT) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.DONE) return Result.RUN;
                        }

                    }



                    if (_ioTurnOver != null)
                    {
                        RtTurnoverHome((int)Home.TurnoverHome, _ioTurnOver.TimelimitAction, Notify, Stop);
                        if (ExecuteResult.Item1)
                        {
                            if (ExecuteResult.Item2 == Result.RUN) return Result.RUN;
                            if (ExecuteResult.Item2 == Result.FAIL) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.TIMEOUT) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.DONE) return Result.RUN;
                        }

                        RtTurnOverTurnBack((int)Home.TurnOverTurnTo0, Notify, Stop);
                        if (ExecuteResult.Item1)
                        {
                            if (ExecuteResult.Item2 == Result.RUN) return Result.RUN;
                            if (ExecuteResult.Item2 == Result.FAIL) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.TIMEOUT) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.DONE) return Result.RUN;
                        }



                        RtWaitTurnOverTurnTo0((int)Home.WaitTurnOverTurnTo0, _ioTurnOver, _timeoutTurnover, Notify, Stop);
                        if (ExecuteResult.Item1)
                        {
                            if (ExecuteResult.Item2 == Result.RUN) return Result.RUN;
                            if (ExecuteResult.Item2 == Result.FAIL) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.TIMEOUT) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.DONE) return Result.RUN;
                        }


                        if (!_ioTurnOver.IsPlacement)
                        {
                            RtTurnOverUnGripWafer((int)Home.WaitTurnOverUnGrip, Notify, Stop);
                            if (ExecuteResult.Item1)
                            {
                                if (ExecuteResult.Item2 == Result.RUN) return Result.RUN;
                                if (ExecuteResult.Item2 == Result.FAIL) return Result.FAIL;
                                if (ExecuteResult.Item2 == Result.TIMEOUT) return Result.FAIL;
                                if (ExecuteResult.Item2 == Result.DONE) return Result.RUN;
                            }



                            RtWaitTurnOverUnGrip((int)Home.WaitTurnOverUnGrip, _ioTurnOver, _timeoutTurnover, Notify, Stop);
                            if (ExecuteResult.Item1)
                            {
                                if (ExecuteResult.Item2 == Result.RUN) return Result.RUN;
                                if (ExecuteResult.Item2 == Result.FAIL) return Result.FAIL;
                                if (ExecuteResult.Item2 == Result.TIMEOUT) return Result.FAIL;
                                if (ExecuteResult.Item2 == Result.DONE) return Result.RUN;
                            }

                        }
                    }

                    if (_lpcount > 0 &&
                        Singleton<FAJobController>.Instance.FAloadports["LP1"].GetTransferState() != LPTransferState.OUT_OF_SERVICE)
                    {
                        RtLoadportReset((int)Home.LoadportAClear, DEVICE.GetDevice<LoadPortBaseDevice>("LP1"), DEVICE.GetDevice<LoadPortBaseDevice>("LP1").TimelimitHome, Notify, Stop);
                        if (ExecuteResult.Item1)
                        {
                            if (ExecuteResult.Item2 == Result.RUN) return Result.RUN;
                            if (ExecuteResult.Item2 == Result.FAIL) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.TIMEOUT) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.DONE) return Result.RUN;
                        }

                        RtLoadportInit((int)Home.LoadportAHome, DEVICE.GetDevice<LoadPortBaseDevice>("LP1"), DEVICE.GetDevice<LoadPortBaseDevice>("LP1").TimelimitHome, Notify, Stop);
                        if (ExecuteResult.Item1)
                        {
                            if (ExecuteResult.Item2 == Result.RUN) return Result.RUN;
                            if (ExecuteResult.Item2 == Result.FAIL) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.TIMEOUT) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.DONE) return Result.RUN;
                        }
                    }
                    if (_lpcount > 1 &&
                        Singleton<FAJobController>.Instance.FAloadports["LP2"].GetTransferState() != LPTransferState.OUT_OF_SERVICE)
                    {
                        RtLoadportReset((int)Home.LoadportBClear, DEVICE.GetDevice<LoadPortBaseDevice>("LP2"), DEVICE.GetDevice<LoadPortBaseDevice>("LP2").TimelimitHome, Notify, Stop);
                        if (ExecuteResult.Item1)
                        {
                            if (ExecuteResult.Item2 == Result.RUN) return Result.RUN;
                            if (ExecuteResult.Item2 == Result.FAIL) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.TIMEOUT) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.DONE) return Result.RUN;
                        }

                        RtLoadportInit((int)Home.LoadportBHome, DEVICE.GetDevice<LoadPortBaseDevice>("LP2"), DEVICE.GetDevice<LoadPortBaseDevice>("LP2").TimelimitHome, Notify, Stop);
                        if (ExecuteResult.Item1)
                        {
                            if (ExecuteResult.Item2 == Result.RUN) return Result.RUN;
                            if (ExecuteResult.Item2 == Result.FAIL) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.TIMEOUT) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.DONE) return Result.RUN;
                        }
                    }
                    if (_lpcount > 2 &&
                        Singleton<FAJobController>.Instance.FAloadports["LP3"].GetTransferState() != LPTransferState.OUT_OF_SERVICE)
                    {
                        RtLoadportReset((int)Home.LoadportCClear, DEVICE.GetDevice<LoadPortBaseDevice>("LP3"), DEVICE.GetDevice<LoadPortBaseDevice>("LP3").TimelimitHome, Notify, Stop);
                        if (ExecuteResult.Item1)
                        {
                            if (ExecuteResult.Item2 == Result.RUN) return Result.RUN;
                            if (ExecuteResult.Item2 == Result.FAIL) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.TIMEOUT) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.DONE) return Result.RUN;
                        }

                        RtLoadportInit((int)Home.LoadportCHome, DEVICE.GetDevice<LoadPortBaseDevice>("LP3"), DEVICE.GetDevice<LoadPortBaseDevice>("LP3").TimelimitHome, Notify, Stop);
                        if (ExecuteResult.Item1)
                        {
                            if (ExecuteResult.Item2 == Result.RUN) return Result.RUN;
                            if (ExecuteResult.Item2 == Result.FAIL) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.TIMEOUT) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.DONE) return Result.RUN;
                        }
                    }
                    if (_lpcount > 3 &&
                        Singleton<FAJobController>.Instance.FAloadports["LP4"].GetTransferState() != LPTransferState.OUT_OF_SERVICE)
                    {
                        RtLoadportReset((int)Home.LoadportDClear, DEVICE.GetDevice<LoadPortBaseDevice>("LP4"), DEVICE.GetDevice<LoadPortBaseDevice>("LP4").TimelimitHome, Notify, Stop);
                        if (ExecuteResult.Item1)
                        {
                            if (ExecuteResult.Item2 == Result.RUN) return Result.RUN;
                            if (ExecuteResult.Item2 == Result.FAIL) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.TIMEOUT) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.DONE) return Result.RUN;
                        }

                        RtLoadportInit((int)Home.LoadportDHome, DEVICE.GetDevice<LoadPortBaseDevice>("LP4"), DEVICE.GetDevice<LoadPortBaseDevice>("LP4").TimelimitHome, Notify, Stop);
                        if (ExecuteResult.Item1)
                        {
                            if (ExecuteResult.Item2 == Result.RUN) return Result.RUN;
                            if (ExecuteResult.Item2 == Result.FAIL) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.TIMEOUT) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.DONE) return Result.RUN;
                        }
                    }
                    if (_lpcount > 4 &&
                        Singleton<FAJobController>.Instance.FAloadports["LP5"].GetTransferState() != LPTransferState.OUT_OF_SERVICE)
                    {
                        RtLoadportReset((int)Home.LoadportEClear, DEVICE.GetDevice<LoadPortBaseDevice>("LP5"), DEVICE.GetDevice<LoadPortBaseDevice>("LP5").TimelimitHome, Notify, Stop);
                        if (ExecuteResult.Item1)
                        {
                            if (ExecuteResult.Item2 == Result.RUN) return Result.RUN;
                            if (ExecuteResult.Item2 == Result.FAIL) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.TIMEOUT) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.DONE) return Result.RUN;
                        }

                        RtLoadportInit((int)Home.LoadportEHome, DEVICE.GetDevice<LoadPortBaseDevice>("LP5"), DEVICE.GetDevice<LoadPortBaseDevice>("LP5").TimelimitHome, Notify, Stop);
                        if (ExecuteResult.Item1)
                        {
                            if (ExecuteResult.Item2 == Result.RUN) return Result.RUN;
                            if (ExecuteResult.Item2 == Result.FAIL) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.TIMEOUT) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.DONE) return Result.RUN;
                        }
                    }
                    if (_lpcount > 5 &&
                        Singleton<FAJobController>.Instance.FAloadports["LP6"].GetTransferState() != LPTransferState.OUT_OF_SERVICE)
                    {
                        RtLoadportReset((int)Home.LoadportFClear, DEVICE.GetDevice<LoadPortBaseDevice>("LP6"), DEVICE.GetDevice<LoadPortBaseDevice>("LP5").TimelimitHome, Notify, Stop);
                        if (ExecuteResult.Item1)
                        {
                            if (ExecuteResult.Item2 == Result.RUN) return Result.RUN;
                            if (ExecuteResult.Item2 == Result.FAIL) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.TIMEOUT) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.DONE) return Result.RUN;
                        }

                        RtLoadportInit((int)Home.LoadportFHome, DEVICE.GetDevice<LoadPortBaseDevice>("LP6"), DEVICE.GetDevice<LoadPortBaseDevice>("LP6").TimelimitHome, Notify, Stop);
                        if (ExecuteResult.Item1)
                        {
                            if (ExecuteResult.Item2 == Result.RUN) return Result.RUN;
                            if (ExecuteResult.Item2 == Result.FAIL) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.TIMEOUT) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.DONE) return Result.RUN;
                        }
                    }
                    if (_lpcount > 6 &&
                        Singleton<FAJobController>.Instance.FAloadports["LP7"].GetTransferState() != LPTransferState.OUT_OF_SERVICE)
                    {
                        RtLoadportReset((int)Home.LoadportGClear, DEVICE.GetDevice<LoadPortBaseDevice>("LP7"), DEVICE.GetDevice<LoadPortBaseDevice>("LP7").TimelimitHome, Notify, Stop);
                        if (ExecuteResult.Item1)
                        {
                            if (ExecuteResult.Item2 == Result.RUN) return Result.RUN;
                            if (ExecuteResult.Item2 == Result.FAIL) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.TIMEOUT) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.DONE) return Result.RUN;
                        }
                        RtLoadportInit((int)Home.LoadportGHome, DEVICE.GetDevice<LoadPortBaseDevice>("LP7"), DEVICE.GetDevice<LoadPortBaseDevice>("LP7").TimelimitHome, Notify, Stop);
                        if (ExecuteResult.Item1)
                        {
                            if (ExecuteResult.Item2 == Result.RUN) return Result.RUN;
                            if (ExecuteResult.Item2 == Result.FAIL) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.TIMEOUT) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.DONE) return Result.RUN;
                        }
                    }
                    if (_lpcount > 7 &&
                        Singleton<FAJobController>.Instance.FAloadports["LP8"].GetTransferState() != LPTransferState.OUT_OF_SERVICE)
                    {
                        RtLoadportReset((int)Home.LoadportHClear, DEVICE.GetDevice<LoadPortBaseDevice>("LP8"), DEVICE.GetDevice<LoadPortBaseDevice>("LP8").TimelimitHome, Notify, Stop);
                        if (ExecuteResult.Item1)
                        {
                            if (ExecuteResult.Item2 == Result.RUN) return Result.RUN;
                            if (ExecuteResult.Item2 == Result.FAIL) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.TIMEOUT) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.DONE) return Result.RUN;
                        }
                        RtLoadportInit((int)Home.LoadportHHome, DEVICE.GetDevice<LoadPortBaseDevice>("LP8"), DEVICE.GetDevice<LoadPortBaseDevice>("LP8").TimelimitHome, Notify, Stop);
                        if (ExecuteResult.Item1)
                        {
                            if (ExecuteResult.Item2 == Result.RUN) return Result.RUN;
                            if (ExecuteResult.Item2 == Result.FAIL) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.TIMEOUT) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.DONE) return Result.RUN;
                        }

                    }
                    if (_lpcount > 8 &&
                        Singleton<FAJobController>.Instance.FAloadports["LP9"].GetTransferState() != LPTransferState.OUT_OF_SERVICE)
                    {
                        RtLoadportReset((int)Home.LoadportIClear, DEVICE.GetDevice<LoadPortBaseDevice>("LP9"), DEVICE.GetDevice<LoadPortBaseDevice>("LP9").TimelimitHome, Notify, Stop);
                        if (ExecuteResult.Item1)
                        {
                            if (ExecuteResult.Item2 == Result.RUN) return Result.RUN;
                            if (ExecuteResult.Item2 == Result.FAIL) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.TIMEOUT) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.DONE) return Result.RUN;
                        }
                        RtLoadportInit((int)Home.LoadportIHome, DEVICE.GetDevice<LoadPortBaseDevice>("LP9"), DEVICE.GetDevice<LoadPortBaseDevice>("LP9").TimelimitHome, Notify, Stop);
                        if (ExecuteResult.Item1)
                        {
                            if (ExecuteResult.Item2 == Result.RUN) return Result.RUN;
                            if (ExecuteResult.Item2 == Result.FAIL) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.TIMEOUT) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.DONE) return Result.RUN;
                        }
                        //WaitLoadportMotion((int)Home.WaitingLoadportIHome, DEVICE.GetDevice<LoadPortBaseDevice>("LP9"), "LP9 Homing...", DEVICE.GetDevice<LoadPortBaseDevice>("LP9").TimelimitHome, Notify, Stop);
                    }
                    if (_lpcount > 9 &&
                        Singleton<FAJobController>.Instance.FAloadports["LP10"].GetTransferState() != LPTransferState.OUT_OF_SERVICE)
                    {
                        RtLoadportReset((int)Home.LoadportHClear, DEVICE.GetDevice<LoadPortBaseDevice>("LP10"), DEVICE.GetDevice<LoadPortBaseDevice>("LP10").TimelimitHome, Notify, Stop);
                        if (ExecuteResult.Item1)
                        {
                            if (ExecuteResult.Item2 == Result.RUN) return Result.RUN;
                            if (ExecuteResult.Item2 == Result.FAIL) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.TIMEOUT) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.DONE) return Result.RUN;
                        }
                        RtLoadportInit((int)Home.LoadportHHome, DEVICE.GetDevice<LoadPortBaseDevice>("LP10"), DEVICE.GetDevice<LoadPortBaseDevice>("LP10").TimelimitHome, Notify, Stop);
                        if (ExecuteResult.Item1)
                        {
                            if (ExecuteResult.Item2 == Result.RUN) return Result.RUN;
                            if (ExecuteResult.Item2 == Result.FAIL) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.TIMEOUT) return Result.FAIL;
                            if (ExecuteResult.Item2 == Result.DONE) return Result.RUN;
                        }
                    }
                    if (ExecuteResult.Item1)
                    {
                        if (ExecuteResult.Item2 == Result.RUN) return Result.RUN;
                        if (ExecuteResult.Item2 == Result.FAIL) return Result.FAIL;
                        if (ExecuteResult.Item2 == Result.TIMEOUT) return Result.FAIL;
                        if (ExecuteResult.Item2 == Result.DONE) return Result.RUN;
                    }
                }

                if(ModuleHelper.IsLoadPort(InitModuleName))
                {
                    RtLoadportReset((int)Home.LoadportHClear, DEVICE.GetDevice<LoadPortBaseDevice>(InitModuleName.ToString()), DEVICE.GetDevice<LoadPortBaseDevice>(InitModuleName.ToString()).TimelimitHome, Notify, Stop);
                    if (ExecuteResult.Item1)
                    {
                        if (ExecuteResult.Item2 == Result.RUN) return Result.RUN;
                        if (ExecuteResult.Item2 == Result.FAIL) return Result.FAIL;
                        if (ExecuteResult.Item2 == Result.TIMEOUT) return Result.FAIL;
                        if (ExecuteResult.Item2 == Result.DONE) return Result.RUN;
                    }
                    RtLoadportInit((int)Home.LoadportHHome, DEVICE.GetDevice<LoadPortBaseDevice>(InitModuleName.ToString()), DEVICE.GetDevice<LoadPortBaseDevice>(InitModuleName.ToString()).TimelimitHome, Notify, Stop);
                    if (ExecuteResult.Item1)
                    {
                        if (ExecuteResult.Item2 == Result.RUN) return Result.RUN;
                        if (ExecuteResult.Item2 == Result.FAIL) return Result.FAIL;
                        if (ExecuteResult.Item2 == Result.TIMEOUT) return Result.FAIL;
                        if (ExecuteResult.Item2 == Result.DONE) return Result.RUN;
                    }
                }

                if (ModuleHelper.IsAligner(InitModuleName))
                {
                    RtAlignerInit((int)Home.AlignerInit, Aligner, "Aligner initialize", _timeoutRobot, Notify, Stop);
                    if (ExecuteResult.Item1)
                    {
                        if (ExecuteResult.Item2 == Result.RUN) return Result.RUN;
                        if (ExecuteResult.Item2 == Result.FAIL) return Result.FAIL;
                        if (ExecuteResult.Item2 == Result.TIMEOUT) return Result.FAIL;
                        if (ExecuteResult.Item2 == Result.DONE) return Result.RUN;
                    }
                }

                if (ModuleHelper.IsRobot(InitModuleName))
                {
                    RtRobotReset((int)Home.RobotClear, Robot, _timeoutRobot, Notify, Stop);
                    if (ExecuteResult.Item1)
                    {
                        if (ExecuteResult.Item2 == Result.RUN) return Result.RUN;
                        if (ExecuteResult.Item2 == Result.FAIL) return Result.FAIL;
                        if (ExecuteResult.Item2 == Result.TIMEOUT) return Result.FAIL;
                        if (ExecuteResult.Item2 == Result.DONE) return Result.RUN;
                    }

                    RtRobotHome((int)Home.RobotHome, Robot, _timeoutRobot, Notify, Stop);
                    if (ExecuteResult.Item1)
                    {
                        if (ExecuteResult.Item2 == Result.RUN) return Result.RUN;
                        if (ExecuteResult.Item2 == Result.FAIL) return Result.FAIL;
                        if (ExecuteResult.Item2 == Result.TIMEOUT) return Result.FAIL;
                        if (ExecuteResult.Item2 == Result.DONE) return Result.RUN;
                    }
                }


                EV.PostInfoLog("System", $"Complete home all routine.");
                IsRoutineActive = false;
                return Result.DONE;

            }
            catch (Exception ex)
            {
                LOG.Write(ex);
                EV.PostAlarmLog("System", "Initialize routine execute failed.");
                return Result.FAIL;
            }
        }

        public void RtTurnoverHome(int id, int time,Action<string> notify, Action<string> error)
        {
            string reason = string.Empty;
            
            Tuple<bool, Result> ret = ExecuteAndWait(id, () =>
            {
                notify("Turnover start homing");
                    return _ioTurnOver.ExecuteHome(out reason);
            }, () =>
            {
                if (_ioTurnOver.IsReady)
                    return Result.DONE;
                
                return Result.RUN;
             },time * 1000);

            if (ret.Item1)
            {
                if (ret.Item2 == Result.FAIL)
                {
                    error($"Turnover home failed, due to turnover occurred error.");
                }
                else if (ret.Item2 == Result.TIMEOUT) //timeout
                {
                    error($"Turnover home timeout, than {time} seconds.");

                }
            }
        }



        protected void RtDeviceReset(int id, string name, int time, Action<string> notify, Action<string> error)
        {
            var ret = Delay(id, () =>
                {
                    notify(string.Format("Device reset"));
                    if (Singleton<SorterJobManager>.Instance.SorterDeviceManagerCallBack != null)
                        Singleton<SorterJobManager>.Instance.SorterDeviceManagerCallBack.ResetDevices();

                    return true;
                }, time * 1000);

            if (ret.Item1)
                if (ret.Item2 == Result.FAIL)
                    error("Device reset failed.");
        }


        #region aligner

        public void RtAlignerReset(int id, AlignerBaseDevice device, string name, int time, Action<string> notify,
            Action<string> error)
        {
            var ret = ExecuteAndWait(id, () =>
                {
                    notify(string.Format("{0} clear error", device.Name));
                    var reason = string.Empty;
                    return device.AlignerReset(out _);
                }, () =>
                {
                    if (device.IsReady()) return Result.DONE;
                    if (device.AlignerState == AlignerStateEnum.Error && !device.IsBusy)
                        return Result.FAIL;
                    return Result.RUN;
                }, time * 1000);

            if (ret.Item1)
            {
                if (ret.Item2 == Result.FAIL)
                {
                    error(string.Format("{0} failed.", name));
                }
                else if (ret.Item2 == Result.TIMEOUT) //timeout
                {
                    error(string.Format("{0} timeout, than {1} seconds.", name, time));
                    
                }
                else
                {
                    
                }
            }
        }

        public void RtAlignerInit(int id, AlignerBaseDevice device, string name, int time,Action<string> notify, Action<string> error)
        {
            var ret = ExecuteAndWait(id, () =>
            {
                notify(string.Format("{0} Init", device.Name));
                var reason = string.Empty;
                return device.Home(out reason);
            }, () =>
            {
                if (device.IsReady()) return  Result.DONE;
                if (device.AlignerState == AlignerStateEnum.Error && !device.IsBusy)
                    return Result.FAIL;
                return Result.RUN; ;
            });

            if (ret.Item1)
            {
                if (ret.Item2 == Result.FAIL)
                {
                    error(string.Format("{0} failed.", name));
                }
                else if (ret.Item2 == Result.TIMEOUT) //timeout
                {
                    error(string.Format("{0} timeout, than {1} seconds.", name, time));
                    
                }
                else
                {
                    
                }
            }
        }


       

        #endregion


        #region Loadport

        ///等待 Loadport
     

        #endregion

    }
}