ZZ-EFEM/Framework/AitexSorterRT/SorterCommonFrame/Routines/SwapRoutine.cs

using System;
using Aitex.Core.Common;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.Routine;
using Aitex.Core.RT.SCCore;
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 MECF.Framework.RT.EquipmentLibrary.HardwareUnits.Aligners.AlignersBase;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.Robots;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.Robots.RobotBase;
using System.Threading;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.LoadPorts.LoadPortBase;
using Aitex.Core.RT.Log;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.Flipper.FlipperBase;
using Aitex.Sorter.RT.SorterCommonFrame.Modules;

namespace Aitex.Sorter.RT.SorterCommonFrame.Routines
{
    public class SwapRoutine : CommonRoutineSorter, IRoutine
    {
        enum Swap
        {
            ReleaseAligner,
            WaitAlignerReady,
            TurnTo180,
            WaitTurnTo180,
            QueryState,
            CheckBeforeSwap,
            SwapWafer,
            WaitSwap,
            SwapPickExtend,
            WaitPickExtend,
            SwapUnGripTurnOver,
            WaitUnGripTurnOver,
            SwapPickRetract,
            WaitPickRetract,
            CheckAfterPick,
            SwapTurnBack,
            WaitTurnBack,
            SwapPlaceExtend,
            WaitPlaceExtend,
            SwapGrip,
            WaitGrip,
            SwapPlaceRetract,
            WaitPlaceRetract,
            TurnOver,
            WaitTurnOver,
            CheckAfterSwap,
            UpdateWaferOnPickBlade,
            UpdateWaferOnChamber,
            RaiseAligner,
            CheckWaferOnTurnOver,
            PickWafer,
            AlignerPrepareAccept,
            WaitAlignerReadyAfterPick,
            PlaceWafer,
        }

        private bool _isNeedToRaiseAligner = false;
        public SwapRoutine(string module, string name)
        {
            Module = module;
            Name = name;

        }

        public bool Initalize()
        {
            Reset();
            IsRoutineActive = false;
              // SC.GetConfigItem($"Robot.{ Robot.RobotModuleName}.TimeLimitForExchangeWafer");
            return true;
        }

        public ModuleName Source { get; set; }
        public ModuleName RobotModulename { get; set; } = ModuleName.Robot;
        public int Slot { get; set; }
        public Hand PlaceBlade { get; set; }
        public Hand PickBlade => GetPickBlade(PlaceBlade);



