Kepler-Release/Venus/Venus_RT/Modules/PMs/ProcessDefine.cs

using System;
using System.Collections.Generic;
//using System.
using Venus_RT.Devices;
using Aitex.Core.RT.Log;
using Venus_Core;
using Aitex.Core.RT.SCCore;
using Aitex.Core.RT.Tolerance;
using System.Diagnostics;
using MECF.Framework.Common.DBCore;
//#pragma warning disable 0436

namespace Venus_RT.Modules.PMs
{
    class ProcessHelper
    {
        protected JetPMBase Chamber;
        private string Module;
        public RecipeHead m_RecipeHead;

        private static Dictionary<string, Func<ProcessUnitBase, RecipeStep, RState>> startHelper = new Dictionary<string, Func<ProcessUnitBase, RecipeStep, RState>>();
        private static Dictionary<string, Func<ProcessUnitBase, RecipeStep, RState>> checkerHelper = new Dictionary<string, Func<ProcessUnitBase, RecipeStep, RState>>();
        private static Dictionary<string, Action<ProcessUnitBase, RecipeStep>> endHelper = new Dictionary<string, Action<ProcessUnitBase, RecipeStep>>();
        private List<float> rfMatchC1 = new List<float>();
        private List<float> rfMatchC2 = new List<float>();
        private int rfMatchC1C2Index = 0;


        private List<float> biasRfMatchC1 = new List<float>();
        private List<float> biasRfMatchC2 = new List<float>();
        private int biasRfMatchC1C2Index = 0;

        public bool isLoop = false;
        public int loopsteps = 0;
        public int currentStepIndex = 0;

        private bool biasRFSetPointFlag = true;

        private double _scRFPowerAlarmTime;
        private double _scBiasRFPowerAlarmTime;

        private RecipeToleranceChecker _GasFlowToleranceChecker;
        private RecipeToleranceChecker _RFToleranceChecker;
        private RecipeToleranceChecker _BiasRFToleranceChecker;
        //private RecipeToleranceChecker _HeliumToleranceChecker;
        private RecipeToleranceChecker _PressureToleranceChecker;
        private RecipeToleranceChecker _HighTemperatureToleranceChecker;
        private RecipeToleranceChecker _MagnetToleranceChecker;




        private bool _isEnableMatchC1C2Offset;
        private int _matchC1C2OffsetValue;
        private bool _isEnableBiasMatchC1C2Offset;
        private int _biasMatchC1C2OffsetValue;

        private bool _isInstalledEPD;
        private Stopwatch _lastEPDStepTimeStopwatch;
        public long lastEPDStepTime;

        //private Fdc _fdc;
        private string _RecipeId;

        private Stopwatch _StableStopWach=new Stopwatch();
        public ProcessHelper(JetPMBase pm)
        {
            Chamber = pm;
            Module = pm.Module.ToString();
            Init();
            _GasFlowToleranceChecker = new RecipeToleranceChecker(Module);
            _RFToleranceChecker = new RecipeToleranceChecker(Module);
            _BiasRFToleranceChecker = new RecipeToleranceChecker(Module);
            //_HeliumToleranceChecker = new RecipeToleranceChecker(Module);
            _PressureToleranceChecker = new RecipeToleranceChecker(Module);
            _HighTemperatureToleranceChecker = new RecipeToleranceChecker(Module);
            _MagnetToleranceChecker = new RecipeToleranceChecker(Module);
            if (Chamber.ChamberType == JetChamber.Kepler2300 || Chamber.ChamberType == JetChamber.VenusSE || Chamber.ChamberType == JetChamber.VenusDE)
            {
                _isInstalledEPD = SC.GetValue<bool>($"{Module}.EPD.IsEnabled");
            }
            if (_isInstalledEPD)
            {
                _lastEPDStepTimeStopwatch = new Stopwatch();
            }
            _StableStopWach.Reset();
        }

        private void Init()
        {
            startHelper[$"{Module}.PressureByPressureModeUnit"] = (ProcessUnitBase unit, RecipeStep step) => PressureByPressureModeUnit_Start(unit, step);
            checkerHelper[$"{Module}.PressureByPressureModeUnit"] = (ProcessUnitBase unit, RecipeStep step) => PressureByPressureModeUnit_Check(unit, step);
            endHelper[$"{Module}.PressureByPressureModeUnit"] = (ProcessUnitBase unit, RecipeStep step) => PressureByPressureModeUnit_End(unit, step);

            //startHelper     [$"{Module}.PressureByValveModeUnit"]     = (ProcessUnitBase unit, RecipeStep step) => PressureByValveModeUnit_Start(unit, step);
            //checkerHelper   [$"{Module}.PressureByValveModeUnit"]     = (ProcessUnitBase unit, RecipeStep step) => PressureByValveModeUnit_Check(unit, step);
            //endHelper       [$"{Module}.PressureByValveModeUnit"]     = (ProcessUnitBase unit, RecipeStep step) => PressureByValveModeUnit_End(unit, step);

            startHelper[$"{Module}.TCPUnit"] = (ProcessUnitBase unit, RecipeStep step) => TCPUnit_Start(unit, step);
            checkerHelper[$"{Module}.TCPUnit"] = (ProcessUnitBase unit, RecipeStep step) => TCPUnit_Check(unit, step);
            endHelper[$"{Module}.TCPUnit"] = (ProcessUnitBase unit, RecipeStep step) => TCPUnit_End(unit, step);

            startHelper[$"{Module}.BiasUnit"] = (ProcessUnitBase unit, RecipeStep step) => BiasUnit_Start(unit, step);
            checkerHelper[$"{Module}.BiasUnit"] = (ProcessUnitBase unit, RecipeStep step) => BiasUnit_Check(unit, step);
            endHelper[$"{Module}.BiasUnit"] = (ProcessUnitBase unit, RecipeStep step) => BiasUnit_End(unit, step);

            startHelper[$"{Module}.GasControlUnit"] = (ProcessUnitBase unit, RecipeStep step) => GasControlUnit_Start(unit, step);
            checkerHelper[$"{Module}.GasControlUnit"] = (ProcessUnitBase unit, RecipeStep step) => GasControlUnit_Check(unit, step);
            endHelper[$"{Module}.GasControlUnit"] = (ProcessUnitBase unit, RecipeStep step) => GasControlUnit_End(unit, step);

            startHelper[$"{Module}.VenusSEGasControlUnit"] = (ProcessUnitBase unit, RecipeStep step) => VenusSEGasControlUnit_Start(unit, step);
            checkerHelper[$"{Module}.VenusSEGasControlUnit"] = (ProcessUnitBase unit, RecipeStep step) => VenusSEGasControlUnit_Check(unit, step);
            endHelper[$"{Module}.VenusSEGasControlUnit"] = (ProcessUnitBase unit, RecipeStep step) => VenusSEGasControlUnit_End(unit, step);

            startHelper[$"{Module}.VenusDEGasControlUnit"] = (ProcessUnitBase unit, RecipeStep step) => VenusDEGasControlUnit_Start(unit, step);
            checkerHelper[$"{Module}.VenusDEGasControlUnit"] = (ProcessUnitBase unit, RecipeStep step) => VenusDEGasControlUnit_Check(unit, step);
            endHelper[$"{Module}.VenusDEGasControlUnit"] = (ProcessUnitBase unit, RecipeStep step) => VenusDEGasControlUnit_End(unit, step);

            startHelper[$"{Module}.ESCHVUnit"] = (ProcessUnitBase unit, RecipeStep step) => ESCHVUnit_Start(unit, step);
            checkerHelper[$"{Module}.ESCHVUnit"] = (ProcessUnitBase unit, RecipeStep step) => ESCHVUnit_Check(unit, step);
            endHelper[$"{Module}.ESCHVUnit"] = (ProcessUnitBase unit, RecipeStep step) => ESCHVUnit_End(unit, step);

            startHelper[$"{Module}.ProcessKitUnit"] = (ProcessUnitBase unit, RecipeStep step) => ProcessKitUnit_Start(unit, step);
            checkerHelper[$"{Module}.ProcessKitUnit"] = (ProcessUnitBase unit, RecipeStep step) => ProcessKitUnit_Check(unit, step);
            endHelper[$"{Module}.ProcessKitUnit"] = (ProcessUnitBase unit, RecipeStep step) => ProcessKitUnit_End(unit, step);

            startHelper[$"{Module}.Kepler2200GasControlUnit"] = (ProcessUnitBase unit, RecipeStep step) => Kepler2200GasControlUnit_Start(unit, step);
            checkerHelper[$"{Module}.Kepler2200GasControlUnit"] = (ProcessUnitBase unit, RecipeStep step) => Kepler2200GasControlUnit_Check(unit, step);
            endHelper[$"{Module}.Kepler2200GasControlUnit"] = (ProcessUnitBase unit, RecipeStep step) => Kepler2200GasControlUnit_End(unit, step);

            startHelper[$"{Module}.HeaterUnit"] = (ProcessUnitBase unit, RecipeStep step) => HeaterUnit_Start(unit, step);
            checkerHelper[$"{Module}.HeaterUnit"] = (ProcessUnitBase unit, RecipeStep step) => HeaterUnit_Check(unit, step);
            endHelper[$"{Module}.HeaterUnit"] = (ProcessUnitBase unit, RecipeStep step) => HeaterUnit_End(unit, step);

            startHelper[$"{Module}.RFBoxUnit"] = (ProcessUnitBase unit, RecipeStep step) => RFBoxUnit_Start(unit, step);
            checkerHelper[$"{Module}.RFBoxUnit"] = (ProcessUnitBase unit, RecipeStep step) => RFBoxUnit_Check(unit, step);
            endHelper[$"{Module}.RFBoxUnit"] = (ProcessUnitBase unit, RecipeStep step) => RFBoxUnit_End(unit, step);

            startHelper[$"{Module}.MagnetUnit"] = (ProcessUnitBase unit, RecipeStep step) => MagnetUnit_Start(unit, step);
            checkerHelper[$"{Module}.MagnetUnit"] = (ProcessUnitBase unit, RecipeStep step) => MagnetUnit_Check(unit, step);
            endHelper[$"{Module}.MagnetUnit"] = (ProcessUnitBase unit, RecipeStep step) => MagnetUnit_End(unit, step);

            //_fdc = new Fdc(Module);
        }

