PunkHPX8/PunkHPX8_RT/Schedulers/EfemRobot/SchedulerRobot.cs

using Aitex.Core.RT.Fsm;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.Routine;
using Aitex.Core.Util;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.Schedulers;
using PunkHPX8_Core;
using PunkHPX8_RT.Modules;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using MECF.Framework.Common.SubstrateTrackings;
using PunkHPX8_RT.Modules.SRD;
using PunkHPX8_RT.Modules.VpwMain;
using PunkHPX8_RT.Modules.VpwCell;
using MECF.Framework.Common.RecipeCenter;
using PunkHPX8_RT.Modules.PlatingCell;
using Aitex.Sorter.Common;
using PunkHPX8_RT.Dispatch;
using MECF.Framework.Common.ToolLayout;
using Aitex.Core.Common;
using PunkHPX8_RT.Devices.VpwMain;
using PunkHPX8_RT.Devices.PlatingCell;
using Aitex.Core.RT.Device;

namespace PunkHPX8_RT.Schedulers.EfemRobot
{
    public class SchedulerRobot : SchedulerModule
    {
        private enum SchedulerRobotOperation
        {
            None,
            Pick,
            PickWait,
            Place,
            PlaceWait
        }
        #region 内部变量
        private EfemEntity _efemEntity;
        #endregion

        #region 属性
        /// <summary>
        /// 是否空闲
        /// </summary>
        public override bool IsIdle
        {
            get { return _state == RState.End; }
        }
        /// <summary>
        /// 是否错误
        /// </summary>
        public override bool IsError
        {
            get { return _state == RState.Failed || _state == RState.Timeout; }
        }
        #endregion
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="module"></param>
        public SchedulerRobot(ModuleName module) : base(module.ToString())
        {
            _efemEntity = Singleton<RouteManager>.Instance.EFEM;
        }
        /// <summary>
        /// 执行
        /// </summary>
        /// <param name="parameter"></param>
        /// <returns></returns>
        public override bool RunProcess(object recipe, object parameter, List<SchedulerSyncModuleMessage> syncMessages)
        {
            if (_efemEntity.IsBusy)
            {
                return false;
            }
            MoveItem moveItem = (MoveItem)parameter;
            if (moveItem.SourceModule != ModuleName.Unknown&&moveItem.DestinationModule!=ModuleName.Unknown)
            {
                SynchorinzeModuleMessages(syncMessages);
                _state = RState.Running;
                if (RobotMoveHelper.Instance.IsIdle)
                {
                    RobotMoveHelper.Instance.Start(moveItem, Module.ToString());
                    return true;
                }
            }
            return false;
        }

        /// <summary>
        /// 监控执行
        /// </summary>
        /// <returns></returns>
        public override bool MonitorProcess(SchedulerSequence schedulerSequence, bool hasMatchWafer)
        {
            RobotMoveHelper.Instance.Monitor(Module.ToString());
            if (RobotMoveHelper.Instance.IsIdle)
            {
                _state = RState.End;
            }
            return true;
        }
        
