PunkHPX8/PunkHPX8_RT/Modules/EFEM/EfemPlaceRoutine.cs

using Aitex.Core.RT.Routine;
using Aitex.Core.RT.SCCore;
using Aitex.Sorter.Common;
using PunkHPX8_RT.Devices;
using MECF.Framework.Common.Routine;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.SubstrateTrackings;
using PunkHPX8_Core;
using Aitex.Core.RT.Log;
using Aitex.Core.Util;
using MECF.Framework.Common.Schedulers;
using System.Collections.Generic;
using PunkHPX8_RT.Devices.EFEM;
using PunkHPX8_RT.Modules.SRD;
using PunkHPX8_RT.Devices.AXIS;
using Aitex.Core.RT.Device;
using MECF.Framework.Common.Utilities;
using System;
using PunkHPX8_RT.Modules.LPs;
using PunkHPX8_RT.Modules.VpwMain;
using PunkHPX8_RT.Devices.PlatingCell;
using PunkHPX8_RT.Modules.PlatingCell;

namespace PunkHPX8_RT.Modules.EFEM
{
    class EfemPlaceRoutine : RoutineBase, IRoutine
    {
        private enum PlaceStep
        {
            WaitIdle,
            SetAlignWaferSize,
            WaitWaferSizeIdle,
            SetAlignDistance,
            WaitAlignDistanceIdle,
            WaitModuleReady,
            Placing1,
            Placing2,
            End,
        }

        private int _moveTimeout = 20 * 1000;
        private ModuleName _targetModule = ModuleName.System;
        int _targetSlot;
        string _targetPufSlot;
        int _targetSlot2;
        Hand _hand;
        Hand _hand2;
        Flip _flip;
        EfemBase _efem;
        bool _bDoublePlace = false;
        private SRDEntity _srdModule;
        private Queue<MoveItem> _moveItems;
        private bool _isAligner;

        public EfemPlaceRoutine(EfemBase efem) : base(ModuleName.EfemRobot.ToString())
        {
            _efem = efem;
        }

        public RState Start(params object[] objs)
        {
            _bDoublePlace = false;
            _moveItems = (Queue<MoveItem>)objs[0];
            MoveItem moveItem = _moveItems.Peek();
            _targetModule = moveItem.DestinationModule;
            _targetSlot = moveItem.DestinationSlot;
            _hand = moveItem.RobotHand;
            _flip = moveItem.PlaceRobotFlip;
            if (!CheckPreCondition())
            {
                return RState.Failed;
            }
            _isAligner = ModuleHelper.IsAligner(_targetModule);
            _moveTimeout = SC.GetValue<int>($"EFEM.MotionTimeout") * 1000;
            return Runner.Start(Module, $"Place to {_targetModule}");
        }


