FurnaceELK/Furnace/FurnaceRT/Equipments/WaferRobots/WaferRobotPlace.cs

using Aitex.Core.RT.Routine;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Util;
using Aitex.Sorter.Common;
using DocumentFormat.OpenXml.Bibliography;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.Schedulers;
using MECF.Framework.Common.SubstrateTrackings;
using MECF.Framework.RT.EquipmentLibrary.LogicUnits;
using System;
using System.Collections.Generic;
using FurnaceRT.Equipments.FIMSs;
using FurnaceRT.Equipments.PMs;
using FurnaceRT.Equipments.Stockers;
using FurnaceRT.Equipments.Systems;
using System.Linq;

namespace FurnaceRT.Equipments.WaferRobots
{
    public class WaferRobotPlace : ModuleRoutine, IRoutine
    {
        enum RoutineStep
        {
            Place,
            RobotRequestWaferPresent,
            CheckWaferInfoByRobotSensor,
            CheckBeforePlace,
            SetRobotActionCommand,
            Delay,
            CheckRobotIsReady,
        }

        private ModuleName _destination;
        private int _destinationSlot;
        private Hand _blade;
        private WaferRobotModule _waferRobotModule;
        private int _timeout = 0;
        private RD_TRIG _holdTrig = new RD_TRIG();
        private R_TRIG _emergencyStopTrig = new R_TRIG();
        private R_TRIG _pauseTrig = new R_TRIG();
        private R_TRIG _resumeTrig = new R_TRIG();
        private RoutineStep _routineStep;
        private double _durationTime = 0;
        private bool _isHasAlarm = false;
        private bool _needStartCheck = true;

        public WaferRobotPlace(WaferRobotModule waferRobotModule)
        {
            _waferRobotModule = waferRobotModule;
            Module = waferRobotModule.Module;

            Name = "Place";
        }

        public void Init(ModuleName destination, int destinationSlot, Hand blade, bool isHasAlarm)
        {
            _destination = destination;
            _destinationSlot = destinationSlot;
            _blade = blade;

            var para = new List<object> { _destination, _destinationSlot, _blade, true };
            _waferRobotModule.PlaceWaferFailAlarm.RetryMessage = (int)WaferRobotModule.MSG.PlaceRetry;
            _waferRobotModule.PlaceWaferFailAlarm.RetryMessageParas = para.ToArray();

            _waferRobotModule.PlaceWaferTimeoutAlarm.RetryMessage = (int)WaferRobotModule.MSG.PlaceRetry;
            _waferRobotModule.PlaceWaferTimeoutAlarm.RetryMessageParas = para.ToArray();

            _waferRobotModule.RequestWaferPresentFailAlarm.RetryMessage = (int)WaferRobotModule.MSG.PlaceRetry;
            _waferRobotModule.RequestWaferPresentFailAlarm.RetryMessageParas = para.ToArray();

            _waferRobotModule.RequestWaferPresentTimeoutAlarm.RetryMessage = (int)WaferRobotModule.MSG.PlaceRetry;
            _waferRobotModule.RequestWaferPresentTimeoutAlarm.RetryMessageParas = para.ToArray();

            _waferRobotModule.RobotHasError.RetryMessage = (int)WaferRobotModule.MSG.PlaceRetry;
            _waferRobotModule.RobotHasError.RetryMessageParas = para.ToArray();

            _isHasAlarm = isHasAlarm;
            if (!_isHasAlarm)
                _needStartCheck = true;
        }

