Virgo_D_SLN/Virgo_DRT/Modules/PMs/PostProcess.cs

using System;
using System.Collections.Generic;
using Aitex.Core.Equipment.SusceptorDefine;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.Routine;
using Aitex.Core.RT.SCCore;
using MECF.Framework.Common.DBCore;
using Virgo_DRT.Devices;

namespace Virgo_DRT.Modules.PMs
{
    class PostProcessRoutine : PMRoutineBase
    {
        private enum PostProcessSequence
        {
            DelayForTest,
            RFPowerOff,
            StopGasFlow,
            CloseAllValves,
            ClosePumpValve,
            DelayWaitValve,
            Loop,
            Pump,
            PumpDelay,
            Vent,
            VentDelay,
            EndLoop,
            ClosePurgeValve,
            SetLiftPin,
            VentEndToPrecision,
            SetLiftPinAfterVent,
            VentEndCloseVentValve,
            End,
        };

        private RecipeHead head;
        private int _purgeCycleCount;
        private int _purgeVentPressure;
        private int _purgePumpPressure;
        private int _purgeVentTimeLimit;
        private int _purgePumpTimeLimit;
        private int _purgeVentStableTime;
        private int _purgePumpStableTime;
        private int _ventTime;
        //private int _ventTimeLimit;
        private readonly RfPowerRoutine _rfPowerRoutine;
        private readonly VentRoutine _ventRoutine;

        //---------------------------------Properties------------------------------------
        // 
        public string RecipeName { get; private set; }

        public string RecipeContext { get; private set; }

        private bool PurgeActive
        {
            get
            {
                if (head != null)
                {
                    if (!string.IsNullOrEmpty(head.PurgeActive))
                    {
                        return Convert.ToBoolean(head.PurgeActive);
                    }
                }
                return true;
            }
        }

        public bool PinStateAfterVent
        {
            get
            {
                if (head != null)
                {
                    if (!string.IsNullOrEmpty(head.PinStateAfterVent))
                    {
                        return head.PinStateAfterVent == "Up" ? true : false;
                    }
                }
                return false;
            }
        }

        //--------------------------------Constructor------------------------------------
        // 
        public PostProcessRoutine(JetPM chamber, VentRoutine _vRoutine) : base(chamber)
        {
            Name = "PostProcess";
            _rfPowerRoutine = new RfPowerRoutine(_chamber, false);
            _ventRoutine = _vRoutine;
        }

        public void Terminate()
        {
        }

        public Result Start(params object[] objs)
        {
            try
            {
                Reset();
                //this.UpdateSCValue();
                
                RecipeName = (string)objs[0];
                RecipeContext = (string)objs[1];

                List<RecipeStep> recipeSteps;
                if (!Recipe.Parse(RecipeContext, out head, out recipeSteps))
                {
                    return Result.FAIL;
                }

                _purgeCycleCount = (int)SC.GetValue<double>($"{_chamber.Module}.Purge.PurgeCycleCount");
                _purgeVentPressure = (int)SC.GetValue<double>($"{_chamber.Module}.Purge.PurgeVentPressure");
                _purgePumpPressure = (int)SC.GetValue<double>($"{_chamber.Module}.Purge.PurgePumpPressure");
                _purgeVentTimeLimit = (int)SC.GetValue<double>($"{_chamber.Module}.Purge.PurgeVentTimeLimit");
                _purgePumpTimeLimit = (int)SC.GetValue<double>($"{_chamber.Module}.Purge.PurgePumpTimeLimit");
                _purgeVentStableTime = (int)SC.GetValue<double>($"{_chamber.Module}.Purge.PurgeVentStableTime");
                _purgePumpStableTime = (int)SC.GetValue<double>($"{_chamber.Module}.Purge.PurgePumpStableTime");

                _ventTime = (int)SC.GetValue<double>($"{_chamber.Module}.VentTime");
                //_ventTimeLimit = (int)SC.GetSC<double>(SCName.System_VentTimeLimit).Value;
            }
            catch (Exception ex)
            {
                LOG.Write(ex, "Post process Start has exception");
                return Result.FAIL;
            }

            Notify("开始");
            return Result.RUN;
        }

        public Result Monitor()
        {
            try
            {
                if (SC.GetValue<bool>("System.IsSimulatorMode"))
                {
                    TimeDelay((int)PostProcessSequence.DelayForTest, 10);
                }

                ExecuteRoutine((int)PostProcessSequence.RFPowerOff, _rfPowerRoutine);

                CloseAllValve((int)PostProcessSequence.CloseAllValves, 1);

                if (PurgeActive)
                {
                    StartLoop((int)PostProcessSequence.Loop, "", _purgeCycleCount, Notify, Stop);

                    CyclePump((int)PostProcessSequence.Pump, _purgePumpPressure, _purgePumpTimeLimit, true);

                    TimeDelay((int)PostProcessSequence.PumpDelay, _purgePumpStableTime);

                    CycleVent((int)PostProcessSequence.Vent, _purgeVentPressure, _purgeVentTimeLimit, true);

                    TimeDelay((int)PostProcessSequence.VentDelay, _purgeVentStableTime);

                    EndLoop((int)PostProcessSequence.EndLoop, Notify, Stop);
                }

                SetLiftPinUpDown((int)PostProcessSequence.SetLiftPin, false, 5000);

                ExecuteRoutine((int)PostProcessSequence.VentEndToPrecision, _ventRoutine);

                SetLiftPinUpDown((int)PostProcessSequence.SetLiftPinAfterVent, PinStateAfterVent, 5000);

                CloseValve((int)PostProcessSequence.VentEndCloseVentValve, valveOpenCloseTimeout);

                End((int)PostProcessSequence.End);
            }
            catch (RoutineBreakException)
            {
                return Result.RUN;
            }
            catch (RoutineFaildException)
            {
                Notify("出错");
                return Result.FAIL;
            }
            catch (Exception ex)
            {
                Stop(ex.Message);
                return Result.FAIL;
            }

            Notify("结束");
            return Result.DONE;
        }

        public void Exit()
        {
            _chamber.BuzzerBlinking(SC.GetValue<double>("System.BuzzerBlinkingTime"));
            ProcessDataRecorder.End(RecipeRunGuid.ToString(), SusceptorStatus.Processed.ToString());

            //update processing end time
            //Singleton<ProcessRecorder>.Instance.EndRecipeProcess(Singleton<PMEntity>.Instance.CurrentRunningJob.RecipeRunId, SusceptorStatus.Processed);
        }
    }
}