CyberX8/CyberX8_RT/Schedulers/Transporter/SchedulerLoaderTransporter.cs

using Aitex.Core.RT.Fsm;
using Aitex.Core.Util;
using MECF.Framework.Common.CommonData;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.SubstrateTrackings;
using CyberX8_Core;
using CyberX8_RT.Modules;
using CyberX8_RT.Modules.Loader;
using CyberX8_RT.Modules.Transporter;
using CyberX8_RT.Modules.PUF;
using System;
using System.Collections.Generic;
using System.Linq;
using System.ServiceModel.Syndication;
using System.Text;
using System.Threading.Tasks;
using CyberX8_RT.Modules.Prewet;
using Aitex.Core.RT.Device;
using CyberX8_RT.Devices.AXIS;
using MECF.Framework.Common.WaferHolder;
using Aitex.Core.RT.Log;

namespace CyberX8_RT.Schedulers.Transporter
{
    public class SchedulerLoaderTransporter : SchedulerModule
    {
        private enum TransBufferToLoaderStep
        {
            None,
            NotifyLoaderPrepare,
            WaitLoaderPrePare,
            PickUpValidate,
            PickUpValidateMoveto,
            Place,
            End
        }
        #region 内部变量
        private LoaderEntity _loaderEntity;
        private TransporterEntity _loaderTransporterEntity;
        private TransporterEntity _processTransporterEntity;
        private TransBufferToLoaderStep _transBufferToLoaderStep = TransBufferToLoaderStep.None;
        private SchedulerPostMsg _schedulerPostMsg = new SchedulerPostMsg();
        private bool _postMsgResult = false;
        #endregion

        #region 属性

        public override bool IsIdle
        {
            get { return _state == RState.End; }
        }

