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;
using MECF.Framework.Common.Schedulers;
using Aitex.Core.RT.SCCore;
using CyberX8_RT.Dispatch;
using MECF.Framework.Common.RecipeCenter;

namespace CyberX8_RT.Schedulers.Transporter
{
    public class SchedulerLoaderTransporter : SchedulerModule
    {
        private enum TransBufferToLoaderStep
        {
            None,
            NotifyLoaderPrepare,
            WaitLoaderPrePare,
            PickUpValidate,
            PickUpValidateMoveto,
            Place,
            End
        }

        private enum TransporterFlip
        {
            None,
            WaitPickUp,
            LoaderFlip,
            WaitLoader,
            WaitPlace,
        }
        #region 内部变量
        private LoaderEntity _loaderEntity;
        private TransporterEntity _loaderTransporterEntity;
        private TransporterEntity _processTransporterEntity;
        private TransBufferToLoaderStep _transBufferToLoaderStep = TransBufferToLoaderStep.None;
        private SchedulerPostMsg _schedulerPostMsg = new SchedulerPostMsg();
        private bool _postMsgResult = false;
        private TransporterFlip _transporterFlip=TransporterFlip.None;
        #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)
            {
                return false;
            }

            TransporterAction action = (TransporterAction)parameter;

            if (action.ActionMsg == TransporterMSG.Transfer)
            {
                SynchorinzeModuleMessages(syncMessages);
                WaferHolderMoveItem waferHolderMoveItem = (WaferHolderMoveItem)action.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 (CheckProcessTransporterWillMeetConflict(strSource, 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);
                    }
                }
            }
            else if (action.ActionMsg == TransporterMSG.Flip)
            {
                return FlipLoader();
            }
            return true;
        }
        /// <summary>
        /// 检验是否将与ProcessTransporter存在冲突的风险
        /// </summary>
        /// <returns></returns>
        private bool CheckProcessTransporterWillMeetConflict(string source, string dest)
        {
            bool transporter1Priority = SC.GetValue<bool>("Scheduler.EnableTransporter1Priority");
            if (!transporter1Priority)
            {
                return false;
            }
            if (!SchedulerManager.Instance.IsQdrCheckConflict)
            {
                return false;
            }

            var result = SchedulerTransporterTimeManager.Instance.GetCurrentTransporter1Scheduler(DateTime.Now);
            if (string.IsNullOrEmpty(result.waferHolderId))
            {
                return false;
            }

            WaferHolderTask waferHolderTask = WaferHolderTaskManager.Instance.GetWaferHolderTaskByWaferHolderId(result.waferHolderId);
            if (waferHolderTask == null)
            {
                return false;
            }

            SchedulerSequence schedulerSequence = waferHolderTask.GetSchedulerSequenceByIndex(result.sequenceIndex);
            if (schedulerSequence == null)
            {
                return false;
            }
            if (schedulerSequence.SchedulerModule == null)
            {
                return false;
            }
            if (schedulerSequence.SchedulerModule.Module != ModuleName.Transporter1)
            {
                return false;
            }
            if (!(schedulerSequence.Parameters is TransporterAction))
            {
                return false;
            }
            TransporterAction action = schedulerSequence.Parameters as TransporterAction;
            if(!(action.Parameter is WaferHolderMoveItem))
            {
                return false;
            }
            WaferHolderMoveItem waferHolderMoveItem = action.Parameter as WaferHolderMoveItem;
            bool isLog = SC.GetValue<bool>("Scheduler.IsShowLog");
            if (waferHolderMoveItem.SourceModule != ModuleName.Unknown)
            {
                if (_loaderTransporterEntity.CheckOtherModuleConflict(ModuleName.Transporter1.ToString(), waferHolderMoveItem.SourceModule.ToString(), source))
                {
                    if (isLog)
                    {
                        LOG.WriteLog(eEvent.EV_SCHEDULER, Module.ToString(), $"transporter2 source {source} will meet {waferHolderTask.WaferHolderInfo.Id} scheduler index {result.sequenceIndex} transporter1 source {waferHolderMoveItem.SourceModule}");
                    }
                    return true;
                }
                if (_loaderTransporterEntity.CheckOtherModuleConflict(ModuleName.Transporter1.ToString(), waferHolderMoveItem.SourceModule.ToString(), dest))
                {
                    if (isLog)
                    {
                        LOG.WriteLog(eEvent.EV_SCHEDULER, Module.ToString(), $"transporter2 dest {dest} will meet {waferHolderTask.WaferHolderInfo.Id} scheduler index {result.sequenceIndex} transporter1 source {waferHolderMoveItem.SourceModule}");
                    }
                    return true;
                }
            }
            if (waferHolderMoveItem.DestModule != ModuleName.Unknown)
            {
                //Transporter1目标是Transporter2的起点，这样容易Transporter2不取走，Transporter1放不进去导致卡住
                if (waferHolderMoveItem.DestModule.ToString() == source)
                {
                    return false;
                }
                if (_loaderTransporterEntity.CheckOtherModuleConflict(ModuleName.Transporter1.ToString(), waferHolderMoveItem.DestModule.ToString(), source))
                {
                    if (isLog)
                    {
                        LOG.WriteLog(eEvent.EV_SCHEDULER, Module.ToString(), $"transporter2 source {source} will meet {waferHolderTask.WaferHolderInfo.Id} scheduler index {result.sequenceIndex} transporter1 dest {waferHolderMoveItem.DestModule}");
                    }
                    return true;
                }
                if (_loaderTransporterEntity.CheckOtherModuleConflict(ModuleName.Transporter1.ToString(), waferHolderMoveItem.DestModule.ToString(), dest))
                {
                    if (isLog)
                    {
                        LOG.WriteLog(eEvent.EV_SCHEDULER, Module.ToString(), $"transporter2 dest {dest} will meet {waferHolderTask.WaferHolderInfo.Id} scheduler index {result.sequenceIndex} transporter1 dest {waferHolderMoveItem.DestModule}");
                    }
                    return true;
                }
            }
            return false;
        }
        /// <summary>
        /// Loader 开始Flip
        /// </summary>
        /// <returns></returns>
        private bool FlipLoader()
        {
            if (_loaderEntity.WaferHolderInfo == null)
            {
                return false;
            }

            if (_loaderTransporterEntity.WaferHolderInfo != null)
            {
                return false;
            }
            bool result = _loaderTransporterEntity.CheckToPostMessage<TransporterState, TransporterMSG>(eEvent.INFO_TRANSPORTER,
                Module.ToString(), (int)TransporterMSG.PickUpFrom, "Loader");
            if (result)
            {
                _state = RState.Running;
                _schedulerPostMsg.Reset();
                _postMsgResult = false;
                _transporterFlip = TransporterFlip.WaitPickUp;
            }
            return result;
        }
        /// <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.INFO_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>(eEvent.INFO_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.INFO_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.INFO_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)
        {
            TransporterAction action=schedulerSequence.Parameters as TransporterAction;
            if (action.ActionMsg == TransporterMSG.Transfer)
            {
                WaferHolderMoveItem moveItem = action.Parameter 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.INFO_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.INFO_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;
                    _transBufferToLoaderStep=TransBufferToLoaderStep.None;
                }
            }
            else if (action.ActionMsg == TransporterMSG.Flip)
            {
                LoaderTransporterFlip(action.Parameter.ToString());
            }
            return true;
        }
        /// <summary>
        /// Flip
        /// </summary>
        private void LoaderTransporterFlip(string strTransporter)
        {
            if(_transporterFlip==TransporterFlip.WaitPickUp)
            {
                //检验PostMsg的结果
                if (!_postMsgResult)
                {
                    if (_loaderTransporterEntity.IsError)
                    {
                        return;
                    }
                    _postMsgResult = _schedulerPostMsg.PostMsg<TransporterState, TransporterMSG>(_loaderTransporterEntity, _loaderTransporterEntity.State,
                        eEvent.INFO_TRANSPORTER, Module.ToString(), (int)TransporterMSG.PickUpFrom,(int)TransporterState.PickUping, "Loader");
                    if (!_postMsgResult)
                    {
                        return;
                    }
                }

                if (_loaderTransporterEntity.IsIdle && _loaderTransporterEntity.WaferHolderInfo != null)
                {
                    _transporterFlip = TransporterFlip.LoaderFlip;
                }
            }
            else if (_transporterFlip == TransporterFlip.LoaderFlip)
            {
                bool result = _loaderEntity.CheckToPostMessage<LOADERSTATE, LoaderMSG>(eEvent.INFO_LOADER, Module.ToString(), (int)LoaderMSG.PrepareForPlace, strTransporter);
                if (result)
                {
                    _transporterFlip = TransporterFlip.WaitLoader;
                }
            }
            else if(_transporterFlip==TransporterFlip.WaitLoader)
            {
                if (_loaderEntity.State == (int)LOADERSTATE.WaitForUnload)
                {
                    bool result = _loaderTransporterEntity.CheckToPostMessage<TransporterState, TransporterMSG>(eEvent.INFO_TRANSPORTER,
                                    Module.ToString(), (int)TransporterMSG.Place, "Loader");
                    if (result)
                    {
                        _transporterFlip = TransporterFlip.WaitPlace;
                    }
                }
            }
            else if (_transporterFlip == TransporterFlip.WaitPlace)
            {
                if (_loaderTransporterEntity.IsIdle && _loaderTransporterEntity.WaferHolderInfo == null)
                {
                    _state = RState.End;
                    _transporterFlip = TransporterFlip.None;
                }
            }
        } 
        /// <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.INFO_TRANSPORTER,Module.ToString(), (int)TransporterMSG.PickUpValidate, 
                    (int)TransporterState.PickUpValidating, waferHolderMoveItem.SourceModule.ToString());
            }
            else
            {
                return _schedulerPostMsg.PostMsg<TransporterState, TransporterMSG>(_loaderTransporterEntity, _loaderTransporterEntity.State,
                    eEvent.INFO_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 TransporterAction)
            {
                TransporterAction action = (TransporterAction)sequence.Parameters;
                if (action.ActionMsg!=TransporterMSG.Transfer)
                {
                    return;
                }
                WaferHolderMoveItem waferHolderMoveItem = (WaferHolderMoveItem)action.Parameter;
                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.INFO_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 TransporterAction))
            {
                reason = "parameter is not TransporterAction";
                return false;
            }
            TransporterAction action = (TransporterAction)parameter;
            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;
            }
            if (action.ActionMsg == TransporterMSG.Transfer)
            {
                WaferHolderMoveItem waferHolderMoveItem = (WaferHolderMoveItem)action.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;
                    }

                    if (WaferHolderManager.Instance.HasWaferHolder(waferHolderMoveItem.DestModule.ToString()))
                    {
                        reason = $"loader transporter {waferHolderMoveItem.DestModule} has wafer shuttle";
                        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";
                    }
                }

                //已经确定了Pwt的Rinse
                if (waferHolderMoveItem.DestModuleType == ModuleType.Rinse && waferHolderMoveItem.DestModule != ModuleName.Unknown)
                {
                    if (SchedulerManager.Instance.IsQdrCheckConflict && !SchedulerWaferHolderTimeManager.Instance.Contained(materialId))
                    {
                        SchedulerSequence qdrSequence = schedulerSequences[sequenceIndex + 1];
                        QdrRecipe qdrRecipe = qdrSequence.Recipe as QdrRecipe;
                        int recipeTime = qdrRecipe.CalculateRunRecipeTime();
                        int transporterTransferSeconds = SC.GetValue<int>("Transporter.TransporterTransferSeconds");
                        DateTime startTime = DateTime.Now.AddSeconds(transporterTransferSeconds).AddSeconds(recipeTime);
                        result = SchedulerModuleTimeManager.Instance.ConfirmAllMetalQdrAndDryer(schedulerSequences, materialId, sequenceIndex, true, startTime);
                        if (result)
                        {
                            LOG.WriteLog(eEvent.EV_SCHEDULER, "System", $"scheduler transporter wafer shuttle {materialId} has avaible cells after Prewet");
                        }
                        return result;
                    }
                }
            }
            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
                {
                    bool result = true;
                    if (SchedulerManager.Instance.IsQdrCheckConflict)
                    {
                        DateTime startTime = DateTime.Now;
                        bool isPwt = false;
                        if (waferHolderMoveItem.DestModuleType == ModuleType.Prewet)
                        {
                            PrewetEntity prewetEntity = Singleton<RouteManager>.Instance.GetModule<PrewetEntity>(ModuleName.Prewet1.ToString());

                            SchedulerSequence pwtSequence = schedulerSequences[sequenceIndex + 1];
                            PwtRecipe pwtRecipe = pwtSequence.Recipe as PwtRecipe;
                            int recipeTime = prewetEntity.CalculateRecipeTime(pwtRecipe);
                            int transporterTransferSeconds = SC.GetValue<int>("Transporter.TransporterTransferSeconds");
                            startTime = DateTime.Now.AddSeconds(transporterTransferSeconds).AddSeconds(recipeTime);
                            isPwt = true;
                        }
                        else if (waferHolderMoveItem.DestModuleType == ModuleType.Rinse)
                        {
                            SchedulerSequence qdrSequence = schedulerSequences[sequenceIndex + 1];
                            QdrRecipe qdrRecipe = qdrSequence.Recipe as QdrRecipe;
                            int recipeTime = qdrRecipe.CalculateRunRecipeTime();
                            int transporterTransferSeconds = SC.GetValue<int>("Transporter.TransporterTransferSeconds");
                            startTime = DateTime.Now.AddSeconds(transporterTransferSeconds).AddSeconds(recipeTime);
                            isPwt = true;
                        }
                        if (isPwt)
                        {
                            result = SchedulerModuleTimeManager.Instance.ConfirmAllMetalQdrAndDryer(schedulerSequences, materialId, sequenceIndex, true, startTime);
                            if (result)
                            {
                                LOG.WriteLog(eEvent.EV_SCHEDULER, "System", $"scheduler transporter wafer shuttle {materialId} has avaible cells after Prewet");
                            }
                            else
                            {
                                return false;
                            }
                        }
                    }
                    if (result)
                    {
                        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.INFO_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;
        }
    }
}