Kepler-Release/Venus/Venus_RT/Modules/TM/MFSwapRoutine.cs

using Aitex.Core.RT.Routine;
using Aitex.Core.RT.SCCore;
using Aitex.Sorter.Common;
using Venus_RT.Devices;
using MECF.Framework.Common.Routine;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.SubstrateTrackings;
using Venus_Core;
using Aitex.Core.RT.Log;
using Aitex.Core.Util;

namespace Venus_RT.Modules.TM
{
    class MFSwapRoutine : ModuleRoutineBase, IRoutine
    {
        private enum SwapStep
        {
            WaitModuleReady,
            ModulePrepare,
            OpenSlitDoor,
            Picking,
            Placing,
            CloseSlitDoor,
            NotifyDone,
        }

        private readonly JetTM _JetTM;
        private readonly ITransferRobot _robot;

        private int _swapTimeout = 120 * 1000;
        private ModuleName _targetModule;
        private LLEntity _llModule;
        int _pickSlot, _placeSlot;
        Hand _pickHand, _placeHand;

        public MFSwapRoutine(JetTM tm, ITransferRobot robot) : base(ModuleName.TM)
        {
            _JetTM = tm;
            _robot = robot;

            Name = "Swap";
        }
        public RState Start(params object[] objs)
        {
            if (!_robot.IsHomed)
            {
                LOG.Write(eEvent.ERR_TM, Module, $"TM Robot is not homed, please home it first");
                return RState.Failed;
            }

            _targetModule = (ModuleName)objs[0];
            _pickSlot = (int)objs[1];
            _placeSlot = (int)objs[2];
            _pickHand = (Hand)objs[3];
            _placeHand = _pickHand == Hand.Blade1 ? Hand.Blade2 : Hand.Blade1;

            if (ModuleHelper.IsLoadLock(_targetModule) && ModuleHelper.IsInstalled(_targetModule))
            {
                _llModule = _targetModule == ModuleName.LLA ? Singleton<RouteManager>.Instance.LLA : Singleton<RouteManager>.Instance.LLB;
            }
            else
            {
                LOG.Write(eEvent.ERR_TM, Module, $"Invalid target module : {_targetModule} for picking action");
                return RState.Failed;
            }

            if (WaferManager.Instance.CheckHasWafer(ModuleName.TM, (int)_pickHand))
            {
                LOG.Write(eEvent.ERR_TM, Module, $"Cannot pick as TM Robot Arm: {_pickHand} already has a wafer");
                return RState.Failed;
            }

            if (WaferManager.Instance.CheckNoWafer(_targetModule, _pickSlot))
            {
                LOG.Write(eEvent.ERR_TM, Module, $"Cannot pick as {_targetModule} Slot {_pickSlot} has no wafer");
                return RState.Failed;
            }

            if (WaferManager.Instance.CheckNoWafer(ModuleName.TM, (int)_placeHand))
            {
                LOG.Write(eEvent.ERR_TM, Module, $"Cannot place as TM Robot Arm: {_placeHand} has no wafer");
                return RState.Failed;
            }

            if (WaferManager.Instance.CheckHasWafer(_targetModule, _placeSlot))
            {
                LOG.Write(eEvent.ERR_TM, Module, $"Cannot place as {_targetModule} Slot {_placeSlot} already has a wafer");
                return RState.Failed;
            }

            Reset();
            _swapTimeout = SC.GetValue<int>($"{Module}.SwapTimeout") * 1000;

            return Runner.Start(Module, Name);
        }

        public RState Monitor()
        {
            Runner.Wait((int)SwapStep.WaitModuleReady,  () => _llModule.IsIdle,     _delay_60s)
                .Run((int)SwapStep.ModulePrepare,       ModulePrepare,              IsModulePrepareReady)
                .Run((int)SwapStep.OpenSlitDoor,        OpenSlitDoor,               IsSlitDoorOpen)
                .Run((int)SwapStep.Picking,             Picking,                    WaitPickDone)
                .Run((int)SwapStep.Placing,             Placing,                    WaitPlaceDone)
                .Run((int)SwapStep.CloseSlitDoor,       CloseSlitDoor,              IsSlitDoorClosed)
                .End((int)SwapStep.NotifyDone,          NotifyLLDone,               _delay_50ms);

            return Runner.Status;
        }

        private bool ModulePrepare()
        {
            _llModule.PostMsg(LLEntity.MSG.Prepare_TM);
            return true;
        }

        private bool IsModulePrepareReady()
        {
            return _llModule.Status == LLEntity.LLStatus.Ready_For_TM;
        }

        private bool OpenSlitDoor()
        {
            return _JetTM.TurnMFSlitDoor(_targetModule, true, out _);
        }

        private bool CloseSlitDoor()
        {
            return _JetTM.TurnMFSlitDoor(_targetModule, false, out _);
        }

        private bool IsSlitDoorOpen()
        {
            if (_targetModule == ModuleName.LLA)
                return _JetTM.IsLLASlitDoorOpen;
            else
                return _JetTM.IsLLBSlitDoorOpen;
        }

        private bool IsSlitDoorClosed()
        {
            if (_targetModule == ModuleName.LLA)
                return _JetTM.IsLLASlitDoorClosed;
            else
                return _JetTM.IsLLBSlitDoorClosed;
        }

        private bool Picking()
        {
            return _robot.Pick(_targetModule, _pickSlot, _pickHand);
        }

        private bool WaitPickDone()
        {
            if (_robot.Status == RState.Running)
            {
                return false;
            }
            else if (_robot.Status == RState.End)
            {
                return true;
            }
            else
            {
                Runner.Stop($"TM Robot Picking failed, {_robot.Status}");
                return true;
            }
        }
        private bool Placing()
        {
            return _robot.Place(_targetModule, _placeSlot, _placeHand);
        }

        private bool WaitPlaceDone()
        {
            if (_robot.Status == RState.Running)
            {
                return false;
            }
            else if (_robot.Status == RState.End)
            {
                return true;
            }
            else
            {
                Runner.Stop($"TM Robot Place failed, {_robot.Status}");
                return true;
            }
        }

        private bool NotifyLLDone()
        {
            _llModule.PostMsg(LLEntity.MSG.TM_Exchange_Ready);
            return true;
        }

        public void Abort()
        {
            _robot.Halt();
        }
    }
}