        /// <summary>
        /// 检验前置条件
        /// </summary>
        /// <param name="sequenceIndex"></param>
        /// <param name="parameter"></param>
        /// <returns></returns>
        public override bool CheckPrecondition(List<SchedulerSequence> schedulerSequences, int sequenceIndex, object parameter,string materialId, ref string reason)
        {
            if (parameter == null)
            {
                reason = "parameter is null";
                return true;
            }
            if (_state == RState.Running)
            {
                reason = "scheduler module is already running";
                return false;
            }
            if(_efemEntity.IsBusy)
            {
                reason = "efem is busy";
                return false;
            }
            if(_efemEntity.IsError)
            {
                reason = "efem is error";
                return false;
            }

            MoveItem moveItem = (MoveItem)parameter;
            if(WaferManager.Instance.CheckHasWafer(ModuleName.EfemRobot, (int)Hand.Blade1))
            {
                reason = "robot lower hand has wafer";
                return false;
            }

            if (WaferManager.Instance.CheckHasWafer(ModuleName.EfemRobot, (int)Hand.Blade2))
            {
                reason = "robot upper hand has wafer";
                return false;
            }

            if (!CheckPreTaskComplete(materialId,schedulerSequences,sequenceIndex))
            {
                reason = "last wafer task has not completed";
                return false;
            }

            if (moveItem.SourceModule == ModuleName.Unknown)
            {
                UpdateUnkownSourceModule(schedulerSequences, moveItem, sequenceIndex);
            }
            if (moveItem.DestinationModule == ModuleName.Unknown)
            {
                bool result= UpdateUnkownTargetModule(schedulerSequences, moveItem, sequenceIndex);
                if (!result)
                {
                    reason = "efem robot confirm target module failed";
                    return false;
                }
            }

            if (!WaferManager.Instance.CheckHasWafer(moveItem.SourceModule, moveItem.SourceSlot))
            {
                reason = $"{moveItem.SourceModule} slot {moveItem.SourceSlot} has no wafer";
                return false;
            }
            if (WaferManager.Instance.CheckHasWafer(moveItem.DestinationModule, moveItem.DestinationSlot))
            {
                reason = $"{moveItem.DestinationModule} slot {moveItem.DestinationSlot} has wafer";
                return false;
            }

            if (ModuleHelper.IsVPWCell(moveItem.DestinationModule))
            {
                return CheckVpw(moveItem, schedulerSequences, sequenceIndex, ref reason);
            }
            if (ModuleHelper.IsPlatingCell(moveItem.DestinationModule))
            {
                return CheckPlatingCell(moveItem,  ref reason);
            }
            return true;
        }
        /// <summary>
        /// 检验VPW
        /// </summary>
        /// <param name="moveItem"></param>
        /// <param name="schedulerSequences"></param>
        /// <param name="sequenceIndex"></param>
        /// <param name="reason"></param>
        /// <returns></returns>
        private bool CheckVpw(MoveItem moveItem,List<SchedulerSequence> schedulerSequences, int sequenceIndex,ref string reason)
        {
            VpwCellEntity vpwEntity = Singleton<RouteManager>.Instance.GetModule<VpwCellEntity>(moveItem.DestinationModule.ToString());
            if (vpwEntity != null)
            {
                bool nextVpwRecipe = false;
                if (sequenceIndex + 1 < schedulerSequences.Count)
                {
                    SchedulerSequence nextSequence = schedulerSequences[sequenceIndex + 1];
                    if (nextSequence.ModuleType == ModuleType.VPW)
                    {
                        nextVpwRecipe = true;
                    }
                }
                if (nextVpwRecipe)
                {
                    if (vpwEntity.State == (int)VPWCellState.WaitForRunRecipe)
                    {
                        return true;
                    }
                    else
                    {
                        if (vpwEntity.IsIdle)
                        {
                            SchedulerSequence nextSequence = schedulerSequences[sequenceIndex + 1];
                            vpwEntity.CheckToPostMessage<VPWCellState, VPWCellMsg>(eEvent.INFO_VPW, Module.ToString(),
                                (int)VPWCellMsg.Prepare, nextSequence.Recipe);
                        }
                        reason = $"{vpwEntity.Module} state is not WaitForRunRecipe";
                        return false;
                    }
                }
                else
                {
                    VpwMainEntity vpwMainEntity = Singleton<RouteManager>.Instance.GetModule<VpwMainEntity>(ModuleName.VPWMain1.ToString());
                    if (vpwMainEntity.IsIdle)
                    {
                        if (vpwMainEntity.IsChamberOpened)
                        {
                            return true;
                        }
                        else
                        {
                            vpwMainEntity.CheckToPostMessage<VPWMainState, VPWMainMsg>(eEvent.INFO_VPW, Module.ToString(), (int)VPWMainMsg.ChamberDown);

                            reason = $"{vpwEntity.Module} chamber is not opened";
                            return false;
                        }
                    }
                    else
                    {
                        reason = $"{vpwMainEntity.Module} is not idle";
                        return false;
                    }
                }
            }
            else
            {
                reason = $"{moveItem.DestinationModule} is null";
            }
            return false;
        }