        private Loadport GetLoadPort(ModuleName station)
        {
            LoadPortModule loadPortModule = Singleton<RouteManager>.Instance.EFEM.GetLoadportModule(station - ModuleName.LP1);
            return loadPortModule.LPDevice;
        }
        private bool CheckPreCondition()
        {
            if (ModuleHelper.IsAligner(_targetModule) || ModuleHelper.IsLoadPort(_targetModule))
            {
                if (_hand == Hand.Blade2)
                {
                    NotifyError(eEvent.ERR_EFEM_ROBOT, $"cannot use upper arm to place to {_targetModule}", -1);
                    return false;
                }
            }
            if (ModuleHelper.IsPlatingCell(_targetModule))
            {
                if (_hand == Hand.Blade1)
                {
                    NotifyError(eEvent.ERR_EFEM_ROBOT, $"cannot use lower arm to place to {_targetModule}", -1);
                    return false;
                }
                PlatingCellDevice platingCellDevice = DEVICE.GetDevice<PlatingCellDevice>(_targetModule.ToString());
                if (platingCellDevice == null)
                {
                    NotifyError(eEvent.ERR_EFEM_ROBOT, $"{_targetModule} entity is null, can not pick", -1);
                    return false;
                }
                if (platingCellDevice != null && platingCellDevice.PlatingCellDeviceData.ClamShellClosed)
                {
                    NotifyError(eEvent.ERR_EFEM_ROBOT, $"{_targetModule} clamshell closed, can not pick", -1);
                    return false;
                }
                string vertical = ModuleMatcherManager.Instance.GetPlatingVerticalByCell(_targetModule.ToString());
                PlatingCellVerticalEntity verticalEntity = Singleton<RouteManager>.Instance.GetModule<PlatingCellVerticalEntity>(vertical);
                if (verticalEntity == null)
                {
                    NotifyError(eEvent.ERR_EFEM_ROBOT, $"{_targetModule} vertical entity is null, can not pick", -1);
                    return false;
                }
                if (verticalEntity != null && !verticalEntity.IsInLoad)
                {
                    NotifyError(eEvent.ERR_EFEM_ROBOT, $"{_targetModule} vertical is not in load, can not pick", -1);
                    return false;
                }
            }
            if (_hand == Hand.Blade1 && _flip == Flip.Down)
            {
                NotifyError(eEvent.ERR_EFEM_ROBOT, $"lower arm cannot flip", -1);
                return false;
            }
            //LoadPort状态判断
            if (ModuleHelper.IsLoadPort(_targetModule) && ModuleHelper.IsInstalled(_targetModule))
            {
                Loadport loadPort = GetLoadPort(_targetModule);
                if (loadPort == null)
                {
                    return false;
                }
                if (!loadPort.IsLoaded)
                {
                    NotifyError(eEvent.ERR_EFEM_ROBOT, $"LoadPort not load, cannot do the pick action", -1);
                    return false;
                }
            }
            if (ModuleHelper.IsSRD(_targetModule) && ModuleHelper.IsInstalled(_targetModule))
            {
                _srdModule = Singleton<RouteManager>.Instance.GetModule<SRDEntity>(_targetModule.ToString());
                if (!_srdModule.IsHomed)
                {
                    NotifyError(eEvent.ERR_EFEM_ROBOT,  $"{_targetModule} is not homed, please home it first",-1);
                    return false;
                }
                if (_srdModule.IsSrdDoorClosed)
                {
                    NotifyError(eEvent.ERR_EFEM_ROBOT, $"{_targetModule} door closed, can not place",-1);
                    return false;
                }
            }
            if (ModuleHelper.IsVPWCell(_targetModule) && ModuleHelper.IsInstalled(_targetModule))
            {
                VpwMainEntity vpwMainEntity = Singleton<RouteManager>.Instance.GetModule<VpwMainEntity>(ModuleName.VPWMain1.ToString());
                
                if (vpwMainEntity.IsChamberClosed)
                {
                    NotifyError(eEvent.ERR_EFEM_ROBOT, $"{_targetModule} door closed, can not place", -1);
                    return false;
                }
            }
            if (WaferManager.Instance.CheckNoWafer(ModuleName.EfemRobot, (int)_hand))
            {
                NotifyError(eEvent.ERR_EFEM_ROBOT, $"Efem robot arm{_hand} already has no wafer, cannot do the place action",-1);
                return false;
            }

            if (WaferManager.Instance.CheckHasWafer(_targetModule, _targetSlot))
            {
                NotifyError(eEvent.ERR_EFEM_ROBOT, $"The target: {_targetModule}.{_targetSlot + 1} has a wafer, cannot do the place action",-1);
                
                return false;
            }

            if (_moveItems.Count >= 2)
            {
                if (!ModuleHelper.IsLoadPort(_targetModule))
                {
                    NotifyError(eEvent.ERR_EFEM_ROBOT,$"Wrong double place command, target is not loadport",-1);
                    return false;
                }

                _hand2 = _hand != Hand.Blade1 ? Hand.Blade1 : Hand.Blade2;
                if (WaferManager.Instance.CheckNoWafer(ModuleName.EfemRobot, (int)_hand2))
                {
                    NotifyError(eEvent.ERR_EFEM_ROBOT,$"Efem robot arm{_hand2} has no wafer, cannot do the double place action",-1);
                    return false;
                }

                _targetSlot2 = _moveItems.ToArray()[1].DestinationSlot;
                if (WaferManager.Instance.CheckHasWafer(_targetModule, _targetSlot2))
                {
                    NotifyError(eEvent.ERR_EFEM_ROBOT, $"The target: {_targetModule}.{_targetSlot2 + 1} has a wafer, cannot do the double pick action",-1);
                    return false;
                }
            }
            return true;
        }