        private RState PressureByPressureModeUnit_Start(ProcessUnitBase unit, RecipeStep step)
        {
            var ProcessUnit = unit as PressureByPressureModeUnit;
            List<ToleranceObject> toleranceObjects = new List<ToleranceObject>();
            _PressureToleranceChecker.IsStable = true;
            if (ProcessUnit.ToleranceMode != ToleranceMode.None)
            {
                toleranceObjects.Add(new ToleranceObject("Pressure", ProcessUnit.StartValue, ProcessUnit.StartValueWarningRange, ProcessUnit.StartValueAlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));

                _PressureToleranceChecker.Start(toleranceObjects, step.Type == StepType.Stable);
            }
            if (ProcessUnit.PressureUnitMode == PressureUnitMode.Pressure)
            {
                if (Chamber.SetPVPressure(ProcessUnit.StartValue))
                {
                    return RState.Running;
                }
            }
            else if (ProcessUnit.PressureUnitMode == PressureUnitMode.Valve)
            {
                if (Chamber.SetPVPostion(ProcessUnit.StartValue))
                {
                    return RState.Running;
                }
            }
            return RState.Failed;
        }

        private RState PressureByPressureModeUnit_Check(ProcessUnitBase unit, RecipeStep step)
        {
            var ProcessUnit = unit as PressureByPressureModeUnit;
            if (ProcessUnit.EnableRamp)
            {
                if (ProcessUnit.PressureUnitMode == PressureUnitMode.Pressure)
                {
                    if (Chamber.SetPVPressure(ProcessUnit.StartValue + (int)((ProcessUnit.TargetValue - ProcessUnit.StartValue) * step.RampFactor())))
                        return RState.Running;
                    else
                        return RState.Failed;
                }
                else if (ProcessUnit.PressureUnitMode == PressureUnitMode.Valve)
                {
                    if (Chamber.SetPVPostion(ProcessUnit.StartValue + (int)((ProcessUnit.TargetValue - ProcessUnit.StartValue) * step.RampFactor())))
                        return RState.Running;
                    else
                        return RState.Failed;
                }
            }

            if (ProcessUnit.PressureUnitMode == PressureUnitMode.Pressure && ProcessUnit.ToleranceMode != ToleranceMode.None)
            {
                return _PressureToleranceChecker.Monitor(Chamber.PendulumPressure);
            }
            else if (ProcessUnit.PressureUnitMode == PressureUnitMode.Valve && ProcessUnit.ToleranceMode != ToleranceMode.None)
            {
                return _PressureToleranceChecker.Monitor(Chamber.PendulumPosition);
            }


            return RState.Running;
        }

        private void PressureByPressureModeUnit_End(ProcessUnitBase unit, RecipeStep step)
        {
            var ProcessUnit = unit as PressureByPressureModeUnit;
            if (ProcessUnit.ToleranceMode != ToleranceMode.None)
            {
                _PressureToleranceChecker.End();
            }
        }

        private RState TCPUnit_Start(ProcessUnitBase unit, RecipeStep step)
        {
            _isEnableMatchC1C2Offset = SC.GetValue<bool>($"{Module}.Match.EnableC1C2StepOffset");
            _matchC1C2OffsetValue = SC.GetValue<int>($"{Module}.Match.C1C2StepOffsetValue");

            var ProcessUnit = unit as TCPUnit;

            List<ToleranceObject> toleranceObjects = new List<ToleranceObject>();
            if (ProcessUnit.ToleranceMode != ToleranceMode.None)
            {
                toleranceObjects.Add(new ToleranceObject("RF", ProcessUnit.RFPower, ProcessUnit.RFPowerWarningRange, ProcessUnit.RFPowerAlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));
                _RFToleranceChecker.Start(toleranceObjects, step.Type == StepType.Stable);
            }

            float p1;
            float p2;
            if (ProcessUnit.C1 > 0)
            {
                p1 = ProcessUnit.C1;
            }
            else
            {
                p1 = ProcessUnit.AutoC1;
            }
            if (ProcessUnit.C2 > 0)
            {
                p2 = ProcessUnit.C2;
            }
            else
            {
                p2 = ProcessUnit.AutoC2;
            }

            if (_isEnableMatchC1C2Offset = false || Math.Abs(Chamber.RFMatchC1 - p1) > _matchC1C2OffsetValue || Math.Abs(Chamber.RFMatchC2 - p2) > _matchC1C2OffsetValue)
            {
                if (!Chamber.SetMatchPosition(p1, p2))
                {
                    LOG.Write(eEvent.ERR_PROCESS, Chamber.Module, $"Step:{step.StepNo} failed duo to Source RF Match Write C1 C2 failed ");
                    return RState.Failed;
                }
            }
            

            if (ProcessUnit.RFPower > 5)
            {
                Chamber.GeneratorSetpower(ProcessUnit.RFPower);
                Chamber.GeneratorPowerOn(true);
            }
            else
            {
                Chamber.GeneratorSetpower(0);
                Chamber.GeneratorPowerOn(false);
            }

            if (ProcessUnit.MatchWorkMode == MatchWorkMode.Auto)
            {
                Chamber.SetMatchWorkMode(MatchWorkMode.Auto);
            }
            else if (ProcessUnit.MatchWorkMode == MatchWorkMode.Manual)
            {
                Chamber.SetMatchWorkMode(MatchWorkMode.Manual);
            }
            _scRFPowerAlarmTime = SC.GetValue<double>($"{Chamber.Name}.Rf.PowerAlarmTime");

            rfMatchC1.Clear();
            rfMatchC1.Clear();
            rfMatchC1C2Index = 0;

            return RState.Running;
        }