        public  bool IsBusy
        {
            get { return _state == RState.Running; }
        }
        public override bool IsError
        {
            get { return _state==RState.Failed||_state==RState.Timeout; }
        }
        #endregion
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="module"></param>
        public SchedulerLoaderTransporter(ModuleName module) : base(module.ToString())
        {
            _loaderEntity = Singleton<RouteManager>.Instance.GetModule<LoaderEntity>(ModuleName.Loader1.ToString());
            _loaderTransporterEntity = Singleton<RouteManager>.Instance.GetModule<TransporterEntity>(ModuleName.Transporter2.ToString());
            _processTransporterEntity = Singleton<RouteManager>.Instance.GetModule<TransporterEntity>(ModuleName.Transporter1.ToString());
        }
        /// <summary>
        /// 执行
        /// </summary>
        /// <param name="parameter"></param>
        /// <returns></returns>
        public override bool RunProcess(object recipe, object parameter,List<SchedulerSyncModuleMessage> syncMessages)
        {
            if(parameter==null||!(parameter is WaferHolderMoveItem))
            {
                return false;
            }
            WaferHolderMoveItem waferHolderMoveItem=(WaferHolderMoveItem)parameter;
            if(waferHolderMoveItem.SourceModule!=ModuleName.Unknown&&waferHolderMoveItem.DestModule!=ModuleName.Unknown)
            {
                SchedulerProcessTransporter schedulerProcessTransporter = (SchedulerProcessTransporter)SchedulerManager.Instance.GetScheduler(ModuleName.Transporter1);
                if(schedulerProcessTransporter.IsBusy&&_processTransporterEntity.IsIdle)
                {
                    return false;
                }
                if (!_loaderTransporterEntity.CheckOtherEntityStatus(waferHolderMoveItem.SourceModule.ToString()))
                {
                    return false;
                }
                if (!_loaderTransporterEntity.CheckOtherEntityStatus(waferHolderMoveItem.DestModule.ToString()))
                {
                    return false;
                }
                string strSource = waferHolderMoveItem.SourceModule.ToString();
                if(waferHolderMoveItem.SourceModule==ModuleName.Loader1)
                {
                    strSource = "Loader";
                }
                //由于PickUpValidate可能存在校验失败的现象
                if (!WaferHolderManager.Instance.HasWaferHolder(strSource)&&_loaderTransporterEntity.State!=(int)TransporterState.PickUpValidateComplete)
                { 
                    return false;
                }
                string strDest = waferHolderMoveItem.DestModule.ToString();
                if(waferHolderMoveItem.DestModule==ModuleName.Loader1)
                {
                    strDest = "Loader";
                }
                if(WaferHolderManager.Instance.HasWaferHolder(strDest))
                {
                    return false;
                }
                if (waferHolderMoveItem.DestModule==ModuleName.Loader1)
                {
                    return TransferWaferHolderToLoader(waferHolderMoveItem);
                }
                else if(waferHolderMoveItem.SourceModule==ModuleName.Loader1)
                {
                    return TransWaferHolderFromLoader(waferHolderMoveItem);
                }
                else if(waferHolderMoveItem.SourceModuleType!=ModuleType.Loader&&waferHolderMoveItem.DestModuleType!=ModuleType.Loader)
                {
                    return TransferWaferHolderNonLoader(waferHolderMoveItem);
                }
            }
            return true;
        }
        /// <summary>
        /// WaferHolder从Loader移动至Buffer
        /// </summary>
        private bool TransWaferHolderFromLoader(WaferHolderMoveItem waferHolderMoveItem)
        {
            if (_loaderEntity.IsBusy)
            {
                return false;
            }
            if (_loaderEntity.WaferHolderInfo == null)
            {
                return false;
            }
            bool result = _loaderTransporterEntity.CheckToPostMessage<TransporterState, TransporterMSG>(Aitex.Core.RT.Log.eEvent.WARN_TRANSPORTER,
                Module.ToString(), (int)TransporterMSG.Transfer, "Loader", waferHolderMoveItem.DestModule.ToString());
            if (result)
            {
                _state = RState.Running;
                _schedulerPostMsg.Reset();
                _postMsgResult = false;
            }
            return result;
        }
        /// <summary>
        /// WaferHolder从Buffer移动至Loader
        /// </summary>
        private bool TransferWaferHolderToLoader(WaferHolderMoveItem waferHolderMoveItem)
        {
            if (_loaderEntity.WaferHolderInfo != null)
            {
                return false;
            }

            if (_loaderEntity.IsIdle)
            {
                bool loaderResult = _loaderEntity.CheckToPostMessage<LOADERSTATE, LoaderMSG>(Aitex.Core.RT.Log.eEvent.WARN_LOADER,
                    _loaderEntity.Module.ToString(), (int)LoaderMSG.PrepareForPlace);
                if (loaderResult)
                {
                    _transBufferToLoaderStep = TransBufferToLoaderStep.WaitLoaderPrePare;
                }
                return false;
            }
            else if(_loaderEntity.State == (int)LOADERSTATE.WaitForUnload&&_transBufferToLoaderStep<TransBufferToLoaderStep.PickUpValidate)
            {
                _transBufferToLoaderStep = TransBufferToLoaderStep.PickUpValidate;
                return false;
            }
            else if (_transBufferToLoaderStep == TransBufferToLoaderStep.WaitLoaderPrePare)
            {
                if (_loaderEntity.State == (int)LOADERSTATE.WaitForUnload)
                {
                    _transBufferToLoaderStep = TransBufferToLoaderStep.PickUpValidate;
                }
                return false;
            }
            else if (_transBufferToLoaderStep == TransBufferToLoaderStep.PickUpValidate)
            {
                if(_loaderTransporterEntity.IsBusy)
                {
                    return false;
                }
                if (!_loaderTransporterEntity.CheckOtherEntityStatus(waferHolderMoveItem.SourceModule.ToString()))
                {
                    return false;
                }
                if (!_loaderTransporterEntity.CheckOtherEntityStatus(waferHolderMoveItem.DestModule.ToString()))
                {
                    return false;
                }
                bool result = _loaderTransporterEntity.CheckToPostMessage<TransporterState, TransporterMSG>(Aitex.Core.RT.Log.eEvent.WARN_TRANSPORTER,
                    Module.ToString(), (int)TransporterMSG.PickUpValidate, waferHolderMoveItem.SourceModule.ToString());
                if (result)
                {
                    _transBufferToLoaderStep= TransBufferToLoaderStep.PickUpValidateMoveto;
                    _state = RState.Running;
                    _schedulerPostMsg.Reset();
                    _postMsgResult = false;
                    return true;
                }
            }
            return false;
        }

