Virgo_D_SLN/Virgo_DRT/Modules/PMs/PreProcess.cs

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

namespace Virgo_DRT.Modules.PMs
{
    class PreProcessRoutine : PMRoutineBase
    {
        public enum Routine
        {
            SetSlitDoor,
            PinDownAndPump,

            DelayForTest,
            CheckDoor,
            CheckDryPump,
            PumpDown,
            SetRfMatchMode,
            SetElectrodeTemp,
            SetHeaterTemp,
            SetLiftPin,
            End,
        }

        //---------------------------------Fields----------------------------------------
        // 
        private readonly PumpDownRoutine           _pumpRoutine;
        private readonly TemperatureControlRoutine _TempRoutine;
        private int _checkSubstrateTempTimeout = 60;
        private double _tolerance;

        //---------------------------------Properties------------------------------------
        // 
        public string CurrentRecipeBaseName           { get; private set; }
        public string CurrentRecipeRunningName        { get; private set; }
        public string CurrentRecipeContent            { get; private set; }
        public string CurrentLotName                  { get; set; }
        public List<RecipeStep> CurrentRecipeStepList { get; set; }
        public RecipeHead CurrentRecipeHead           { get; set; }
        private bool _bPinDownExecuted = false;
        private readonly int _PumpingAndPinDownTimeout = 60 * 1000;
        private int _timeout;

        private double BasePressure
        {
            get
            {
                if (CurrentRecipeHead != null)
                {
                    if (!string.IsNullOrEmpty(CurrentRecipeHead.BasePressure))
                    {
                        double setpoint = Convert.ToDouble(CurrentRecipeHead.BasePressure);
                        if (setpoint > 0 && setpoint < 750000)
                            return setpoint;
                    }
                }
                return SC.GetValue<int>($"{Module}.Pump.PumpBasePressure");
            }
        }

        private double PumpDownLimit
        {
            get
            {
                if (CurrentRecipeHead != null)
                {
                    if (!string.IsNullOrEmpty(CurrentRecipeHead.PumpDownLimit))
                    {
                        double setpoint = Convert.ToDouble(CurrentRecipeHead.PumpDownLimit);
                        if (setpoint > 0 && setpoint < 600)
                            return setpoint;
                    }
                }
                return SC.GetValue<double>($"{Module}.Pump.PumpTimeLimit");
            }
        }

        public double SubstrateTemp
        {
            get
            {
                if (CurrentRecipeHead != null)
                {
                    if (!string.IsNullOrEmpty(CurrentRecipeHead.SubstrateTemp))
                    {
                        double setpoint = Convert.ToDouble(CurrentRecipeHead.SubstrateTemp);
                        if (setpoint > 0 && setpoint < 600)
                            return setpoint;
                    }
                }
                return 0;
            }
        }

        private int PinDownPressure
        {
            get
            {
                if (CurrentRecipeHead != null)
                {
                    if (!string.IsNullOrEmpty(CurrentRecipeHead.PinDownPressure))
                    {
                        int setpoint = Convert.ToInt32(CurrentRecipeHead.PinDownPressure);
                        if (setpoint > 0)
                            return setpoint;
                    }
                }

                return 1000;
            }
        }

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

        //--------------------------------Constructor------------------------------------
        // 
        public PreProcessRoutine(JetPM chamber, PumpDownRoutine pdr) : base(chamber)
        {
            Name = "Pre Process";
            _pumpRoutine = pdr;
        }

        public void Terminate()
        {
        }

        public Result LoadRecipe(params object[] param)
        {
            CurrentRecipeBaseName = (string)param[0];

            CurrentRecipeContent = RecipeFileManager.Instance.LoadRecipe("", CurrentRecipeBaseName, true);

            if (string.IsNullOrEmpty(CurrentRecipeContent))
            {
                EV.PostInfoLog(ModuleName.System.ToString(), $"error during read recipe file {CurrentRecipeBaseName}");
                return Result.FAIL;
            }

            if (!RecipeFileManager.Instance.CheckRecipe(ModuleName.System.ToString(), CurrentRecipeContent, out var reasons))
            {
                EV.PostAlarmLog(Module, $"recipe file content not valid {CurrentRecipeBaseName}");

                string info = "";
                foreach (var item in reasons)
                    info += item;
                EV.PostPopDialogMessage(EventLevel.Alarm, "recipe file not valid", info);
            }

            CurrentRecipeRunningName = $"{CurrentRecipeBaseName}";

            if (!Recipe.Parse(CurrentRecipeContent, out RecipeHead recipeHead, out var recipeSteps))
            {
                return Result.FAIL;
            }

            CurrentRecipeStepList = recipeSteps;
            CurrentRecipeHead = recipeHead;

            return Result.DONE;
        }