        private RState TCPUnit_Check(ProcessUnitBase unit, RecipeStep step)
        {
            var ProcessUnit = unit as TCPUnit;
            if (ProcessUnit.MaxReflectedPower > 0 && Chamber.ReflectPower > ProcessUnit.MaxReflectedPower && step.ElapsedTime() > _scRFPowerAlarmTime * 1000)
            {
                LOG.Write(eEvent.ERR_PROCESS, Chamber.Module, $"Step:{step.StepNo} failed, RF Reflect Power:{Chamber.ReflectPower} exceeds the Max Limit:{ProcessUnit.MaxReflectedPower}");
                return RState.Failed;
            }

            if (step.ElapsedTime() > m_RecipeHead.RFHoldTime * 1000)
            {
                Chamber.GeneratorSetpower(0);
                Chamber.GeneratorPowerOn(false);
                return RState.Failed;
            }

            if (step.ElapsedTime() > rfMatchC1C2Index * 1000)
            {
                rfMatchC1.Add(Chamber.RFMatchC1);
                rfMatchC2.Add(Chamber.RFMatchC2);
                rfMatchC1C2Index += 1;
            }
            if (ProcessUnit.ToleranceMode != ToleranceMode.None)
            {
                return _RFToleranceChecker.Monitor(Chamber.ForwardPower);
            }

            return RState.Running;
        }

        private void TCPUnit_End(ProcessUnitBase unit, RecipeStep step)
        {
            var ProcessUnit = unit as TCPUnit;
            if (rfMatchC1.Count >= 6)
            {
                float allValue = 0;
                for (int i = 4; i < rfMatchC1.Count; i++)
                {
                    allValue += rfMatchC1[i];
                }
                var average = allValue / (rfMatchC1.Count - 4);
                ProcessUnit.AutoC1 = (int)average;
            }
            if (rfMatchC2.Count >= 6)
            {
                float allValue = 0;
                for (int i = 4; i < rfMatchC2.Count; i++)
                {
                    allValue += rfMatchC2[i];
                }
                var average = allValue / (rfMatchC2.Count - 4);
                ProcessUnit.AutoC2 = (int)average;
            }

            rfMatchC1.Clear();
            rfMatchC2.Clear();

            if (ProcessUnit.ToleranceMode != ToleranceMode.None)
            {
                _RFToleranceChecker.End();
            }
        }

        private RState BiasUnit_Start(ProcessUnitBase unit, RecipeStep step)
        {
            _isEnableBiasMatchC1C2Offset = SC.GetValue<bool>($"{Module}.BiasMatch.EnableC1C2StepOffset");
            _biasMatchC1C2OffsetValue = SC.GetValue<int>($"{Module}.BiasMatch.C1C2StepOffsetValue");


            var ProcessUnit = unit as BiasUnit;

            float p1;
            float p2;
            if (ProcessUnit.BiasC1 > 0)
            {
                p1 = ProcessUnit.BiasC1;
            }
            else
            {
                p1 = ProcessUnit.AutoBiasC1;
            }
            if (ProcessUnit.BiasC2 > 0)
            {
                p2 = ProcessUnit.BiasC2;
            }
            else
            {
                p2 = ProcessUnit.AutoBiasC2;
            }
            if (_isEnableBiasMatchC1C2Offset == false || Math.Abs(Chamber.BiasRFMatchC1 - p1) > _biasMatchC1C2OffsetValue || Math.Abs(Chamber.BiasRFMatchC2 - p2) > _biasMatchC1C2OffsetValue)
            {
                Chamber.SetBiasMatchPosition(p1, p2);
            }

            if (ProcessUnit.BiasRFPower > 5)
            {
                Chamber.GeneratorBiasPowerOn(true);
                if ((ProcessUnit.EnableRamp == false))
                {
                    Chamber.GeneratorBiasSetpower(ProcessUnit.BiasRFPower);
                }
            }
            else
            {
                Chamber.GeneratorBiasPowerOn(false);
                Chamber.GeneratorBiasSetpower(0);
            }


            if (ProcessUnit.BiasMatchWorkMode == MatchWorkMode.Auto)
            {
                Chamber.SetBiasMatchWorkMode(MatchWorkMode.Auto);
            }
            else if (ProcessUnit.BiasMatchWorkMode == MatchWorkMode.Manual)
            {
                Chamber.SetBiasMatchWorkMode(MatchWorkMode.Manual);
            }


            if (ProcessUnit.BiasGeneratorMode == GeneratorMode.Pulsing)
            {
                Chamber.SetBiasPulseMode(true);
                Chamber.SetBiasPulseRateFreq(ProcessUnit.PulseRateFreq);
                Chamber.SetDiasPulseDutyCycle(ProcessUnit.PulseDutyCycle);
            }
            else
            {
                Chamber.SetBiasPulseMode(false);
            }
            List<ToleranceObject> toleranceObjects = new List<ToleranceObject>();
            if (ProcessUnit.ToleranceMode != ToleranceMode.None)
            {
                toleranceObjects.Add(new ToleranceObject("BiasRF", ProcessUnit.BiasRFPower, ProcessUnit.RFPowerWarningRange, ProcessUnit.RFPowerAlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));
                _BiasRFToleranceChecker.Start(toleranceObjects, step.Type == StepType.Stable);
            }
            _scBiasRFPowerAlarmTime = SC.GetValue<double>($"{Chamber.Name}.BiasRf.PowerAlarmTime");
            biasRfMatchC1.Clear();
            biasRfMatchC1.Clear();
            biasRfMatchC1C2Index = 0;
            biasRFSetPointFlag = true;
            return RState.Running;
        }

        private RState BiasUnit_Check(ProcessUnitBase unit, RecipeStep step)
        {
            //var _scPowerAlarmTime = SC.GetValue<double>($"{Chamber.Name}.BiasRf.PowerAlarmTime");

            var ProcessUnit = unit as BiasUnit;
            if (ProcessUnit.BiasMaxReflectedPower > 0 && Chamber.BiasReflectPower > ProcessUnit.BiasMaxReflectedPower && step.ElapsedTime() > _scBiasRFPowerAlarmTime * 1000)
            {
                LOG.Write(eEvent.ERR_PROCESS, Chamber.Module, $"Step:{step.StepNo} failed, Bias Reflect Power:{Chamber.BiasReflectPower} exceeds the Max Limit:{ProcessUnit.BiasMaxReflectedPower}");
                return RState.Failed;
            }

            if (step.ElapsedTime() > m_RecipeHead.BiasRFHoldTime * 1000)
            {
                Chamber.GeneratorBiasSetpower(0);
                Chamber.GeneratorBiasPowerOn(false);
                return RState.Failed;
            }
            if (step.ElapsedTime() > biasRfMatchC1C2Index * 1000)
            {
                biasRfMatchC1.Add(Chamber.BiasRFMatchC1);
                biasRfMatchC2.Add(Chamber.BiasRFMatchC2);
                biasRfMatchC1C2Index += 1;
            }
            if (ProcessUnit.ToleranceMode != ToleranceMode.None)
            {
                return _BiasRFToleranceChecker.Monitor(Chamber.BiasForwardPower);
            }
            if (ProcessUnit.EnableRamp)
            {
                //if (step.ElapsedTime() <= 500*cycleIndex)
                //{
                //    return RState.Running;
                //}
                //cycleIndex += 1;
                if (ProcessUnit.TargetMode == TargetMode.Cycle)
                {
                    if (biasRFSetPointFlag == true)
                    {
                        biasRFSetPointFlag = false;

                        Chamber.GeneratorBiasSetpower((float)((ProcessUnit.BiasRFPower + (float)((float)(ProcessUnit.TargetBiasRFPower - ProcessUnit.BiasRFPower) / ((float)(loopsteps - 1) / (float)(currentStepIndex))))));
                    }
                    //float rampFactor = (float)currentStepIndex / (float)(loopsteps-1);
                    //double rampFactor = step.RampFactor();                                 
                    //Chamber.GeneratorBiasSetpower((float)((ProcessUnit.BiasRFPower+  (ProcessUnit.TargetBiasRFPower - ProcessUnit.BiasRFPower)/(loopsteps)*currentStepIndex) +  ((double)(ProcessUnit.TargetBiasRFPower - ProcessUnit.BiasRFPower) / ((double)loopsteps)) * rampFactor));
                }
                else
                {
                    //double rampFactor = step.RampFactor();                 
                    //Chamber.GeneratorBiasSetpower((float)(ProcessUnit.BiasRFPower + (ProcessUnit.TargetBiasRFPower - ProcessUnit.BiasRFPower) * rampFactor));
                }
            }
            return RState.Running;
        }