        /// <summary>
        /// 传输WaferHolder（无WaferHolder）
        /// </summary>
        /// <param name="waferHolderMoveItem"></param>
        private bool TransferWaferHolderNonLoader(WaferHolderMoveItem waferHolderMoveItem)
        {
            IModuleEntity moduleEntity = Singleton<RouteManager>.Instance.GetModule<IModuleEntity>(waferHolderMoveItem.DestModule.ToString());
            if (moduleEntity != null)
            {
                if (waferHolderMoveItem.SourceModule == ModuleName.Unknown || waferHolderMoveItem.DestModule == ModuleName.Unknown)
                {
                    return false;
                }
                if (moduleEntity.Module == ModuleName.Prewet1)
                {
                    PrewetEntity prewetEntity = moduleEntity as PrewetEntity;
                    if(prewetEntity.State!=(int)PrewetState.WaitForPlace)
                    {
                        return false;
                    }
                }
                else
                {
                    if (!moduleEntity.IsIdle)
                    {
                        return false;
                    }
                }
                if (waferHolderMoveItem.SourceModule != ModuleName.Unknown)
                {
                    if (!_loaderTransporterEntity.CheckOtherEntityStatus(waferHolderMoveItem.SourceModule.ToString()))
                    {
                        return false;
                    }
                }
                if (waferHolderMoveItem.DestModule != ModuleName.Unknown)
                {
                    if (!_loaderTransporterEntity.CheckOtherEntityStatus(waferHolderMoveItem.DestModule.ToString()))
                    {
                        return false;
                    }
                }
                bool result = _loaderTransporterEntity.CheckToPostMessage<TransporterState, TransporterMSG>(Aitex.Core.RT.Log.eEvent.WARN_TRANSPORTER,
                    Module.ToString(), (int)TransporterMSG.Transfer, waferHolderMoveItem.SourceModule.ToString(), waferHolderMoveItem.DestModule.ToString());
                if (result)
                {
                    _state = RState.Running;
                    _postMsgResult = false;
                    _schedulerPostMsg.Reset();
                }
                return result;
            }
            return false;
        }
        /// <summary>
        /// 监控执行
        /// </summary>
        /// <returns></returns>
        public override bool MonitorProcess(SchedulerSequence schedulerSequence, bool hasMatchWafer)
        {
            WaferHolderMoveItem moveItem=schedulerSequence.Parameters as WaferHolderMoveItem;
            //检验PostMsg的结果
            if (!_postMsgResult)
            {
                if (_loaderTransporterEntity.IsError)
                {
                    return false;
                }
                _postMsgResult = CheckPostMsg(moveItem);
                if (!_postMsgResult)
                {
                    return false;
                }
            }
            if (moveItem.DestModule == ModuleName.Loader1)
            {
                if (_transBufferToLoaderStep == TransBufferToLoaderStep.PickUpValidateMoveto)
                {
                    if (_loaderTransporterEntity.IsIdle)
                    {
                        _state = RState.Failed;
                        _transBufferToLoaderStep = TransBufferToLoaderStep.None;
                        return false;
                    }
                    if (_loaderTransporterEntity.State == (int)TransporterState.PickUpValidateComplete)
                    {
                        if (!_loaderTransporterEntity.CheckOtherEntityStatus("Loader"))
                        {
                            return false;
                        }
                        bool result = _loaderTransporterEntity.CheckToPostMessage<TransporterState, TransporterMSG>(Aitex.Core.RT.Log.eEvent.WARN_TRANSPORTER,
                                Module.ToString(), (int)TransporterMSG.MoveTo, "Loader");
                        if (result)
                        {
                            _transBufferToLoaderStep = TransBufferToLoaderStep.Place;
                        }
                    }
                    return true;

                }
                else if (_transBufferToLoaderStep == TransBufferToLoaderStep.Place)
                {
                    if (_loaderTransporterEntity.State == (int)TransporterState.ValidateMoveToComplete)
                    {
                        bool result = _loaderTransporterEntity.CheckToPostMessage<TransporterState, TransporterMSG>(Aitex.Core.RT.Log.eEvent.WARN_TRANSPORTER,
                                Module.ToString(), (int)TransporterMSG.Place, "Loader");
                        if (result)
                        {
                            _transBufferToLoaderStep = TransBufferToLoaderStep.End;
                        }
                    }
                    return true;
                }
            }
            if (_loaderTransporterEntity.IsIdle)
            {
                if(_loaderTransporterEntity.WaferHolderInfo!=null)
                {
                    return false;
                }
                PrewetPickComplete(schedulerSequence);
                _state = RState.End;
            }
            return true;
        }
        /// <summary>
        /// 检验PostMsg的结果
        /// </summary>
        /// <param name="waferHolderMoveItem"></param>
        /// <returns></returns>
        private bool CheckPostMsg(WaferHolderMoveItem waferHolderMoveItem)
        {
            if (waferHolderMoveItem.DestModule == ModuleName.Loader1)
            {
                return _schedulerPostMsg.PostMsg<TransporterState,TransporterMSG>(_loaderTransporterEntity, _loaderTransporterEntity.State, 
                    eEvent.WARN_TRANSPORTER,Module.ToString(), (int)TransporterMSG.PickUpValidate, 
                    (int)TransporterState.PickUpValidating, waferHolderMoveItem.SourceModule.ToString());
            }
            else
            {
                return _schedulerPostMsg.PostMsg<TransporterState, TransporterMSG>(_loaderTransporterEntity, _loaderTransporterEntity.State,
                    eEvent.WARN_TRANSPORTER, Module.ToString(), (int)TransporterMSG.Transfer,
                    (int)TransporterState.Transfering, waferHolderMoveItem.SourceModule.ToString(),waferHolderMoveItem.DestModule.ToString());
            }
        }
        /// <summary>
        /// PrewetPick完成事件
        /// </summary>
        private void PrewetPickComplete(SchedulerSequence sequence)
        {
            if (sequence.Parameters is WaferHolderMoveItem)
            {
                WaferHolderMoveItem waferHolderMoveItem = (WaferHolderMoveItem)sequence.Parameters;
                if (waferHolderMoveItem.SourceModule == ModuleName.Prewet1)
                {
                    PrewetEntity prewetEntity = Singleton<RouteManager>.Instance.GetModule<PrewetEntity>(ModuleName.Prewet1.ToString());
                    if (prewetEntity.State == (int)PrewetState.WaitForPick)
                    {
                        prewetEntity.CheckToPostMessage<PrewetState, PrewetMsg>(Aitex.Core.RT.Log.eEvent.WARN_PREWET, ModuleName.Prewet1.ToString(),
                            (int)PrewetMsg.PickComplete);
                    }
                }
            }
        }