        public   Result Start(params object[] objs)
        {           
            Name = "Swap";
            Robot = DEVICE.GetDevice<RobotBaseDevice>(RobotModulename.ToString());
            Reset();

            if (!Robot.Blade2Enable && !Robot.Blade1Enable)
            {
                EV.PostAlarmLog(ModuleName.System.ToString(), $"Can not {Name}, not all blade is enable");
                return Result.FAIL;
            }
            


            FixedTurnOverPosition = SC.ContainsItem("Process.FixedTurnOverPosition") ? SC.GetValue<bool>("Process.FixedTurnOverPosition") : true;

            IsRoutineActive = true;
            if(WaferManager.Instance.CheckHasWafer(RobotModulename,(int)PickBlade))
            {
                EV.PostAlarmLog(ModuleName.System.ToString(), $"Robot:{RobotModulename} detect wafer on pick blade:{PickBlade}.");
                return Result.FAIL;
            }
            if (WaferManager.Instance.CheckNoWafer(RobotModulename, (int)PlaceBlade))
            {
                EV.PostAlarmLog(ModuleName.System.ToString(), $"Robot:{RobotModulename} detect no wafer on place blade:{PlaceBlade}.");
                return Result.FAIL;
            }


            if (ModuleHelper.IsAligner(Source) && !DEVICE.GetDevice<AlignerBaseDevice>(Source.ToString()).IsReady())
            {                
                EV.PostAlarmLog(ModuleName.System.ToString(), "Aligner is not ready.");
                return Result.FAIL;
            }
            if(ModuleHelper.IsTurnOverStation(Source) && !_ioTurnOver.IsReady)
            {
                EV.PostAlarmLog(ModuleName.System.ToString(), "Turn Over is not ready.");
                return Result.FAIL;
            }           
           
            if (ModuleHelper.IsTurnOverStation(Source))
            {
                _isTurnOverOn0deg = _ioTurnOver.CurrentFlipperPosition == FlipperPosEnum.FrontSide;
            }
            if (ModuleHelper.IsAligner(Source))
            {
                _isNeedToRaiseAligner = Aligner.IsNeedRelease;
                _isNeedPrepareAccept = Aligner.IsNeedPrepareBeforePlaceWafer();

            }
            if (ModuleHelper.IsLoadPort(Source))
            {
                var lp = DEVICE.GetDevice<LoadPortBaseDevice>(Source.ToString());
                if (lp.IsForbidAccessSlotAboveWafer() && Slot > 0 && WaferManager.Instance.CheckHasWafer(Source, Slot - 1))
                {
                    EV.PostAlarmLog(ModuleName.System.ToString(), "Access dennied to the slot above wafer.");
                    return Result.FAIL;
                }
                string reason;
                if (!lp.IsEnableTransferWafer(out reason))
                {
                    EV.PostAlarmLog(ModuleName.System.ToString(), $"{Source} is not ready to transfer wafer:{reason}.");
                    return Result.FAIL;
                }
            }

            if (!ModuleHelper.IsTurnOverStation(Source) && Source != ModuleName.Aligner)
            {
                if (!RobotOffsetConfig.Instance.GetPickOffset(Source, ref _offsetX, ref _offsetY, ref _offsetZ,
                    out string reason))
                {
                    EV.PostWarningLog(ModuleName.System.ToString(), $"Can not {Name}, {reason}");
                    return Result.FAIL;
                }
            }
            else
            {
                _offsetX = 0;
                _offsetY = 0;
                _offsetY = 0;
            }


            EV.PostInfoLog("System", $"Start swapping wafer from station:{Source} slot:{Slot + 1} with blade {PickBlade}");

            return Monitor();
        }
        private bool _isTurnOverOn0deg;
        private bool _isNeedPrepareAccept;
        public Result Monitor()
        {
            if (!IsRoutineActive) 
                return Result.DONE;
            var ret = MonitorRoutine();
            if(ret == Result.FAIL)
            {
                IsRoutineActive = false;
            }
            if (ret == Result.DONE)
            {
                IsRoutineActive = false;
            }
            return ret;
        }