        private void BiasUnit_End(ProcessUnitBase unit, RecipeStep step)
        {
            var ProcessUnit = unit as BiasUnit;
            //Chamber.GeneratorBiasSetpower(0);
            //Chamber.GeneratorBiasPowerOn(false);
            if (biasRfMatchC1.Count >= 6)
            {
                float allValue = 0;
                for (int i = 4; i < biasRfMatchC1.Count; i++)
                {
                    allValue += biasRfMatchC1[i];
                }
                var average = allValue / (biasRfMatchC1.Count - 4);
                ProcessUnit.AutoBiasC1 = (int)average;
            }
            if (biasRfMatchC2.Count >= 6)
            {
                float allValue = 0;
                for (int i = 4; i < biasRfMatchC2.Count; i++)
                {
                    allValue += biasRfMatchC2[i];
                }
                var average = allValue / (biasRfMatchC2.Count - 4);
                ProcessUnit.AutoBiasC2 = (int)average;
            }
            biasRfMatchC1.Clear();
            biasRfMatchC1.Clear();
            biasRfMatchC1C2Index = 0;
            //cycleIndex = 0;
            biasRFSetPointFlag = true;
            if (ProcessUnit.ToleranceMode != ToleranceMode.None)
            {
                _BiasRFToleranceChecker.End();
            }
        }

        private RState GasControlUnit_Start(ProcessUnitBase unit, RecipeStep step)
        {
            Chamber.OpenValve(ValveType.GasFinal, true);
            var ProcessUnit = unit as GasControlUnit;

            if (ProcessUnit.Gas1 >= 1)
            {
                Chamber.FlowGas(0, ProcessUnit.Gas1);
            }
            else
            {
                Chamber.FlowGas(0, 0);
            }

            if (ProcessUnit.Gas2 >= 1)
            {
                Chamber.FlowGas(1, ProcessUnit.Gas2);
            }
            else
            {
                Chamber.FlowGas(1, 0);
            }

            if (ProcessUnit.Gas3 >= 1)
            {
                Chamber.FlowGas(2, ProcessUnit.Gas3);
            }
            else
            {
                Chamber.FlowGas(2, 0);
            }

            if (ProcessUnit.Gas4 >= 1)
            {
                Chamber.FlowGas(3, ProcessUnit.Gas4);
            }
            else
            {
                Chamber.FlowGas(3, 0);
            }

            if (ProcessUnit.Gas5 >= 1)
            {
                Chamber.FlowGas(4, ProcessUnit.Gas5);
            }
            else
            {
                Chamber.FlowGas(4, 0);
            }

            if (ProcessUnit.Gas6 >= 1)
            {
                Chamber.FlowGas(5, ProcessUnit.Gas6);
            }
            else
            {
                Chamber.FlowGas(5, 0);
            }

            if (ProcessUnit.Gas7 >= 1)
            {
                Chamber.FlowGas(6, ProcessUnit.Gas7);
            }
            else
            {
                Chamber.FlowGas(6, 0);
            }

            if (ProcessUnit.Gas8 >= 1)
            {
                Chamber.FlowGas(7, ProcessUnit.Gas8);
            }
            else
            {
                Chamber.FlowGas(7, 0);
            }
            _GasFlowToleranceChecker.IsStable = true;
            if (ProcessUnit.ToleranceMode != ToleranceMode.None)
            {
                List<ToleranceObject> toleranceObjects = new List<ToleranceObject>();
                toleranceObjects.Add(new ToleranceObject("Gas1", ProcessUnit.Gas1, ProcessUnit.Gas1WarningRange, ProcessUnit.Gas1AlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));
                toleranceObjects.Add(new ToleranceObject("Gas2", ProcessUnit.Gas2, ProcessUnit.Gas2WarningRange, ProcessUnit.Gas2AlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));
                toleranceObjects.Add(new ToleranceObject("Gas3", ProcessUnit.Gas3, ProcessUnit.Gas3WarningRange, ProcessUnit.Gas3AlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));
                toleranceObjects.Add(new ToleranceObject("Gas4", ProcessUnit.Gas4, ProcessUnit.Gas4WarningRange, ProcessUnit.Gas4AlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));
                toleranceObjects.Add(new ToleranceObject("Gas5", ProcessUnit.Gas5, ProcessUnit.Gas5WarningRange, ProcessUnit.Gas5AlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));
                toleranceObjects.Add(new ToleranceObject("Gas6", ProcessUnit.Gas6, ProcessUnit.Gas6WarningRange, ProcessUnit.Gas6AlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));
                toleranceObjects.Add(new ToleranceObject("Gas7", ProcessUnit.Gas7, ProcessUnit.Gas7WarningRange, ProcessUnit.Gas7AlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));
                toleranceObjects.Add(new ToleranceObject("Gas8", ProcessUnit.Gas8, ProcessUnit.Gas8WarningRange, ProcessUnit.Gas8AlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));
                _GasFlowToleranceChecker.Start(toleranceObjects, step.Type == StepType.Stable);
            }
            return RState.Running;
        }

        private RState GasControlUnit_Check(ProcessUnitBase unit, RecipeStep step)
        {
            var ProcessUnit = unit as GasControlUnit;
            if (ProcessUnit.EnableRamp)
            {
                double rampFactor = step.RampFactor();
                Chamber.FlowGas(0, ProcessUnit.Gas1 + (ProcessUnit.Gas1Target - ProcessUnit.Gas1) * rampFactor);
                Chamber.FlowGas(1, ProcessUnit.Gas2 + (ProcessUnit.Gas2Target - ProcessUnit.Gas2) * rampFactor);
                Chamber.FlowGas(2, ProcessUnit.Gas3 + (ProcessUnit.Gas3Target - ProcessUnit.Gas3) * rampFactor);
                Chamber.FlowGas(3, ProcessUnit.Gas4 + (ProcessUnit.Gas4Target - ProcessUnit.Gas4) * rampFactor);
                Chamber.FlowGas(4, ProcessUnit.Gas5 + (ProcessUnit.Gas5Target - ProcessUnit.Gas5) * rampFactor);
                Chamber.FlowGas(5, ProcessUnit.Gas6 + (ProcessUnit.Gas6Target - ProcessUnit.Gas6) * rampFactor);
                Chamber.FlowGas(6, ProcessUnit.Gas7 + (ProcessUnit.Gas7Target - ProcessUnit.Gas7) * rampFactor);
                Chamber.FlowGas(7, ProcessUnit.Gas8 + (ProcessUnit.Gas8Target - ProcessUnit.Gas8) * rampFactor);
            }
            if (ProcessUnit.ToleranceMode != ToleranceMode.None)
            {
                return _GasFlowToleranceChecker.Monitor(Chamber.MFC1FeedBack, Chamber.MFC2FeedBack, Chamber.MFC3FeedBack, Chamber.MFC4FeedBack, Chamber.MFC5FeedBack, Chamber.MFC6FeedBack, Chamber.MFC7FeedBack, Chamber.MFC8FeedBack);
            }
            return RState.Running;
        }