        /// <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)
        {
            _state = RState.Init;
            if(!(parameter is WaferHolderMoveItem))
            {
                reason = "parameter is not WaferHolderMoveItem";
                return false;
            }
            if (_state == RState.Running)
            {
                reason = "scheduler module is already running";
                return false;
            }
            if (_loaderTransporterEntity.IsBusy)
            {
                reason = "loader transporter entity is busy";
                return false;
            }
            if (_loaderTransporterEntity.WaferHolderInfo != null&& _loaderTransporterEntity.State != (int)TransporterState.PickUpValidateComplete)
            {
                reason = "loader transporter has wafer shuttle,but state is not PickUpValidateComplete";
                return false;
            }
            //电机是否还在执行动作
            JetAxisBase gantryAxis = DEVICE.GetDevice<JetAxisBase>($"{ModuleName.Transporter2}.Gantry");
            if (gantryAxis == null)
            {
                reason = "loader transporter gantry is null";
                return false;
            }
            if (gantryAxis.Status == RState.Running)
            {
                reason = "loader transporter gantry is running";
                return false;
            }
            JetAxisBase elevatorAxis = DEVICE.GetDevice<JetAxisBase>($"{ModuleName.Transporter2}.Elevator");
            if (elevatorAxis == null)
            {
                reason = "loader transporter elevator is null";
                return false;
            }
            if (elevatorAxis.Status == RState.Running)
            {
                reason = "loader transporter elevator is running";
                return false;
            }

            WaferHolderMoveItem waferHolderMoveItem = (WaferHolderMoveItem)parameter;
            //更新未知目标模块
            bool result= UpdateUnkownTargetModule(schedulerSequences,waferHolderMoveItem,sequenceIndex, materialId);
            if(!result)
            {
                reason = "loader transporter moveitem target module is unknown";
                return false;
            }
            //更新未知源模块
            UpdateUnkownSourceModule(schedulerSequences, waferHolderMoveItem, sequenceIndex,materialId);
            
            if (waferHolderMoveItem.SourceModule != ModuleName.Unknown)
            {
                if (!_loaderTransporterEntity.CheckOtherEntityStatus(waferHolderMoveItem.SourceModule.ToString()))
                {
                    reason = $"loader transporter {waferHolderMoveItem.SourceModule} conflict process transporter";
                    return false;
                }
            }
            if (waferHolderMoveItem.DestModule != ModuleName.Unknown)
            {
                if (!_loaderTransporterEntity.CheckOtherEntityStatus(waferHolderMoveItem.DestModule.ToString()))
                {
                    reason = $"loader transporter {waferHolderMoveItem.DestModule} conflict process transporter";
                    return false;
                }
            }
            //目标为Prewet
            if (waferHolderMoveItem.DestModule == ModuleName.Prewet1)
            {
                bool prewetCondition= CheckTargetPrewetCondition();
                if (!prewetCondition)
                {
                    reason = "loader transporter destmodule prewet condition is not avaible";
                }
                return prewetCondition;
            }
            //源为Prewet
            if (waferHolderMoveItem.SourceModule == ModuleName.Prewet1)
            {
                bool prewetCondition= CheckSourcePrewetCondition(); 
                if (!prewetCondition)
                {
                    reason = "loader transporter sourcemodule prewet condition is not avaible";
                }
            }
            return true;
        }
        /// <summary>
        /// 更新未知目标模块
        /// </summary>
        private bool UpdateUnkownTargetModule(List<SchedulerSequence> schedulerSequences, WaferHolderMoveItem waferHolderMoveItem, int sequenceIndex,string materialId)
        {
            SchedulerSequence currentSequence = schedulerSequences[sequenceIndex];
            if (waferHolderMoveItem.DestModule == ModuleName.Unknown)
            {
                ModuleName moduleName = SchedulerSequenceManager.Instance.GetAvaibleEmptyModuleCell(waferHolderMoveItem.DestModuleType,currentSequence.SequenceType);
                if (moduleName == ModuleName.Unknown)
                {
                    return false;
                }
                else
                {
                    waferHolderMoveItem.DestModule = moduleName;
                    if (sequenceIndex + 1 < schedulerSequences.Count)
                    {
                        SchedulerSequence sequence = schedulerSequences[sequenceIndex + 1];
                        if (sequence.SchedulerModule == null)
                        {
                            sequence.SchedulerModule = SchedulerManager.Instance.GetScheduler(moduleName);
                            sequence.ModuleName = moduleName;
                            LOG.WriteLog(eEvent.INFO_TRANSPORTER, Module.ToString(), $"{materialId} loadertransporter confirm source module {moduleName}");
                        }
                    }
                }
            }
            return true;
        }
        /// <summary>
        /// 更新未知源模块
        /// </summary>
        private void UpdateUnkownSourceModule(List<SchedulerSequence> schedulerSequences, WaferHolderMoveItem waferHolderMoveItem,int sequenceIndex,string materialId)
        {
            if (waferHolderMoveItem.SourceModule == ModuleName.Unknown)
            {
                if (sequenceIndex >= 1 && sequenceIndex - 1 < schedulerSequences.Count)
                {
                    SchedulerSequence preSchedulerSequence = schedulerSequences[sequenceIndex - 1];
                    if (preSchedulerSequence != null && preSchedulerSequence.SchedulerModule != null)
                    {
                        waferHolderMoveItem.SourceModule = preSchedulerSequence.SchedulerModule.Module;
                        LOG.WriteLog(eEvent.INFO_TRANSPORTER, Module.ToString(), $"{materialId} loadertransporter confirm source module {preSchedulerSequence.SchedulerModule.Module}");
                    }
                }
            }
        }
        /// <summary>
        /// 检验目标Prewet前置条件
        /// </summary>
        /// <returns></returns>
        private bool CheckTargetPrewetCondition()
        {
            PrewetEntity prewetEntity = Singleton<RouteManager>.Instance.GetModule<PrewetEntity>(ModuleName.Prewet1.ToString());
            if(prewetEntity.IsIdle)
            {
                prewetEntity.CheckToPostMessage<PrewetState, PrewetMsg>(Aitex.Core.RT.Log.eEvent.WARN_PREWET, ModuleName.Prewet1.ToString(),
                    (int)PrewetMsg.PrepareToPlace);
            }
            else if(prewetEntity.State==(int)PrewetState.WaitForPlace)
            {
                return true;
            }
            return false;
        }

        /// <summary>
        /// 检验源Prewet前置条件
        /// </summary>
        /// <returns></returns>
        private bool CheckSourcePrewetCondition()
        {
            PrewetEntity prewetEntity = Singleton<RouteManager>.Instance.GetModule<PrewetEntity>(ModuleName.Prewet1.ToString());
            if (prewetEntity.State == (int)PrewetState.WaitForPick||prewetEntity.IsError)
            {
                return true;
            }
            return false;
        }

        public override void ResetTask()
        {
            base.ResetTask();
            _schedulerPostMsg.Reset();
            _postMsgResult = false;
        }
    }
}