        public Result Start(params object[] param)
        {
            if (CheckSlitDoor() != Result.RUN || CheckDryPump() != Result.RUN)
            {
                return Result.FAIL;
            }

            _chamber.SetGeneratorCommunicationMode(1);  // RS232 mode

            _tolerance = SC.GetValue<double>($"System.MaxTemperatureToleranceToTarget");

            try
            {
                _timeout = SC.GetValue<int>($"{Module}.PrepareTransferTimeout");
                if (BasePressure <= 0 || BasePressure >= 760000)
                {
                    return Result.FAIL;
                }

                if (PumpDownLimit <= 0.01 || PumpDownLimit >= 600)
                {
                    return Result.FAIL;
                }

                _checkSubstrateTempTimeout = SC.GetValue<int>($"{Module}.CheckSubstrateTempTimeout");

                Reset();

                RecipeRunGuid = Guid.NewGuid();
                ProcessDataRecorder.Start(RecipeRunGuid.ToString(), CurrentRecipeRunningName.Split('\\')[1], null, CurrentRecipeRunningName.Split('\\')[0]);
                //RecipeFileManager.Instance.SaveRecipeHistory(ModuleName.System.ToString(), CurrentRecipeRunningName, CurrentRecipeContent);
            }
            catch (Exception ex)
            {
                LOG.Write(ex, "Preprocess Start has exception");
                throw ex;
            }
            Notify("开始");
            _bPinDownExecuted = false;
            return Result.RUN;
        }

        public Result Monitor()
        {
            try
            {
                CloseSlitDoor((int)Routine.SetSlitDoor, _timeout);

                CheckSubstrateTemp((int)Routine.CheckDoor, SubstrateTemp, _checkSubstrateTempTimeout, _tolerance);
                ParallellyPumpAndPinDown((int)Routine.PinDownAndPump);
                // pump down
                //ExecuteRoutine((int)Routine.PumpDown, _pumpRoutine);
                //设置RF Match Mode
                //SetRfMatchMode((int)Routine.SetRfMatchMode, string.Format(Resources.PreProcess_Monitor_SetRFMatchMode, _rfMatchModeDuringProcess==(int)Virgo_DRfMatchMode.Manual ? "Manual" : "Auto"), _rfMatchModeDuringProcess);
                //SetLiftPinUpDown((int)Routine.SetLiftPin, PumpingPinIsUp, 5000);


                End((int)Routine.End);
            }
            catch (RoutineBreakException)
            {
                return Result.RUN;
            }
            catch (RoutineFaildException)
            {
                return Result.FAIL;
            }
            catch (Exception ex)
            {
                Stop(ex.Message);
                return Result.FAIL;
            }

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

        public void Exit()
        {  }

        protected void CloseSlitDoor(int id, int timeout)
        {
            Tuple<bool, Result> ret = ExecuteAndWait(id, () =>
            {
                Notify($"设置传送门 {_chamber.Name} " + (false ? "开" : "关"));

                if (!_chamber.CheckSlitDoorClose())
                {
                    _chamber.SetSlitDoor(false, out _);
                }
                return true;
            }, () => _chamber.CheckSlitDoorClose(), timeout * 1000);

            if (ret.Item1)
            {
                if (ret.Item2 == Result.FAIL)
                {
                    throw new RoutineFaildException();
                }
                else if (ret.Item2 == Result.TIMEOUT) //timeout
                {
                    Stop($"无法关传送门 in {timeout} seconds");
                    throw new RoutineFaildException();
                }
                else
                    throw new RoutineBreakException();
            }
        }


        private void ParallellyPumpAndPinDown(int id)
        {
            bool Func()
            {
                _pumpRoutine.Start(BasePressure);
                return true;
            }

            bool? Check1()
            {
                if (!_bPinDownExecuted)
                {
                    if ((PumpingPinIsUp == false) && ((_chamber.ChamberPressure <= PinDownPressure) || (PinDownPressure <= BasePressure)))
                    {
                        _bPinDownExecuted = true;
                        Notify($"设置 lift pin {_chamber.Name} " + "降");
                        if (!_chamber.SetLiftPin(MovementPosition.Down, out string reason))
                        {
                            Stop(reason);
                            return false;
                        }
                    }
                }

                bool res1 = _chamber.CheckLiftDown();
                var result = _pumpRoutine.Monitor();

                return (res1 || PumpingPinIsUp) && (result == Result.DONE);
            }

            Tuple<bool, Result> ret = ExecuteAndWait(id, Func, Check1, _PumpingAndPinDownTimeout);

            if (ret.Item1)
            {
                if (ret.Item2 == Result.FAIL)
                {
                    throw new RoutineFaildException();
                }
                if (ret.Item2 == Result.TIMEOUT)
                {
                    Stop(!_chamber.CheckLiftDown() ? $"Set Pin Down timeout in {_PumpingAndPinDownTimeout / 1000} seconds" : $"Pumping timeout  in {_PumpingAndPinDownTimeout / 1000} seconds");
                    throw new RoutineFaildException();
                }
                throw new RoutineBreakException();
            }
        }

    }
}