        private void GasControlUnit_End(ProcessUnitBase unit, RecipeStep step)
        {
            var ProcessUnit = unit as GasControlUnit;
            if (ProcessUnit.ToleranceMode != ToleranceMode.None)
            {
                _GasFlowToleranceChecker.End();
            }
        }
        private RState Kepler2200GasControlUnit_Start(ProcessUnitBase unit, RecipeStep step)
        {
            List<ToleranceObject> toleranceObjects = new List<ToleranceObject>();
            Chamber.OpenValve(ValveType.GasFinal, true);
            var ProcessUnit = unit as Kepler2200GasControlUnit;
            if (ProcessUnit.Gas1 >= 1)
            {
                Chamber.FlowGas(0, ProcessUnit.Gas1);
            }
            else
            {
                Chamber.FlowGas(0, 0);
            }

            if (ProcessUnit.Gas2 >= 1)
            {
                Chamber.FlowGas(1, ProcessUnit.Gas2);
            }
            else
            {
                Chamber.FlowGas(1, 0);
            }

            if (ProcessUnit.Gas3 >= 1)
            {
                Chamber.FlowGas(2, ProcessUnit.Gas3);
            }
            else
            {
                Chamber.FlowGas(2, 0);
            }

            if (ProcessUnit.Gas4 >= 1)
            {
                Chamber.FlowGas(3, ProcessUnit.Gas4);
            }
            else
            {
                Chamber.FlowGas(3, 0);
            }

            if (ProcessUnit.Gas5 >= 1)
            {
                Chamber.FlowGas(4, ProcessUnit.Gas5);
            }
            else
            {
                Chamber.FlowGas(4, 0);
            }

            if (ProcessUnit.Gas6 >= 1)
            {
                Chamber.FlowGas(5, ProcessUnit.Gas6);
            }
            else
            {
                Chamber.FlowGas(5, 0);
            }

            if (ProcessUnit.Gas7 >= 1)
            {
                Chamber.FlowGas(6, ProcessUnit.Gas7);
            }
            else
            {
                Chamber.FlowGas(6, 0);
            }

            if (ProcessUnit.Gas8 >= 1)
            {
                Chamber.FlowGas(7, ProcessUnit.Gas8);
            }
            else
            {
                Chamber.FlowGas(7, 0);
            }
            _GasFlowToleranceChecker.IsStable = true;

            if (ProcessUnit.ToleranceMode != ToleranceMode.None)
            {
                toleranceObjects.Add(new ToleranceObject("Gas1", ProcessUnit.Gas1, ProcessUnit.Gas1WarningRange, ProcessUnit.Gas1AlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));
                toleranceObjects.Add(new ToleranceObject("Gas2", ProcessUnit.Gas2, ProcessUnit.Gas2WarningRange, ProcessUnit.Gas2AlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));
                toleranceObjects.Add(new ToleranceObject("Gas3", ProcessUnit.Gas3, ProcessUnit.Gas3WarningRange, ProcessUnit.Gas3AlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));
                toleranceObjects.Add(new ToleranceObject("Gas4", ProcessUnit.Gas4, ProcessUnit.Gas4WarningRange, ProcessUnit.Gas4AlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));
                toleranceObjects.Add(new ToleranceObject("Gas5", ProcessUnit.Gas5, ProcessUnit.Gas5WarningRange, ProcessUnit.Gas5AlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));
                toleranceObjects.Add(new ToleranceObject("Gas6", ProcessUnit.Gas6, ProcessUnit.Gas6WarningRange, ProcessUnit.Gas6AlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));
                toleranceObjects.Add(new ToleranceObject("Gas7", ProcessUnit.Gas7, ProcessUnit.Gas7WarningRange, ProcessUnit.Gas7AlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));
                toleranceObjects.Add(new ToleranceObject("Gas8", ProcessUnit.Gas8, ProcessUnit.Gas8WarningRange, ProcessUnit.Gas8AlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));
                _GasFlowToleranceChecker.Start(toleranceObjects, step.Type == StepType.Stable);
            }
            return RState.Running;
        }

        private RState Kepler2200GasControlUnit_Check(ProcessUnitBase unit, RecipeStep step)
        {
            var ProcessUnit = unit as Kepler2200GasControlUnit;
            if (ProcessUnit.ToleranceMode != ToleranceMode.None)
            {
                return _GasFlowToleranceChecker.Monitor(Chamber.MFC1FeedBack, Chamber.MFC2FeedBack, Chamber.MFC3FeedBack, Chamber.MFC4FeedBack, Chamber.MFC5FeedBack, Chamber.MFC6FeedBack, Chamber.MFC7FeedBack, Chamber.MFC8FeedBack);
            }
            return RState.Running;
        }

        private void Kepler2200GasControlUnit_End(ProcessUnitBase unit, RecipeStep step)
        {
            var ProcessUnit = unit as Kepler2200GasControlUnit;
            if (ProcessUnit.ToleranceMode != ToleranceMode.None)
            {
                _GasFlowToleranceChecker.End();
            }
        }
        private RState VenusSEGasControlUnit_Start(ProcessUnitBase unit, RecipeStep step)
        {
            Chamber.OpenValve(ValveType.GasFinal, true);
            var ProcessUnit = unit as VenusSEGasControlUnit;
            Chamber.FlowGas(0, ProcessUnit.Gas1);
            if (ProcessUnit.Gas1 >= 1)
            {
                Chamber.OpenValve(ValveType.PV11, true);
            }
            Chamber.FlowGas(1, ProcessUnit.Gas2);
            if (ProcessUnit.Gas2 >= 1)
            {
                Chamber.OpenValve(ValveType.PV21, true);
            }
            Chamber.FlowGas(2, ProcessUnit.Gas3);
            if (ProcessUnit.Gas3 >= 1)
            {
                Chamber.OpenValve(ValveType.PV31, true);
            }
            Chamber.FlowGas(3, ProcessUnit.Gas4);
            if (ProcessUnit.Gas4 >= 1)
            {
                Chamber.OpenValve(ValveType.PV41, true);
            }
            Chamber.FlowGas(4, ProcessUnit.Gas5);
            if (ProcessUnit.Gas5 >= 1)
            {
                Chamber.OpenValve(ValveType.PV51, true);
            }
            Chamber.FlowGas(5, ProcessUnit.Gas6);
            if (ProcessUnit.Gas6 >= 1)
            {
                Chamber.OpenValve(ValveType.PV61, true);
            }
            Chamber.FlowGas(6, ProcessUnit.Gas7);
            if (ProcessUnit.Gas7 >= 1)
            {
                Chamber.OpenValve(ValveType.PV71, true);
            }
            Chamber.FlowGas(7, ProcessUnit.Gas8);
            if (ProcessUnit.Gas8 >= 1)
            {
                Chamber.OpenValve(ValveType.PV81, true);
            }
            Chamber.FlowGas(8, ProcessUnit.Gas9);
            if (ProcessUnit.Gas9 >= 1)
            {
                Chamber.OpenValve(ValveType.PV91, true);
            }
            Chamber.FlowGas(9, ProcessUnit.Gas10);
            if (ProcessUnit.Gas10 >= 1)
            {
                Chamber.OpenValve(ValveType.PVA1, true);
            }
            Chamber.FlowGas(10, ProcessUnit.Gas11);
            if (ProcessUnit.Gas11 >= 1)
            {
                Chamber.OpenValve(ValveType.PVB1, true);
            }
            Chamber.FlowGas(11, ProcessUnit.Gas12);
            if (ProcessUnit.Gas12 >= 1)
            {
                Chamber.OpenValve(ValveType.PVC1, true);
            }
            _GasFlowToleranceChecker.IsStable = true;
            if (ProcessUnit.ToleranceMode != ToleranceMode.None)
            {
                List<ToleranceObject> toleranceObjects = new List<ToleranceObject>();

                toleranceObjects.Add(new ToleranceObject("Gas1", ProcessUnit.Gas1, ProcessUnit.Gas1WarningRange, ProcessUnit.Gas1AlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));
                toleranceObjects.Add(new ToleranceObject("Gas2", ProcessUnit.Gas2, ProcessUnit.Gas2WarningRange, ProcessUnit.Gas2AlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));
                toleranceObjects.Add(new ToleranceObject("Gas3", ProcessUnit.Gas3, ProcessUnit.Gas3WarningRange, ProcessUnit.Gas3AlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));
                toleranceObjects.Add(new ToleranceObject("Gas4", ProcessUnit.Gas4, ProcessUnit.Gas4WarningRange, ProcessUnit.Gas4AlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));
                toleranceObjects.Add(new ToleranceObject("Gas5", ProcessUnit.Gas5, ProcessUnit.Gas5WarningRange, ProcessUnit.Gas5AlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));
                toleranceObjects.Add(new ToleranceObject("Gas6", ProcessUnit.Gas6, ProcessUnit.Gas6WarningRange, ProcessUnit.Gas6AlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));
                toleranceObjects.Add(new ToleranceObject("Gas7", ProcessUnit.Gas7, ProcessUnit.Gas7WarningRange, ProcessUnit.Gas7AlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));
                toleranceObjects.Add(new ToleranceObject("Gas8", ProcessUnit.Gas8, ProcessUnit.Gas8WarningRange, ProcessUnit.Gas8AlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));
                toleranceObjects.Add(new ToleranceObject("Gas9", ProcessUnit.Gas9, ProcessUnit.Gas9WarningRange, ProcessUnit.Gas9AlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));
                toleranceObjects.Add(new ToleranceObject("Gas10", ProcessUnit.Gas10, ProcessUnit.Gas10WarningRange, ProcessUnit.Gas10AlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));
                toleranceObjects.Add(new ToleranceObject("Gas11", ProcessUnit.Gas11, ProcessUnit.Gas11WarningRange, ProcessUnit.Gas11AlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));
                toleranceObjects.Add(new ToleranceObject("Gas12", ProcessUnit.Gas12, ProcessUnit.Gas12WarningRange, ProcessUnit.Gas12AlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));

                _GasFlowToleranceChecker.Start(toleranceObjects, step.Type == StepType.Stable);
            }
            return RState.Running;
        }