        public Result Start(params object[] objs)
        {
            // 抛出过alarm就不reset
            if (!_isHasAlarm)
            {
                Reset();
            }
            else
            {
                List<int> stepLst = new List<int>(Steps.ToArray());
                stepLst.Remove((int)_routineStep);
                Steps = new Stack<int>(stepLst);
                _isHasAlarm = false;
                ResetState();
            }

            _holdTrig.RST = true;
            _emergencyStopTrig.RST = true;
            _pauseTrig.RST = true;
            _resumeTrig.RST = true;

            _timeout = SC.GetValue<int>($"{Module}.PlaceTimeout");

            var isSimulateMode = SC.GetValue<bool>("System.IsSimulatorMode");

            if (_needStartCheck)
            {
                if (_blade == Hand.Blade1)
                {
                    if (isSimulateMode)
                    {
                        if (!WaferManager.Instance.CheckHasWafer(ModuleName.WaferRobot, 2))
                        {
                            //_waferRobotModule.BladeWaferNotPresentWarning.Description = $"{ModuleName.WaferRobot} {_blade} wafer not present";
                            _waferRobotModule.BladeWaferNotPresentWarning.Set($"{ModuleName.WaferRobot} {_blade} wafer not present");
                            return Result.FAIL;
                        }
                    }
                    else
                    {
                        if (!_waferRobotModule.WaferRobotDevice.IsWaferPresenceOnBlade3 || !WaferManager.Instance.CheckHasWafer(ModuleName.WaferRobot, 2))
                        {
                            //_waferRobotModule.BladeWaferNotPresentWarning.Description = $"{ModuleName.WaferRobot} {_blade} wafer not present";
                            _waferRobotModule.BladeWaferNotPresentWarning.Set($"{ModuleName.WaferRobot} {_blade} wafer not present");
                            return Result.FAIL;
                        }
                    }

                    if (!WaferManager.Instance.CheckNoWafer(_destination, _destinationSlot))
                    {
                        //_waferRobotModule.TargetWaferPresentWarning.Description = $"{_destination} {_destinationSlot + 1} wafer present";
                        _waferRobotModule.TargetWaferPresentWarning.Set($"{_destination} {_destinationSlot + 1} wafer present");
                        return Result.FAIL;
                    }
                }
                else if (_blade == Hand.Blade2)
                {
                    if (isSimulateMode)
                    {
                        if (!WaferManager.Instance.CheckHasWafer(ModuleName.WaferRobot, 1) ||
                        !WaferManager.Instance.CheckHasWafer(ModuleName.WaferRobot, 2) ||
                        !WaferManager.Instance.CheckHasWafer(ModuleName.WaferRobot, 3) ||
                        !WaferManager.Instance.CheckHasWafer(ModuleName.WaferRobot, 4))
                        {
                            //_waferRobotModule.BladeWaferNotPresentWarning.Description = $"{ModuleName.WaferRobot} {_blade} wafer not present";
                            _waferRobotModule.BladeWaferNotPresentWarning.Set($"{ModuleName.WaferRobot} {_blade} wafer not present");
                            return Result.FAIL;
                        }
                    }
                    else
                    {
                        if (!_waferRobotModule.WaferRobotDevice.IsWaferPresenceOnBlade2 ||
                        !WaferManager.Instance.CheckHasWafer(ModuleName.WaferRobot, 1) ||
                        !WaferManager.Instance.CheckHasWafer(ModuleName.WaferRobot, 2) ||
                        !WaferManager.Instance.CheckHasWafer(ModuleName.WaferRobot, 3) ||
                        !WaferManager.Instance.CheckHasWafer(ModuleName.WaferRobot, 4))
                        {
                            //_waferRobotModule.BladeWaferNotPresentWarning.Description = $"{ModuleName.WaferRobot} {_blade} wafer not present";
                            _waferRobotModule.BladeWaferNotPresentWarning.Set($"{ModuleName.WaferRobot} {_blade} wafer not present");
                            return Result.FAIL;
                        }
                    }

                    if (!WaferManager.Instance.CheckNoWafer(_destination, _destinationSlot))
                    {
                        //_waferRobotModule.TargetWaferPresentWarning.Description = $"{_destination} {_destinationSlot + 1} wafer present";
                        _waferRobotModule.TargetWaferPresentWarning.Set($"{_destination} {_destinationSlot + 1} wafer present");
                        return Result.FAIL;
                    }
                    if (!WaferManager.Instance.CheckNoWafer(_destination, _destinationSlot + 1))
                    {
                        //_waferRobotModule.TargetWaferPresentWarning.Description = $"{_destination} {_destinationSlot + 2} wafer present";
                        _waferRobotModule.TargetWaferPresentWarning.Set($"{_destination} {_destinationSlot + 2} wafer present");
                        return Result.FAIL;
                    }
                    if (!WaferManager.Instance.CheckNoWafer(_destination, _destinationSlot + 2))
                    {
                        //_waferRobotModule.TargetWaferPresentWarning.Description = $"{_destination} {_destinationSlot + 3} wafer present";
                        _waferRobotModule.TargetWaferPresentWarning.Set($"{_destination} {_destinationSlot + 3} wafer present");
                        return Result.FAIL;
                    }
                    if (!WaferManager.Instance.CheckNoWafer(_destination, _destinationSlot + 3))
                    {
                        //_waferRobotModule.TargetWaferPresentWarning.Description = $"{_destination} {_destinationSlot + 4} wafer present";
                        _waferRobotModule.TargetWaferPresentWarning.Set($"{_destination} {_destinationSlot + 4} wafer present");
                        return Result.FAIL;
                    }
                }
                else if (_blade == Hand.Both)
                {
                    if (isSimulateMode)
                    {
                        if (!WaferManager.Instance.CheckHasWafer(ModuleName.WaferRobot, 0) ||
                            !WaferManager.Instance.CheckHasWafer(ModuleName.WaferRobot, 1) ||
                            !WaferManager.Instance.CheckHasWafer(ModuleName.WaferRobot, 2) ||
                            !WaferManager.Instance.CheckHasWafer(ModuleName.WaferRobot, 3) ||
                            !WaferManager.Instance.CheckHasWafer(ModuleName.WaferRobot, 4))
                        {
                            //_waferRobotModule.BladeWaferNotPresentWarning.Description = $"{ModuleName.WaferRobot} {_blade} wafer not present";
                            _waferRobotModule.BladeWaferNotPresentWarning.Set($"{ModuleName.WaferRobot} {_blade} wafer not present");
                            return Result.FAIL;
                        }
                    }
                    else
                    {
                        if (!_waferRobotModule.WaferRobotDevice.IsWaferPresenceOnBlade1 ||
                            !_waferRobotModule.WaferRobotDevice.IsWaferPresenceOnBlade2 ||
                            !_waferRobotModule.WaferRobotDevice.IsWaferPresenceOnBlade3 ||
                            !_waferRobotModule.WaferRobotDevice.IsWaferPresenceOnBlade4 ||
                            !_waferRobotModule.WaferRobotDevice.IsWaferPresenceOnBlade5 ||
                            !WaferManager.Instance.CheckHasWafer(ModuleName.WaferRobot, 0) ||
                            !WaferManager.Instance.CheckHasWafer(ModuleName.WaferRobot, 1) ||
                            !WaferManager.Instance.CheckHasWafer(ModuleName.WaferRobot, 2) ||
                            !WaferManager.Instance.CheckHasWafer(ModuleName.WaferRobot, 3) ||
                            !WaferManager.Instance.CheckHasWafer(ModuleName.WaferRobot, 4))
                        {
                            //_waferRobotModule.BladeWaferNotPresentWarning.Description = $"{ModuleName.WaferRobot} {_blade} wafer not present";
                            _waferRobotModule.BladeWaferNotPresentWarning.Set($"{ModuleName.WaferRobot} {_blade} wafer not present");
                            return Result.FAIL;
                        }
                    }

                    if (!WaferManager.Instance.CheckNoWafer(_destination, _destinationSlot))
                    {
                        //_waferRobotModule.TargetWaferPresentWarning.Description = $"{_destination} {_destinationSlot + 1} wafer present";
                        _waferRobotModule.TargetWaferPresentWarning.Set($"{_destination} {_destinationSlot + 1} wafer present");
                        return Result.FAIL;
                    }
                    if (!WaferManager.Instance.CheckNoWafer(_destination, _destinationSlot + 1))
                    {
                        //_waferRobotModule.TargetWaferPresentWarning.Description = $"{_destination} {_destinationSlot + 2} wafer present";
                        _waferRobotModule.TargetWaferPresentWarning.Set($"{_destination} {_destinationSlot + 2} wafer present");
                        return Result.FAIL;
                    }
                    if (!WaferManager.Instance.CheckNoWafer(_destination, _destinationSlot + 2))
                    {
                        //_waferRobotModule.TargetWaferPresentWarning.Description = $"{_destination} {_destinationSlot + 3} wafer present";
                        _waferRobotModule.TargetWaferPresentWarning.Set($"{_destination} {_destinationSlot + 3} wafer present");
                        return Result.FAIL;
                    }
                    if (!WaferManager.Instance.CheckNoWafer(_destination, _destinationSlot + 3))
                    {
                        //_waferRobotModule.TargetWaferPresentWarning.Description = $"{_destination} {_destinationSlot + 4} wafer present";
                        _waferRobotModule.TargetWaferPresentWarning.Set($"{_destination} {_destinationSlot + 4} wafer present");
                        return Result.FAIL;
                    }
                    if (!WaferManager.Instance.CheckNoWafer(_destination, _destinationSlot + 4))
                    {
                        //_waferRobotModule.TargetWaferPresentWarning.Description = $"{_destination} {_destinationSlot + 5} wafer present";
                        _waferRobotModule.TargetWaferPresentWarning.Set($"{_destination} {_destinationSlot + 5} wafer present");
                        return Result.FAIL;
                    }
                }

                if (ModuleHelper.IsPm(_destination))
                {
                    var pmModule = Singleton<EquipmentManager>.Instance.Modules[_destination] as PMModule;
                    if (pmModule != null && !pmModule.CheckReadyForTransfer(ModuleHelper.Converter(_waferRobotModule.Module), _blade, _destinationSlot, EnumTransferType.Place, out string reason))
                    {
                        //_waferRobotModule.PlaceWaferFailAlarm.Description = reason;
                        _waferRobotModule.PlaceWaferFailAlarm.Set(reason);
                        return Result.FAIL;
                    }
                }
                if (_destination == ModuleName.FIMS1 || _destination == ModuleName.FIMS2)
                {
                    var fims = Singleton<EquipmentManager>.Instance.Modules[_destination] as FIMSModule;

                    if (fims != null && !fims.CheckReadyForTransfer(ModuleHelper.Converter(Module), _blade, _destinationSlot, EnumTransferType.Place, out string reason))
                    {
                        //_waferRobotModule.PlaceWaferFailAlarm.Description = reason;
                        _waferRobotModule.PlaceWaferFailAlarm.Set(reason);
                        return Result.FAIL;
                    }
                    if (fims != null && fims.IsWaferOnRobot)
                    {
                        _waferRobotModule.PlaceWaferFailAlarm.Set($"The wafer on {Module} has shifted");
                    }
                }
            }

            Notify($"Start");

            return Result.RUN;
        }