        /// <summary>
        /// 检验VPW
        /// </summary>
        /// <param name="moveItem"></param>
        /// <param name="schedulerSequences"></param>
        /// <param name="sequenceIndex"></param>
        /// <param name="reason"></param>
        /// <returns></returns>
        private bool CheckPlatingCell(MoveItem moveItem,ref string reason)
        {
            PlatingCellEntity entity = Singleton<RouteManager>.Instance.GetModule<PlatingCellEntity>(moveItem.DestinationModule.ToString());
            PlatingCellDevice platingCellDevice = DEVICE.GetDevice<PlatingCellDevice>(moveItem.DestinationModule.ToString());
            if (entity != null&&platingCellDevice!=null)
            {
                if (entity.State == (int)PlatingCellState.Idle&&platingCellDevice.PlatingCellDeviceData.ClamShellOpened)
                {
                    return true;
                }
                else
                {
                    if (entity.IsIdle)
                    {
                        entity.CheckToPostMessage<PlatingCellState, PlatingCellMsg>(eEvent.INFO_PLATINGCELL, Module.ToString(),
                            (int)PlatingCellMsg.Unload);
                    }
                    reason = $"{moveItem.DestinationModule} state is not idle";
                    return false;
                }
            }
            else
            {
                reason = $"{moveItem.DestinationModule} is null";
            }
            return false;
        }
        /// <summary>
        /// 更新未知源模块
        /// </summary>
        private void UpdateUnkownSourceModule(List<SchedulerSequence> schedulerSequences, MoveItem moveItem, int sequenceIndex)
        {
            if (moveItem.SourceModule == ModuleName.Unknown)
            {
                if (sequenceIndex >= 1 && sequenceIndex - 1 < schedulerSequences.Count)
                {
                    SchedulerSequence preSchedulerSequence = schedulerSequences[sequenceIndex - 1];
                    if (preSchedulerSequence != null && preSchedulerSequence.SchedulerModule != null)
                    {
                        moveItem.SourceModule = preSchedulerSequence.SchedulerModule.Module;
                    }
                }
            }
        }
        /// <summary>
        /// 更新未知目标模块
        /// </summary>
        private bool UpdateUnkownTargetModule(List<SchedulerSequence> schedulerSequences, MoveItem moveItem, int sequenceIndex)
        {
            SchedulerSequence currentSchedulerSequence= schedulerSequences[sequenceIndex];
            if (sequenceIndex >= schedulerSequences.Count - 1)
            {
                return false;
            }
            SchedulerSequence nextSequence=schedulerSequences[sequenceIndex+1];
            ModuleName moduleName = ModuleName.Unknown;
            if (moveItem.DestinationType == ModuleType.SRD)
            {
                SRDEntity srd1Entity = Singleton<RouteManager>.Instance.GetModule<SRDEntity>(ModuleName.SRD1.ToString());
                if (srd1Entity != null&&srd1Entity.IsIdle&&srd1Entity.IsAuto&&WaferManager.Instance.CheckNoWafer(ModuleName.SRD1.ToString(),0))
                {
                    moduleName = ModuleName.SRD1;
                }
                else
                {
                    SRDEntity srd2Entity= Singleton<RouteManager>.Instance.GetModule<SRDEntity>(ModuleName.SRD2.ToString());
                    if (srd2Entity != null && srd2Entity.IsIdle&&srd2Entity.IsAuto && WaferManager.Instance.CheckNoWafer(ModuleName.SRD2.ToString(), 0))
                    {
                        moduleName=ModuleName.SRD2;
                    }
                }

            }
            else if (moveItem.DestinationType == ModuleType.PlatingCell)
            {
                DepRecipe depRecipe = (DepRecipe)nextSequence.Recipe;
                List<PlatingCellEntity> platingCellEntities= SchedulerSequenceManager.Instance.GetAvaiblePlatingCellList(depRecipe.Chemistry, nextSequence.SequenceType, nextSequence.WaferSize, true);
                if (platingCellEntities.Count > 0)
                {
                    moduleName = platingCellEntities[0].Module;
                }
            }
            else
            {
                return false;
            } 
            
            if (moduleName == ModuleName.Unknown)
            {
                return false;
            }
            else
            {
                if(WaferManager.Instance.CheckHasWafer(moduleName,0))
                {
                    return false;
                }
                IModuleEntity moduleEntity = Singleton<RouteManager>.Instance.GetModule<IModuleEntity>(moduleName.ToString());
                if (moduleEntity==null)
                {
                    return false;
                }
                if (moduleEntity.IsBusy)
                {
                    return false;
                }
                moveItem.DestinationModule = moduleName;
                if (sequenceIndex + 1 < schedulerSequences.Count)
                {
                    SchedulerSequence sequence = schedulerSequences[sequenceIndex + 1];
                    if (sequence.SchedulerModule == null)
                    {
                        sequence.SchedulerModule = SchedulerManager.Instance.GetScheduler(moduleName);
                        sequence.ModuleName = moduleName;
                    }
                }
            }
            return true;
        }
        /// <summary>
        /// 检验上一个任务是否完成
        /// </summary>
        /// <param name="materialId"></param>
        /// <returns></returns>
        private bool CheckPreTaskComplete(string materialId, List<SchedulerSequence> schedulerSequences, int sequenceIndex)
        {
            WaferTask waferTask = WaferTaskManager.Instance.GetWaferTask(materialId);
            if(waferTask == null)
            {
                return true;
            }
            WaferInfo waferInfo = WaferManager.Instance.GetWaferByWaferId(materialId);
            if (waferInfo == null || waferInfo.IsEmpty)
            {
                return true;
            }
            if (!string.IsNullOrEmpty(waferTask.MateWaferTask))
            {
                return true;
            }

            if (sequenceIndex < 1)
            {
                return true;
            }
            SchedulerSequence preSequence=schedulerSequences[sequenceIndex-1];
            if (preSequence==null)
            {
                return true;
            }
            if (preSequence.ModuleName!=ModuleName.Aligner1)
            {
                return true;
            }
            List<string> platingCells = PlatingCellItemManager.Instance.InstalledModules;
            foreach(string item in platingCells)
            {
                PlatingCellEntity platingCellEntity = Singleton<RouteManager>.Instance.GetModule<PlatingCellEntity>(item);
                if (!platingCellEntity.IsAuto)
                {
                    continue;
                }
                if (platingCellEntity.MetalWaferSize != (int)waferInfo.Size)
                {
                    continue;
                }
                if (WaferManager.Instance.CheckHasWafer(item, 0))
                {
                    return false;
                }
            }
            List<string> vpwCells = VpwCellItemManager.Instance.InstalledModules;
            foreach (string item in vpwCells)
            {
                VpwCellEntity entity = Singleton<RouteManager>.Instance.GetModule<VpwCellEntity>(item);
                if (!entity.IsAuto)
                {
                    continue;
                }
                if (entity.VpwWaferSize != (int)waferInfo.Size)
                {
                    continue;
                }
                if (WaferManager.Instance.CheckHasWafer(item, 0))
                {
                    return false;
                }
            }
            return true;
        }

        public override void ResetTask()
        {
            base.ResetTask();
            RobotMoveHelper.Instance.Reset();
        }
    }
}