        private RState VenusSEGasControlUnit_Check(ProcessUnitBase unit, RecipeStep step)
        {
            var ProcessUnit = unit as VenusSEGasControlUnit;
            if (ProcessUnit.ToleranceMode != ToleranceMode.None)
            {
                return _GasFlowToleranceChecker.Monitor(Chamber.MFC1FeedBack, Chamber.MFC2FeedBack, Chamber.MFC3FeedBack, Chamber.MFC4FeedBack, Chamber.MFC5FeedBack, Chamber.MFC6FeedBack, Chamber.MFC7FeedBack, Chamber.MFC8FeedBack, Chamber.MFC9FeedBack, Chamber.MFC10FeedBack, Chamber.MFC11FeedBack, Chamber.MFC12FeedBack);
            }
            return RState.Running;
        }

        private void VenusSEGasControlUnit_End(ProcessUnitBase unit, RecipeStep step)
        {
            Chamber.FlowGas(0, 0);
            Chamber.FlowGas(1, 0);
            Chamber.FlowGas(2, 0);
            Chamber.FlowGas(3, 0);
            Chamber.FlowGas(4, 0);
            Chamber.FlowGas(5, 0);
            Chamber.FlowGas(6, 0);
            Chamber.FlowGas(7, 0);
            Chamber.FlowGas(8, 0);
            Chamber.FlowGas(9, 0);
            Chamber.FlowGas(10, 0);
            Chamber.FlowGas(11, 0);
            Chamber.FlowGas(12, 0);
            var ProcessUnit = unit as VenusSEGasControlUnit;
            if (ProcessUnit.ToleranceMode != ToleranceMode.None)
            {
                _GasFlowToleranceChecker.End();
            }
        }
        private RState VenusDEGasControlUnit_Start(ProcessUnitBase unit, RecipeStep step)
        {
            Chamber.OpenValve(ValveType.GasFinal, true);
            var ProcessUnit = unit as VenusDEGasControlUnit;
            Chamber.FlowGas(0, ProcessUnit.Gas1);
            if (ProcessUnit.Gas1 >= 1)
            {
                Chamber.OpenValve(ValveType.PV11, true);
            }
            Chamber.FlowGas(1, ProcessUnit.Gas2);
            if (ProcessUnit.Gas2 >= 1)
            {
                Chamber.OpenValve(ValveType.PV21, true);
            }
            Chamber.FlowGas(2, ProcessUnit.Gas3);
            if (ProcessUnit.Gas3 >= 1)
            {
                Chamber.OpenValve(ValveType.PV31, true);
            }
            Chamber.FlowGas(3, ProcessUnit.Gas4);
            if (ProcessUnit.Gas4 >= 1)
            {
                Chamber.OpenValve(ValveType.PV41, true);
            }
            Chamber.FlowGas(4, ProcessUnit.Gas5);
            if (ProcessUnit.Gas5 >= 1)
            {
                Chamber.OpenValve(ValveType.PV51, true);
            }
            Chamber.FlowGas(5, ProcessUnit.Gas6);
            if (ProcessUnit.Gas6 >= 1)
            {
                Chamber.OpenValve(ValveType.PV61, true);
            }
            Chamber.FlowGas(6, ProcessUnit.Gas7);
            if (ProcessUnit.Gas7 >= 1)
            {
                Chamber.OpenValve(ValveType.PV71, true);
            }
            Chamber.FlowGas(7, ProcessUnit.Gas8);
            if (ProcessUnit.Gas8 >= 1)
            {
                Chamber.OpenValve(ValveType.PV81, true);
            }
            Chamber.FlowGas(8, ProcessUnit.Gas9);
            if (ProcessUnit.Gas9 >= 1)
            {
                Chamber.OpenValve(ValveType.PV91, true);
            }
            Chamber.FlowGas(9, ProcessUnit.Gas10);
            if (ProcessUnit.Gas10 >= 1)
            {
                Chamber.OpenValve(ValveType.PVA1, true);
            }
            Chamber.FlowGas(10, ProcessUnit.Gas11);
            if (ProcessUnit.Gas11 >= 1)
            {
                Chamber.OpenValve(ValveType.PVB1, true);
            }
            Chamber.FlowGas(11, ProcessUnit.Gas12);
            if (ProcessUnit.Gas12 >= 1)
            {
                Chamber.OpenValve(ValveType.PVC1, true);
            }
            _GasFlowToleranceChecker.IsStable = true;
            if (ProcessUnit.ToleranceMode != ToleranceMode.None)
            {
                List<ToleranceObject> toleranceObjects = new List<ToleranceObject>();

                toleranceObjects.Add(new ToleranceObject("Gas1", ProcessUnit.Gas1, ProcessUnit.Gas1WarningRange, ProcessUnit.Gas1AlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));
                toleranceObjects.Add(new ToleranceObject("Gas2", ProcessUnit.Gas2, ProcessUnit.Gas2WarningRange, ProcessUnit.Gas2AlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));
                toleranceObjects.Add(new ToleranceObject("Gas3", ProcessUnit.Gas3, ProcessUnit.Gas3WarningRange, ProcessUnit.Gas3AlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));
                toleranceObjects.Add(new ToleranceObject("Gas4", ProcessUnit.Gas4, ProcessUnit.Gas4WarningRange, ProcessUnit.Gas4AlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));
                toleranceObjects.Add(new ToleranceObject("Gas5", ProcessUnit.Gas5, ProcessUnit.Gas5WarningRange, ProcessUnit.Gas5AlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));
                toleranceObjects.Add(new ToleranceObject("Gas6", ProcessUnit.Gas6, ProcessUnit.Gas6WarningRange, ProcessUnit.Gas6AlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));
                toleranceObjects.Add(new ToleranceObject("Gas7", ProcessUnit.Gas7, ProcessUnit.Gas7WarningRange, ProcessUnit.Gas7AlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));
                toleranceObjects.Add(new ToleranceObject("Gas8", ProcessUnit.Gas8, ProcessUnit.Gas8WarningRange, ProcessUnit.Gas8AlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));
                toleranceObjects.Add(new ToleranceObject("Gas9", ProcessUnit.Gas9, ProcessUnit.Gas9WarningRange, ProcessUnit.Gas9AlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));
                toleranceObjects.Add(new ToleranceObject("Gas10", ProcessUnit.Gas10, ProcessUnit.Gas10WarningRange, ProcessUnit.Gas10AlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));
                toleranceObjects.Add(new ToleranceObject("Gas11", ProcessUnit.Gas11, ProcessUnit.Gas11WarningRange, ProcessUnit.Gas11AlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));
                toleranceObjects.Add(new ToleranceObject("Gas12", ProcessUnit.Gas12, ProcessUnit.Gas12WarningRange, ProcessUnit.Gas12AlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));

                _GasFlowToleranceChecker.Start(toleranceObjects, step.Type == StepType.Stable);
            }
            return RState.Running;
        }