        public void Abort()
        {
            _waferRobotModule.ResetRobotActionCommand();
            _waferRobotModule.Stop();
            (Singleton<EquipmentManager>.Instance.Modules[_destination] as ITransferTarget)?.NoteTransferStop(ModuleHelper.Converter(_waferRobotModule.Module), _blade, _destinationSlot, EnumTransferType.Place);
        }

        public override Result Monitor()
        {
            try
            {
                PauseRountine(_waferRobotModule.WaferRobotDevice.IsPause);
                if (_waferRobotModule.WaferRobotDevice.IsPause)
                    return Result.RUN;

                CheckBeforePlace((int)RoutineStep.CheckBeforePlace, _destination, _destinationSlot, _blade);

                if (_waferRobotModule.TrigActionCommand != null)
                    SetRobotActionCommand((int)RoutineStep.SetRobotActionCommand, _destination, _timeout);

                Place((int)RoutineStep.Place, _destination, _destinationSlot, _blade, _timeout);

                //RobotRequestWaferPresent((int)RoutineStep.RobotRequestWaferPresent, _blade, _timeout);

                CheckWaferInfoByRobotSensor((int)RoutineStep.CheckWaferInfoByRobotSensor, _blade, false);

                CheckRobotIsReady((int)RoutineStep.CheckRobotIsReady, _timeout);

                if (SC.ContainsItem("System.AddRobotDelay") && SC.ContainsItem("System.RobotDelayTime") && SC.GetValue<bool>("System.AddRobotDelay"))
                    Delay((int)RoutineStep.Delay, float.Parse(SC.GetStringValue("System.RobotDelayTime")));
            }
            catch (RoutineBreakException)
            {
                return Result.RUN;
            }
            catch (RoutineFaildException ex)
            {
                _waferRobotModule.ResetRobotActionCommand();
                (Singleton<EquipmentManager>.Instance.Modules[_destination] as ITransferTarget)?.NoteTransferStop(ModuleHelper.Converter(_waferRobotModule.Module), _blade, _destinationSlot, EnumTransferType.Place);
                return Result.FAIL;
            }

            _waferRobotModule.ResetRobotActionCommand();
            (Singleton<EquipmentManager>.Instance.Modules[_destination] as ITransferTarget)?.NoteTransferStop(ModuleHelper.Converter(_waferRobotModule.Module), _blade, _destinationSlot, EnumTransferType.Place);

            Notify("Finished");
            return Result.DONE;
        }