        public RState Monitor()
        {
            if (_bDoublePlace)
            {
                Runner.WaitIf(PlaceStep.WaitIdle,_isAligner,WaitModuleReady)
                    .RunIf(PlaceStep.SetAlignWaferSize,_isAligner,SetAlignerWaferSize, CheckAlignDone, _delay_5s)
                     .Wait(PlaceStep.WaitWaferSizeIdle, WaitModuleReady)
                    .RunIf(PlaceStep.SetAlignDistance, _isAligner, SetAlignerDistance,CheckAlignDone, _delay_5s)
                     .Wait(PlaceStep.WaitAlignDistanceIdle, WaitModuleReady)
                    .Wait(PlaceStep.WaitModuleReady,     WaitModuleReady)
                        .Run(PlaceStep.Placing1,           Place1,         Place1Done,     _moveTimeout)
                        .Run(PlaceStep.Placing2,           Place2,         Place2Done,     _moveTimeout)
                        .End(PlaceStep.End,                ActionDone);
            }
            else
            {
                Runner.WaitIf(PlaceStep.WaitIdle, _isAligner, WaitModuleReady)
                    .RunIf(PlaceStep.SetAlignWaferSize, _isAligner, SetAlignerWaferSize, _delay_1ms)
                     .Wait(PlaceStep.WaitWaferSizeIdle, WaitModuleReady)
                    .RunIf(PlaceStep.SetAlignDistance, _isAligner, SetAlignerDistance, _delay_1ms)
                     .Wait(PlaceStep.WaitAlignDistanceIdle, WaitModuleReady)
                    .Wait(PlaceStep.WaitModuleReady, WaitModuleReady)
                        .Run(PlaceStep.Placing1,           Place1,         Place1Done,     _moveTimeout)
                        .End(PlaceStep.End,                ActionDone);
            }

            return Runner.Status;
        }
        private bool SetAlignerWaferSize()
        {
            return _efem.SetAlignWaferSize();
        }

        private bool SetAlignerDistance()
        {
            return _efem.SetAlignDistance();
        }

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

        private bool WaitModuleReady()
        {
            if (_efem.IsInPauseStatus)
            {
                return false;
            }
            return _efem.Status == RState.End;
        }

        private bool Place1()
        {
            return _efem.Place(_targetModule, _targetSlot, _hand, _flip);
        }

        private bool Place1Done()
        {
            if (_efem.Status == RState.End)
            {
                WaferManager.Instance.WaferMoved(ModuleName.EfemRobot, (int)_hand, _targetModule, _targetSlot);
                return true;
            }
            else if (_efem.Status == RState.Failed)
            {
                NotifyError(eEvent.ERR_EFEM_ROBOT, $"Efem robot place failed: {_efem.Status}",-1);
                return true;
            }

            return false;
        }
        private bool CheckAlignDone()
        {
            if (_efem.Status == RState.End)
            {
                return true;
            }
            else if (_efem.Status == RState.Failed)
            {
                LOG.Write(eEvent.ERR_EFEM_COMMON_FAILED, Module, $"Efem PreAligner align failed: {_efem.Status}");
                return true;
            }

            return false;
        }

        private bool Place2()
        {
            return _efem.Place(_targetModule, _targetSlot2, _hand2, _flip);
        }

        private bool Place2Done()
        {
            if (_efem.Status == RState.End)
            {
                WaferManager.Instance.WaferMoved(ModuleName.EfemRobot, (int)_hand2, _targetModule, _targetSlot2);
                return true;
            }
            else if (_efem.Status == RState.Failed)
            {
                NotifyError(eEvent.ERR_EFEM_ROBOT, $"Efem robot place failed: {_efem.Status}",-1);
                return true;
            }

            return false;
        }

        private bool ActionDone()
        {
            return true;
        }

        /// <summary>
        /// 重试
        /// </summary>
        /// <param name="step"></param>
        public RState Retry(int step)
        {
            if (!CheckPreCondition())
            {
                return RState.Failed;
            }
            _efem.Reset();
            List<Enum> preStepIds = new List<Enum>();
            AddPreSteps(PlaceStep.SetAlignWaferSize, preStepIds);
            return Runner.Retry(PlaceStep.SetAlignWaferSize, preStepIds, Module, "Place Retry");
        }

        /// <summary>
        /// 忽略前
        /// </summary>
        /// <param name="step"></param>
        /// <param name="preStepIds"></param>
        private void AddPreSteps(PlaceStep step, List<Enum> preStepIds)
        {
            for (int i = 0; i < (int)step; i++)
            {
                preStepIds.Add((PlaceStep)i);
            }
        }
        /// <summary>
        /// 检验前面完成状态
        /// </summary>
        /// <returns></returns>
        public bool CheckCompleteCondition(int index)
        {
            if (WaferManager.Instance.CheckHasWafer(ModuleName.EfemRobot, (int)_hand))
            {
                NotifyError(eEvent.ERR_EFEM_ROBOT, $"Efem robot arm{_hand} has no wafer", -1);
                return false;
            }
            if (WaferManager.Instance.CheckNoWafer(_targetModule, _targetSlot))
            {
                NotifyError(eEvent.ERR_EFEM_ROBOT, $"{_targetModule} Slot{_targetSlot} has no wafer", -1);
                return false;
            }
            return true;
        }
    }
}