        private RState VenusDEGasControlUnit_Check(ProcessUnitBase unit, RecipeStep step)
        {
            var ProcessUnit = unit as VenusDEGasControlUnit;
            if (ProcessUnit.ToleranceMode != ToleranceMode.None)
            {
                return _GasFlowToleranceChecker.Monitor(Chamber.MFC1FeedBack, Chamber.MFC2FeedBack, Chamber.MFC3FeedBack, Chamber.MFC4FeedBack, Chamber.MFC5FeedBack, Chamber.MFC6FeedBack, Chamber.MFC7FeedBack, Chamber.MFC8FeedBack, Chamber.MFC9FeedBack, Chamber.MFC10FeedBack, Chamber.MFC11FeedBack, Chamber.MFC12FeedBack);
            }
            return RState.Running;
        }

        private void VenusDEGasControlUnit_End(ProcessUnitBase unit, RecipeStep step)
        {
            Chamber.FlowGas(0, 0);
            Chamber.FlowGas(1, 0);
            Chamber.FlowGas(2, 0);
            Chamber.FlowGas(3, 0);
            Chamber.FlowGas(4, 0);
            Chamber.FlowGas(5, 0);
            Chamber.FlowGas(6, 0);
            Chamber.FlowGas(7, 0);
            Chamber.FlowGas(8, 0);
            Chamber.FlowGas(9, 0);
            Chamber.FlowGas(10, 0);
            Chamber.FlowGas(11, 0);
            Chamber.FlowGas(12, 0);
            var ProcessUnit = unit as VenusDEGasControlUnit;
            if (ProcessUnit.ToleranceMode != ToleranceMode.None)
            {
                _GasFlowToleranceChecker.End();
            }
        }

        private RState ESCHVUnit_Start(ProcessUnitBase unit, RecipeStep step)
        {

            var ProcessUnit = unit as ESCHVUnit;

            if (ProcessUnit.ESCClampValtage > 0)
            {
                Chamber.SetESCClampVoltage(ProcessUnit.ESCClampValtage);
            }
            else
            {
                Chamber.SetESCClampVoltage(0);
                Chamber.OnOffSetESCHV(false);
            }
            Chamber.SetBacksideHePressure(ProcessUnit.BacksideHelium);
            Chamber.SetBacksideHeThreshold(ProcessUnit.MinHeFlow, ProcessUnit.MaxHeFlow);
            //List<ToleranceObject> toleranceObjects = new List<ToleranceObject>();
            //if (ProcessUnit.ToleranceMode != ToleranceMode.None)
            //{
            //    toleranceObjects.Add(new ToleranceObject("ESCTemperature", ProcessUnit.ESCTemperature, ProcessUnit.ESCTemperatureWarningRange, ProcessUnit.ESCTemperatureAlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));
            //    toleranceObjects.Add(new ToleranceObject("WallTemperature", ProcessUnit.WallTemperature, ProcessUnit.WallTemperatureWarningRange, ProcessUnit.WallTemperatureAlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));

            //    _HeliumToleranceChecker.Start(toleranceObjects);
            //}
            return RState.Running;
        }
        private RState ESCHVUnit_Check(ProcessUnitBase unit, RecipeStep step)
        {
            var ProcessUnit = unit as ESCHVUnit;
            if (Chamber.BackSideHeOutOfRange && step.ElapsedTime() > ProcessUnit.CheckDelay)
            {
                LOG.Write(eEvent.ERR_PROCESS, Chamber.Module, $"Step:{step.StepNo} failed, Backside Helium out of range.");
                return RState.Failed;
            }
            //if (ProcessUnit.ToleranceMode != ToleranceMode.None)
            //{
            //    return _HeliumToleranceChecker.Monitor(Chamber.ESCTemperature,Chamber.WallTemperature);
            //}
            return RState.Running;
        }
        private void ESCHVUnit_End(ProcessUnitBase unit, RecipeStep step)
        {
            Chamber.SetBacksideHeThreshold(0, 0);
            //var ProcessUnit = unit as ESCHVUnit;
            //if (ProcessUnit.ToleranceMode != ToleranceMode.None)
            //{
            //    _HeliumToleranceChecker.End();
            //}
        }

        private RState ProcessKitUnit_Start(ProcessUnitBase unit, RecipeStep step)
        {
            var ProcessUnit = unit as ProcessKitUnit;
            if (Chamber.SetLiftPin(ProcessUnit.LiftPinPostion, out string reason))
            {
                return RState.Running;
            }
            else
            {
                LOG.Write(eEvent.ERR_PROCESS, Chamber.Module, $"Step:{step.StepNo} failed. Target Position:{ProcessUnit.LiftPinPostion}");
                return RState.Failed;
            }
        }

        private RState ProcessKitUnit_Check(ProcessUnitBase unit, RecipeStep step)
        {
            //var ProcessUnit = unit as ProcessKitUnit;
            return RState.Running;
        }

        private void ProcessKitUnit_End(ProcessUnitBase unit, RecipeStep step)
        {
        }
        private RState MagnetUnit_Start(ProcessUnitBase unit, RecipeStep step)
        {
            var ProcessUnit = unit as MagnetUnit;
            if (Chamber.MagnetSetpower(ProcessUnit.MagnetIntensity) && Chamber.SetFieldRatio(ProcessUnit.FieldRatio) && Chamber.SetWaveform(ProcessUnit.MagnetWaveform))
            {
                return RState.Running;
            }
            else
            {
                LOG.Write(eEvent.ERR_PROCESS, Chamber.Module, $"Step:{step.StepNo} failed duo to Magnet Write Intensity failed");
                return RState.Failed;
            }
        }

        private RState MagnetUnit_Check(ProcessUnitBase unit, RecipeStep step)
        {
            var ProcessMagnetUnit = unit as MagnetUnit;
            if (ProcessMagnetUnit.ToleranceMode != ToleranceMode.None)
            {
                return _MagnetToleranceChecker.Monitor(Chamber.MagnetIntensity);
            }
            return RState.Running;
        }