        private void PlaceStartInfo(ModuleName moduleName)
        {
            if (ModuleHelper.IsFIMS(moduleName))
            {
                var fimsFoupInfo = CarrierManager.Instance.GetCarrier(_destination);
                fimsFoupInfo.UICarrierStatusEnum = CarrierStatus.WDCHRG;
                Singleton<EquipmentManager>.Instance.SetVisibility(fimsFoupInfo, true);
                Singleton<EquipmentManager>.Instance.SetUIWaferCount(fimsFoupInfo, moduleName, out var wafers);


            }
            if (ModuleHelper.IsPm(moduleName))
            {
                var fims1 = Singleton<EquipmentManager>.Instance.Modules[ModuleName.FIMS1] as FIMSModule;
                var fims2 = Singleton<EquipmentManager>.Instance.Modules[ModuleName.FIMS2] as FIMSModule;
                if (fims1 != null && fims1.CheckReadyForTransfer(ModuleName.WaferRobot, _blade, 0, EnumTransferType.Pick, out string reason))
                {
                    var fims1FoupInfo = CarrierManager.Instance.GetCarrier(ModuleName.FIMS1);
                    fims1FoupInfo.UICarrierStatusEnum = CarrierStatus.WCHARG;
                    Singleton<EquipmentManager>.Instance.SetUIWaferCount(fims1FoupInfo, ModuleName.FIMS1, out var wafers);
                    if (wafers.All(a => a.IsEmpty))
                    {
                        fims1FoupInfo.UICarrierStatusEnum = CarrierStatus.ONBOAT;
                    }
                    Singleton<EquipmentManager>.Instance.SetVisibility(fims1FoupInfo, true);

                }
                if (fims2 != null && fims2.CheckReadyForTransfer(ModuleName.WaferRobot, _blade, 0, EnumTransferType.Pick, out reason))
                {
                    var fims2FoupInfo = CarrierManager.Instance.GetCarrier(ModuleName.FIMS2);
                    fims2FoupInfo.UICarrierStatusEnum = CarrierStatus.WCHARG;
                    Singleton<EquipmentManager>.Instance.SetUIWaferCount(fims2FoupInfo, ModuleName.FIMS2, out var wafers);
                    if (wafers.All(a => a.IsEmpty))
                    {
                        fims2FoupInfo.UICarrierStatusEnum = CarrierStatus.ONBOAT;
                    }
                    Singleton<EquipmentManager>.Instance.SetVisibility(fims2FoupInfo, true);

                }
            }
        }