        private Result MonitorRoutine()
        {
            try
            {
                if (ModuleHelper.IsAligner(Source))
                {
                    if (_isNeedToRaiseAligner)
                    {
                        RtReleaseAligner((int)Swap.ReleaseAligner, 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.DONE;
                        }
                        RtWaitAlignerMotion((int)Swap.WaitAlignerReady, Aligner, "Wait Aligner Ready", Aligner.TimeLimitAlignWafer, 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.DONE;
                        }
                    }
                    if(_isNeedPrepareAccept)
                    {
                        RtPickWaferForSwap((int)Swap.PickWafer,"Pick wafer for swap",Source,Slot,PickBlade, Robot.RobotCommandTimeout,_offsetX,_offsetY,_offsetZ, 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.DONE;
                        }
                        AlignerPostActionAfterPick((int)Swap.AlignerPrepareAccept, 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;
                        }
                        RtWaitAlignerMotion((int)Swap.WaitAlignerReadyAfterPick, Aligner, "Wait Aligner Ready", Aligner.TimeLimitAlignWafer, 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.DONE;
                        }
                        RtPlaceWafer((int)Swap.PlaceWafer,"Place wafer for swap",Source,Slot,PlaceBlade, Robot.RobotCommandTimeout, _offsetX, _offsetY, _offsetZ, 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.DONE;
                        }
                    }
                    else
                    {
                        RtSwapWafer((int)Swap.SwapWafer, "Swap wafer", Source, Slot, PickBlade, Robot.RobotCommandTimeout, 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.DONE;
                        }
                    }
                }
                if (ModuleHelper.IsLoadPort(Source) || ModuleHelper.IsBuffer(Source))
                {
                    RtSwapWafer((int)Swap.SwapWafer, "Swap wafer", Source, Slot, PickBlade, Robot.RobotCommandTimeout, 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.DONE;
                    }
                }
               

                if (ModuleHelper.IsTurnOverStation(Source))
                {
                    if (FixedTurnOverPosition)
                    {
                        if (_isTurnOverOn0deg)
                        {
                            RtTurnOverTurn((int)Swap.TurnTo180, 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.DONE;
                            }
                            RtWaitTurnOverTurnTo180((int)Swap.WaitTurnTo180, _ioTurnOver, _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.DONE;
                            }
                        }

                        RtRobotArmGoReadyForPickFromTurnOver((int)Swap.SwapPickExtend, Source, Slot, PickBlade, Robot.RobotCommandTimeout,
                            Notify, Stop, GetWaferOffsetForTurnOverOn180());
                        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.DONE;
                        }

                        RtTurnOverUnGripWafer((int)Swap.SwapUnGripTurnOver, 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.DONE;
                        }

                        RtWaitTurnOverMotion((int)Swap.WaitUnGripTurnOver, _ioTurnOver, _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.DONE;
                        }

                        RtPickWaferFromTurnOver((int)Swap.SwapPickRetract, Source, Slot, PickBlade,Robot.RobotCommandTimeout, Notify, Stop, GetWaferOffsetForTurnOverOn180());
                        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.DONE;
                        }

                        RtTurnOverTurnBack((int)Swap.SwapTurnBack, 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.DONE;
                        }

                        RtWaitTurnOverMotion((int)Swap.WaitTurnBack, _ioTurnOver, _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.DONE;
                        }

                        RtDeliverWaferToGrip((int)Swap.SwapPlaceExtend, Source, Slot, PlaceBlade, Robot.RobotCommandTimeout, 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.DONE;
                        }
                        RtTurnOverGripWafer((int)Swap.SwapGrip, 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.DONE;
                        }
                        RtWaitTurnOverMotion((int)Swap.WaitGrip, _ioTurnOver, _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.DONE;
                        }
                        RtRetractRobotArmForTurning((int)Swap.SwapPlaceRetract, Source, Slot, PlaceBlade, Robot.RobotCommandTimeout, 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.DONE;
                        }
                        RtCheckWaferOnTurn((int)Swap.CheckWaferOnTurnOver, 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.DONE;
                        }
                        RtTurnOverTurn((int)Swap.TurnOver, 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.DONE;
                        }
                    }
                    else
                    {
                        if (_isTurnOverOn0deg)
                        {
                            RtRobotArmGoReadyForPickFromTurnOver((int)Swap.SwapPickExtend, Source, Slot, PickBlade, Robot.RobotCommandTimeout, 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.DONE;
                            }
                            RtTurnOverUnGripWafer((int)Swap.SwapUnGripTurnOver, 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.DONE;
                            }
                            RtWaitTurnOverMotion((int)Swap.WaitUnGripTurnOver, _ioTurnOver, _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.DONE;
                            }
                            RtPickWaferFromTurnOver((int)Swap.SwapPickRetract, Source, Slot, PickBlade, Robot.RobotCommandTimeout, 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.DONE;
                            }
                            RtDeliverWaferToGrip((int)Swap.SwapPlaceExtend, Source, Slot, PlaceBlade, Robot.RobotCommandTimeout, 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.DONE;
                            }
                            RtTurnOverGripWafer((int)Swap.SwapGrip, 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.DONE;
                            }
                            RtWaitTurnOverMotion((int)Swap.WaitGrip, _ioTurnOver, _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.DONE;
                            }
                            RtRetractRobotArmForTurning((int)Swap.SwapPlaceRetract, Source, Slot, PlaceBlade, Robot.RobotCommandTimeout, 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.DONE;
                            }
                            RtCheckWaferOnTurn((int)Swap.CheckWaferOnTurnOver, 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.DONE;
                            }
                            RtTurnOverTurn((int)Swap.TurnOver, 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.DONE;
                            }
                        }
                        else
                        {
                            RtRobotArmGoReadyForPickFromTurnOver((int)Swap.SwapPickExtend, Source, Slot, PickBlade, Robot.RobotCommandTimeout, Notify, Stop,
                                GetWaferOffsetForTurnOverOn180());
                            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.DONE;
                            }
                            RtTurnOverUnGripWafer((int)Swap.SwapUnGripTurnOver, 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.DONE;
                            }
                            RtWaitTurnOverMotion((int)Swap.WaitUnGripTurnOver, _ioTurnOver, _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.DONE;
                            }
                            RtPickWaferFromTurnOver((int)Swap.SwapPickRetract, Source, Slot, PickBlade, Robot.RobotCommandTimeout, Notify, Stop,
                                GetWaferOffsetForTurnOverOn180());
                            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.DONE;
                            }
                            RtDeliverWaferToGrip((int)Swap.SwapPlaceExtend, Source, Slot, PlaceBlade, Robot.RobotCommandTimeout, Notify, Stop,
                                PutWaferOffsetForTurnOverOn180());
                            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.DONE;
                            }
                            RtTurnOverGripWafer((int)Swap.SwapGrip, 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.DONE;
                            }
                            RtWaitTurnOverMotion((int)Swap.WaitGrip, _ioTurnOver, _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.DONE;
                            }
                            RtRetractRobotArmForTurning((int)Swap.SwapPlaceRetract, Source, Slot, PlaceBlade, Robot.RobotCommandTimeout, Notify, Stop,
                                PutWaferOffsetForTurnOverOn180());
                            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.DONE;
                            }
                            RtCheckWaferOnTurn((int)Swap.CheckWaferOnTurnOver, 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.DONE;
                            }
                            RtTurnOverTurnBack((int)Swap.TurnOver, 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.DONE;
                            }
                        }
                    }
                }
                RtUpdateWaferSingleStepProcessState((int)Swap.UpdateWaferOnPickBlade, "Update process state on robot", RobotModulename, 0, PickBlade,
                     EnumWaferProcessStatus.Idle, 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.DONE;
                }
                RtUpdateWaferSingleStepProcessState((int)Swap.UpdateWaferOnChamber, "Update process state on chamber", Source, Slot, PickBlade,
                     EnumWaferProcessStatus.Wait, 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.DONE;
                }




                EV.PostInfoLog("System", $"Complete swapping wafer from station:{Source} slot:{Slot + 1} with blade {PickBlade}.");

                //EV.PostMessage(ModuleName.System.ToString(), EventEnum.GeneralInfo, string.Format("Swap wafer {0}{1:D2} place blade {2}", Source.ToString(), Slot+1, PlaceBlade.ToString()));
                IsRoutineActive = false;
                return Result.DONE;

            }

            catch (Exception ex)
            {
                LOG.Write(ex);
                EV.PostAlarmLog("System", $"Failed to swap wafer from station:{Source} slot:{Slot + 1} with blade {PickBlade}.");
                IsRoutineActive = false;
                return Result.FAIL;
            }
        }

        protected override void Notify(string message)
        {
            EV.PostMessage(Module, EventEnum.GeneralInfo, String.Format("Swap wafer:{0}", message));
        }

        /// <summary>
        /// prepare process failed
        /// </summary>
        /// <param name="failReason"></param>
        /// <param name="reactor"></param>
        protected override void Stop(string failReason)
        {
            string reason = String.Empty;
            EV.PostMessage(ModuleName.System.ToString(), EventEnum.GeneralInfo, string.Format("Swap wafer {0}{1:D2} with arm {2} failed, {3}", Source.ToString(), Slot+1, PlaceBlade.ToString(), failReason));
        }

       

        private Hand GetPickBlade(Hand placeBlade)
        {
            return PlaceBlade == Hand.Blade1 ? Hand.Blade2 : Hand.Blade1;
        }

       

     }
}