        private void MagnetUnit_End(ProcessUnitBase unit, RecipeStep step)
        {
            var ProcessMagnetUnit = unit as MagnetUnit;
            if (ProcessMagnetUnit.ToleranceMode != ToleranceMode.None)
            {
                _MagnetToleranceChecker.End();
            }
        }
        private RState RFBoxUnit_Start(ProcessUnitBase unit, RecipeStep step)
        {
            var ProcessUnit = unit as RFBoxUnit;
            if (Chamber.SetRFBoxC1Position(ProcessUnit.C1))
            {
                return RState.Running;
            }
            else
            {
                LOG.Write(eEvent.ERR_PROCESS, Chamber.Module, $"Step:{step.StepNo} failed duo to RFBox Write C1 failed ");
                return RState.Failed;
            }
        }

        private RState RFBoxUnit_Check(ProcessUnitBase unit, RecipeStep step)
        {
            return RState.Running;
        }

        private void RFBoxUnit_End(ProcessUnitBase unit, RecipeStep step)
        {

        }

        private RState HeaterUnit_Start(ProcessUnitBase unit, RecipeStep step)
        {
            var ProcessUnit = unit as HeaterUnit;
            var position = (HighTemperatureHeaterPosition)Enum.Parse(typeof(HighTemperatureHeaterPosition), ProcessUnit.SuspectPosition.ToString());
            if (!Chamber.HighTemperatureHeaterGotoPosition(position))
            {
                return RState.Failed;
            }
            if (ProcessUnit.HeaterTemp > 0)
            {
                Chamber.SetHighTemperatureHeaterTemperature(ProcessUnit.HeaterTemp);
            }
            if (ProcessUnit.HeaterRatio > 0)
            {
                Chamber.SetHighTemperatureHeaterRatio(ProcessUnit.HeaterRatio);
            }
            _HighTemperatureToleranceChecker.IsStable = true;
            if (ProcessUnit.ToleranceMode != ToleranceMode.None)
            {
                List<ToleranceObject> toleranceObjects = new List<ToleranceObject>();
                toleranceObjects.Add(new ToleranceObject("HighTemperatureHeater Temperature", ProcessUnit.HeaterTemp, ProcessUnit.HeaterTempWarningRange, ProcessUnit.HeaterTempAlarmRange, ProcessUnit.ToleranceDelayTime, ProcessUnit.ToleranceMode));
                _HighTemperatureToleranceChecker.Start(toleranceObjects, step.Type == StepType.Stable);
            }
            return RState.Running;
        }

        private RState HeaterUnit_Check(ProcessUnitBase unit, RecipeStep step)
        {
            var ProcessUnit = unit as HeaterUnit;
            if (ProcessUnit.ToleranceMode != ToleranceMode.None)
            {
                return _HighTemperatureToleranceChecker.Monitor(Chamber.ChamberTemperature);
            }
            if (step.ElapsedTime() >= step.Time*1000-500 && step.Type==StepType.Time)
            {
                if (ProcessUnit.SuspectPosition.ToString() != Chamber.HighTemperatureHeaterPosition.ToString())
                {
                    LOG.Write(eEvent.ERR_PROCESS, Chamber.Module, $"Step:{step.StepNo} failed duo to High Temperature Heater 在setp结束前未到达 {ProcessUnit.SuspectPosition.ToString()}");

                    return RState.Failed;
                }
            }
            return RState.Running;
        }

        private void HeaterUnit_End(ProcessUnitBase unit, RecipeStep step)
        {
            var ProcessUnit = unit as HeaterUnit;
            if (ProcessUnit.ToleranceMode != ToleranceMode.None)
            {
                _HighTemperatureToleranceChecker.End();
            }

        }
        public bool LoadMethods(ProcessUnitBase unit)
        {
            var className = $"{Module}.{unit.GetType().Name}";
            if (startHelper.ContainsKey(className) && checkerHelper.ContainsKey(className) && endHelper.ContainsKey(className))
            {

                unit.starter = startHelper[className];
                unit.checker = checkerHelper[className];
                unit.end = endHelper[className];

                return true;
            }

            return false;
        }

        //public void fdcStop()
        //{


        //    if (m_RecipeHead.Type == RecipeType.Process)
        //    {                
        //        _fdc.Stop();
        //    }
        //}
        //public void loopStep(bool isloop,int loopCount,int loopIndex)
        //{ 
        //    isLoop = isloop;
        //    loopsteps=loopCount;
        //    currentStepIndex = loopIndex;
        //}

        private RState stepStarter(RecipeStep step)
        {
            step.StartStepTimer();
            if (_isInstalledEPD)
            {
                Chamber.EPDStepStart(step.EPDConfig, step.StepNo);

                if (step.Type == StepType.EndPoint)
                {
                    _lastEPDStepTimeStopwatch.Restart();
                }
            }


            return RState.Running;
        }

        private RState stepChecker(RecipeStep step)
        {
            switch (step.Type)
            {
                case StepType.Time:
                    //_fdc.OnMonitor();
                    return step.ElapsedTime() >= step.Time * 1000 ? RState.End : RState.Running;
                case StepType.OverEtch:
                    lastEPDStepTime = _lastEPDStepTimeStopwatch.ElapsedMilliseconds * step.OverEtchPercent / 100;
                    return step.ElapsedTime() >= lastEPDStepTime ? RState.End : RState.Running;
                case StepType.EndPoint:
                    if (step.ElapsedTime() > step.MaxEndPointTime * 1000)
                    {
                        LOG.Write(eEvent.ERR_PROCESS, Chamber.Module, $"Step:{step.StepNo} timeout, did not capture endpoint signal in {step.MaxEndPointTime} seconds");
                        return RState.Failed;
                    }
                    else
                    {
                        if (Chamber.EPDCaptured)
                        {
                            if (step.ElapsedTime() < step.MinEndPointTime * 1000)
                            {
                                LOG.Write(eEvent.ERR_PROCESS, Chamber.Module, $"Step:{step.StepNo} timeout,  capture endpoint signal less than {step.MinEndPointTime} seconds");
                                return RState.Failed;
                            }
                            else
                            {
                                return RState.End;
                            }
                        }
                        else
                        {
                            return RState.Running;
                        }
                        //return Chamber.EPDCaptured ? RState.End : RState.Running;
                    }
                case StepType.Stable:
                    if (step.ElapsedTime() >= step.Time * 1000)
                    {
                        LOG.Write(eEvent.ERR_PROCESS, Chamber.Module, $"Step:{step.StepNo} timeout, did not Stable in {step.Time} seconds");

                        return RState.Failed;
                    }
                    else
                    {
                        if (_GasFlowToleranceChecker.IsStable && _PressureToleranceChecker.IsStable && _HighTemperatureToleranceChecker.IsStable&& step.ElapsedTime() >=2000)
                        {
                            //_StableStopWach
                            return RState.End;
                        }
                        else
                        {
                            //_StableStopWach.
                        }
                    }
                    return RState.Running;
            }

            return RState.Running;
        }

        private RState stepEnder(RecipeStep step)
        {
            //if (step.Type == StepType.EndPoint)
            //{
            //    Chamber.EPDStepStop();
            //}

            if (_isInstalledEPD)
            {
                Chamber.EPDStepStop();
                if (step.Type == StepType.EndPoint)
                {
                    _lastEPDStepTimeStopwatch.Stop();
                }
            }
            //if (m_RecipeHead.Type == RecipeType.Process)
            //{
            //    ProcessDataRecorder.StepEnd(_RecipeId, step.StepNo, _fdc.DataList);
            //}
            return RState.End;
        }

        public bool LoadStepFuns(RecipeStep step)
        {
            step.starter = stepStarter;
            step.checker = stepChecker;
            step.ender = stepEnder;

            //for (int i = 0; i < step.LstUnit.Count; i++)
            //{
            //    var items = (step.LstUnit[i] as ProcessUnitBase).GetFDCItems();
            //    if (items != null && items.Count > 0)
            //    {
            //        _fdc.AppendKeyValues(items);
            //    }
            //}
            return true;
        }
    }
}