        private void CheckBeforePlace(int id, ModuleName target, int slot, Hand blade)
        {
            Tuple<bool, Result> ret = Execute(id, () =>
            {
                Notify("Check place condition");
                string reason = string.Empty;

                if (_waferRobotModule.WaferRobotDevice.IsError)
                {
                    //_waferRobotModule.PlaceWaferFailAlarm.Description = $"place to {target} failed for robot error, error code={_waferRobotModule.WaferRobotDevice.ErrorCode}";
                    _waferRobotModule.PlaceWaferFailAlarm.Set($"place to {target} failed for robot error, error code={_waferRobotModule.WaferRobotDevice.ErrorCode}");
                    return false;
                }

                if (!_waferRobotModule.WaferRobotDevice.IsReady(out reason))
                {
                    //_waferRobotModule.PlaceWaferFailAlarm.Description = $"place to {target} failed for robot isn't Ready";
                    _waferRobotModule.PlaceWaferFailAlarm.Set($"place to {target} failed for robot isn't Ready {reason}");
                    return false;
                }
                if (ModuleHelper.IsPm(_destination))
                {
                    var pmModule = Singleton<EquipmentManager>.Instance.Modules[_destination] as PMModule;
                    if (pmModule != null && !pmModule.CheckReadyForTransfer(ModuleHelper.Converter(_waferRobotModule.Module), _blade, slot, EnumTransferType.Place, out reason))
                    {
                        //_waferRobotModule.PlaceWaferFailAlarm.Description = reason;
                        _waferRobotModule.PlaceWaferFailAlarm.Set(reason);
                        return false;
                    }
                    PlaceStartInfo(_destination);
                }
                if (target == ModuleName.FIMS1 || target == ModuleName.FIMS2)
                {
                    var fims = Singleton<EquipmentManager>.Instance.Modules[_destination] as FIMSModule;

                    if (fims != null && !fims.CheckReadyForTransfer(ModuleHelper.Converter(Module), _blade, slot, EnumTransferType.Place, out reason))
                    {
                        //_waferRobotModule.PlaceWaferFailAlarm.Description = reason;
                        _waferRobotModule.PlaceWaferFailAlarm.Set(reason);
                        return false;
                    }
                    PlaceStartInfo(target);
                }

                if (blade == Hand.Blade1)
                {
                    if (!WaferManager.Instance.CheckNoWafer(target, slot))
                    {
                        //_waferRobotModule.PlaceWaferFailAlarm.Description = $"place to {target} failed for {target} has wafer";
                        _waferRobotModule.PlaceWaferFailAlarm.Set($"place to {target} failed for {target} has wafer");
                        return false;
                    }

                    if (!WaferManager.Instance.CheckHasWafer(Module, 2))
                    {
                        //_waferRobotModule.PlaceWaferFailAlarm.Description = $"place to {target} failed for blade no wafer";
                        _waferRobotModule.PlaceWaferFailAlarm.Set($"place to {target} failed for blade no wafer");
                        return false;
                    }
                }
                else if (blade == Hand.Blade2)
                {
                    if (!WaferManager.Instance.CheckNoWafer(target, slot))
                    {
                        //_waferRobotModule.PlaceWaferFailAlarm.Description = $"place to {target} failed for {target} has wafer";
                        _waferRobotModule.PlaceWaferFailAlarm.Set($"place to {target} failed for {target} has wafer");
                        return false;
                    }

                    if (!WaferManager.Instance.CheckHasWafer(Module, 1))
                    {
                        //_waferRobotModule.PlaceWaferFailAlarm.Description = $"place to {target} failed for blade no wafer";
                        _waferRobotModule.PlaceWaferFailAlarm.Set($"place to {target} failed for blade no wafer");
                        return false;
                    }
                }
                else
                {
                    for (int i = 0; i < 5; i++)
                    {
                        if (!WaferManager.Instance.CheckNoWafer(target, slot + i))
                        {
                            //_waferRobotModule.PlaceWaferFailAlarm.Description = $"place to {target} failed for {target} has wafer";
                            _waferRobotModule.PlaceWaferFailAlarm.Set($"place to {target} failed for {target} has wafer");
                            return false;
                        }

                        if (!WaferManager.Instance.CheckHasWafer(Module, i))
                        {
                            //_waferRobotModule.PlaceWaferFailAlarm.Description = $"place to {target} failed for blade no wafer";
                            _waferRobotModule.PlaceWaferFailAlarm.Set($"place to {target} failed for blade no wafer");
                            return false;
                        }
                    }
                }

                return true;
            });

            if (ret.Item1)
            {
                if (ret.Item2 == Result.FAIL)
                {
                    throw (new RoutineFaildException());
                }
            }

            _needStartCheck = false;
        }
        private void Place(int id, ModuleName target, int slot, Hand hand, int timeout)
        {
            _routineStep = (RoutineStep)Enum.Parse(typeof(RoutineStep), id.ToString());
            Tuple<bool, Result> ret = ExecuteAndWait(id, () =>
            {
                Notify("send place command to device");
                string reason;
                (Singleton<EquipmentManager>.Instance.Modules[target] as ITransferTarget)?.NoteTransferStart(ModuleHelper.Converter(_waferRobotModule.Module), hand, slot, EnumTransferType.Place);
                if (!_waferRobotModule.RobotPlace(target, slot, hand, out reason))
                {
                    //_waferRobotModule.PlaceWaferFailAlarm.Description = reason;
                    _waferRobotModule.PlaceWaferFailAlarm.Set(reason);
                    return false;
                }
                return true;
            }, () =>
            {
                if (_waferRobotModule.WaferRobotDevice.IsReady() && !_waferRobotModule.WaferRobotDevice.IsError)
                {
                    return true;
                }

                return false;
            }, timeout * 1000);

            if (ret.Item1)
            {
                if (ret.Item2 == Result.FAIL)
                {
                    //_waferRobotModule.PlaceWaferFailAlarm.Description = $"{_waferRobotModule.WaferRobotDevice.ErrorCode}";
                    _waferRobotModule.PlaceWaferFailAlarm.Set($"place to {target} failed for robot error, error code={_waferRobotModule.WaferRobotDevice.ErrorCode}");
                    throw (new RoutineFaildException());
                }
                else if (ret.Item2 == Result.TIMEOUT) //timeout
                {
                    //_waferRobotModule.PlaceWaferTimeoutAlarm.Description = $"timeout over {timeout} seconds";
                    _waferRobotModule.PlaceWaferTimeoutAlarm.Set($"timeout over {timeout} seconds");
                    throw (new RoutineFaildException());
                }
                else
                    throw (new RoutineBreakException());
            }
        }

        private void RobotRequestWaferPresent(int id, Hand hand, int timeout)
        {
            Tuple<bool, Result> ret = ExecuteAndWait(id, () =>
            {
                Notify("request wafer present");

                if (!_waferRobotModule.RequestWaferPresent(hand, out string reason))
                {
                    //_waferRobotModule.RequestWaferPresentFailAlarm.Description = reason;
                    _waferRobotModule.RequestWaferPresentFailAlarm.Set(reason);
                    return false;
                }

                return true;
            }, () =>
            {
                if (_waferRobotModule.WaferRobotDevice.IsReady() && !_waferRobotModule.WaferRobotDevice.IsError)
                {
                    return true;
                }

                return false;

            }, timeout * 1000);

            if (ret.Item1)
            {
                if (ret.Item2 == Result.FAIL)
                {
                    throw (new RoutineFaildException());
                }
                else if (ret.Item2 == Result.TIMEOUT) //timeout
                {
                    //_waferRobotModule.RequestWaferPresentTimeoutAlarm.Description = $"timeout over {timeout} seconds";
                    _waferRobotModule.RequestWaferPresentTimeoutAlarm.Set($"timeout over {timeout} seconds");
                    throw (new RoutineFaildException());
                }
                else
                    throw (new RoutineBreakException());
            }
        }

        private void CheckWaferInfoByRobotSensor(int id, Hand hand, bool isAfterPick)
        {
            Tuple<bool, Result> ret = Execute(id, () =>
            {
                Notify($"check wafer info by robot RQ present");

                if (SC.GetValue<bool>("System.IsSimulatorMode"))
                    return true;

                if (hand == Hand.Blade1 || hand == Hand.Both)
                {
                    if (!isAfterPick && _waferRobotModule.WaferRobotDevice.IsWaferPresenceOnBlade3)
                    {
                        _waferRobotModule.RobotSensorFoundWaferOnBladeAfterPlaceAlarm.Set("Wafer Robot sensor found wafer on blade 3");
                        return false;
                    }

                    if (isAfterPick && !_waferRobotModule.WaferRobotDevice.IsWaferPresenceOnBlade3)
                    {
                        _waferRobotModule.RobotSensorNotFoundWaferOnBladeAfterPickAlarm.Set("Wafer Robot sensor no wafer on blade 3");
                        return false;
                    }
                }

                if (hand == Hand.Blade2 || hand == Hand.Both)
                {
                    if (!isAfterPick && _waferRobotModule.WaferRobotDevice.IsWaferPresenceOnBlade1)
                    {
                        _waferRobotModule.RobotSensorFoundWaferOnBladeAfterPlaceAlarm.Set("Wafer Robot sensor found wafer on blade 1");
                        return false;
                    }

                    if (isAfterPick && !_waferRobotModule.WaferRobotDevice.IsWaferPresenceOnBlade1)
                    {
                        _waferRobotModule.RobotSensorNotFoundWaferOnBladeAfterPickAlarm.Set("Wafer Robot sensor no wafer on blade 1");
                        return false;
                    }

                    if (!isAfterPick && _waferRobotModule.WaferRobotDevice.IsWaferPresenceOnBlade2)
                    {
                        _waferRobotModule.RobotSensorFoundWaferOnBladeAfterPlaceAlarm.Set("Wafer Robot sensor found wafer on blade 2");
                        return false;
                    }

                    if (isAfterPick && !_waferRobotModule.WaferRobotDevice.IsWaferPresenceOnBlade2)
                    {
                        _waferRobotModule.RobotSensorNotFoundWaferOnBladeAfterPickAlarm.Set("Wafer Robot sensor no wafer on blade 2");
                        return false;
                    }

                    if (!isAfterPick && _waferRobotModule.WaferRobotDevice.IsWaferPresenceOnBlade4)
                    {
                        _waferRobotModule.RobotSensorFoundWaferOnBladeAfterPlaceAlarm.Set("Wafer Robot sensor found wafer on blade 4");
                        return false;
                    }

                    if (isAfterPick && !_waferRobotModule.WaferRobotDevice.IsWaferPresenceOnBlade4)
                    {
                        _waferRobotModule.RobotSensorNotFoundWaferOnBladeAfterPickAlarm.Set("Wafer Robot sensor no wafer on blade 4");
                        return false;
                    }

                    if (!isAfterPick && _waferRobotModule.WaferRobotDevice.IsWaferPresenceOnBlade5)
                    {
                        _waferRobotModule.RobotSensorFoundWaferOnBladeAfterPlaceAlarm.Set("Wafer Robot sensor found wafer on blade 5");
                        return false;
                    }

                    if (isAfterPick && !_waferRobotModule.WaferRobotDevice.IsWaferPresenceOnBlade5)
                    {
                        _waferRobotModule.RobotSensorNotFoundWaferOnBladeAfterPickAlarm.Set("Wafer Robot sensor no wafer on blade 5");
                        return false;
                    }
                }

                return true;
            });

            if (ret.Item1)
            {
                if (ret.Item2 == Result.FAIL)
                {
                    _waferRobotModule.CheckWaferInformationFailAlarm.Set();
                    throw (new RoutineFaildException());
                }
                else
                    throw (new RoutineBreakException());
            }
        }
        private void SetRobotActionCommand(int id, ModuleName source, int timeout)
        {
            _routineStep = (RoutineStep)Enum.Parse(typeof(RoutineStep), id.ToString());
            Tuple<bool, Result> ret = ExecuteAndWait(id, () =>
            {
                Notify($"Set robot action command target position {source}");

                _waferRobotModule.SetRobotActionCommand(source, EnumTransferType.Place);

                return true;
            }, () =>
            {
                return _waferRobotModule.CheckRobotActionCommand(source, EnumTransferType.Place);
            }, timeout * 1000);

            if (ret.Item1)
            {
                if (ret.Item2 == Result.FAIL)
                {
                    _waferRobotModule.PlaceWaferFailAlarm.Set($"place to {source} failed for robot action command interlock");
                    throw (new RoutineFaildException());
                }
                else if (ret.Item2 == Result.TIMEOUT) //timeout
                {
                    _waferRobotModule.PlaceWaferTimeoutAlarm.Set($"timeout over {timeout} seconds");
                    throw (new RoutineFaildException());
                }
                else
                    throw (new RoutineBreakException());
            }
        }

        private void CheckRobotIsReady(int id, int timeout)
        {
            Tuple<bool, Result> ret = ExecuteAndWait(id, () =>
            {
                return true;
            }, () =>
            {
                int count = 0;
                while (count < 3)
                {
                    if (_waferRobotModule.WaferRobotDevice.IsReady() && !_waferRobotModule.WaferRobotDevice.IsError)
                        count++;
                }

                if (count == 3)
                    return true;

                return false;
            }, timeout * 1000);

            if (ret.Item1)
            {
                if (ret.Item2 == Result.FAIL)
                {
                    throw (new RoutineFaildException());
                }
                else if (ret.Item2 == Result.TIMEOUT) //timeout
                {
                    throw (new RoutineFaildException());
                }
                else
                    throw (new RoutineBreakException());
            }
        }
    }
}