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

using System;
using System.Collections.Generic;
//using System.
using Venus_RT.Devices;
using Venus_RT.Modules;
using Aitex.Core.RT.Log;
using Venus_Core;
using Aitex.Core.RT.SCCore;
using System.Reflection;
using System.Diagnostics;
//#pragma warning disable 0436

namespace Venus_RT.Modules.PMs
{

    class ProcessHelper
    {
        static protected JetPM Chamber;

        static Stopwatch sRFStopWatch = new Stopwatch();
        static Stopwatch bRFStopWatch = new Stopwatch();


        private static Dictionary<string, Func<ProcessUnitBase, RecipeStep, RState>> startHelper = new Dictionary<string, Func<ProcessUnitBase, RecipeStep, RState>>
        {
            {"PressureByPressureModeUnit",  PressureByPressureModeUnit_Start},
            {"PressureByValveModeUnit",     PressureByValveModeUnit_Start},
            {"TCPUnit",                     TCPUnit_Start},
            {"BiasUnit",                    BiasUnit_Start},
            {"GasControlUnit",              GasControlUnit_Start },
            {"ESCHVUnit",                   ESCHVUnit_Start },
            {"ProcessKitUnit",              ProcessKitUnit_Start },
        };

        private static Dictionary<string, Func<ProcessUnitBase, RecipeStep, RState>> checkerHelper = new Dictionary<string, Func<ProcessUnitBase, RecipeStep, RState>>
        {
            {"PressureByPressureModeUnit",  PressureByPressureModeUnit_Check},
            {"PressureByValveModeUnit",     PressureByValveModeUnit_Check},
            {"TCPUnit",                     TCPUnit_Check},
            {"BiasUnit",                    BiasUnit_Check},
            {"GasControlUnit",              GasControlUnit_Check},
            {"ESCHVUnit",                   ESCHVUnit_Check},
            {"ProcessKitUnit",              ProcessKitUnit_Check}

        };

        private static Dictionary<string, Action<ProcessUnitBase, RecipeStep>> endHelper = new Dictionary<string, Action<ProcessUnitBase, RecipeStep>>
        {
            {"PressureByPressureModeUnit",  PressureByPressureModeUnit_End},
            {"PressureByValveModeUnit",     PressureByValveModeUnit_End},
            {"TCPUnit",                     TCPUnit_End},
            {"BiasUnit",                    BiasUnit_End},
            {"GasControlUnit",              GasControlUnit_End},
            {"ESCHVUnit",                   ESCHVUnit_End},
            {"ProcessKitUnit",              ProcessKitUnit_End}

        };

        public ProcessHelper(JetPM pm)
        {
            Chamber = pm;
        }

        static private RState PressureByPressureModeUnit_Start(ProcessUnitBase unit, RecipeStep step)
        {
            var ProcessUnit = unit as PressureByPressureModeUnit;
            if (Chamber.SetPVPressure(ProcessUnit.StartPressure))
            {
                return RState.Running;
            }

            return RState.Failed;
        }

        static private RState PressureByPressureModeUnit_Check(ProcessUnitBase unit, RecipeStep step)
        {
            var ProcessUnit = unit as PressureByPressureModeUnit;
            if(ProcessUnit.EnableRamp)
            {
                if (Chamber.SetPVPressure(ProcessUnit.StartPressure + (int)((ProcessUnit.TargetPressure - ProcessUnit.StartPressure) * step.RampFactor())))
                    return RState.Running;
                else
                    return RState.Failed;
            }

            if(step.Type == StepType.Stable && Chamber.ChamberPressure == ProcessUnit.StartPressure)
            {
                return RState.End;
            }

            return RState.Running;
        }

        static private void PressureByPressureModeUnit_End(ProcessUnitBase unit, RecipeStep step)
        {

        }

        static private RState PressureByValveModeUnit_Start(ProcessUnitBase unit, RecipeStep step)
        {
            var ProcessUnit = unit as PressureByValveModeUnit;
            if(Chamber.SetPVPostion(ProcessUnit.StartPosition))
            {
                return RState.Running;
            }
            return RState.Failed;
        }

        static private RState PressureByValveModeUnit_Check(ProcessUnitBase unit, RecipeStep step)
        {
            var ProcessUnit = unit as PressureByValveModeUnit;
            if(ProcessUnit.EnableRamp)
            {
                if (Chamber.SetPVPostion(ProcessUnit.StartPosition + (int)((ProcessUnit.TargetPosition - ProcessUnit.StartPosition) * step.RampFactor())))
                    return RState.Running;
                else
                    return RState.Failed;
            }

            return RState.Running;
        }

        static private void PressureByValveModeUnit_End(ProcessUnitBase unit, RecipeStep step)
        {

        }

        static private RState TCPUnit_Start(ProcessUnitBase unit, RecipeStep step)
        {
            sRFStopWatch.Restart();
            var ProcessUnit = unit as TCPUnit;
            if (ProcessUnit.RFPower > 5)
            {
                Chamber.GeneratorSetpower(ProcessUnit.RFPower);
                Chamber.GeneratorPowerOn(true);
            }     
            Chamber.SetMatchPosition(ProcessUnit.TuneCapPreset, ProcessUnit.LoadCapPreset);
            return RState.Running;
        }

        static private RState TCPUnit_Check(ProcessUnitBase unit, RecipeStep step)
        {
            var _scPowerAlarmTime= SC.GetValue<double>($"{Chamber.Name}.Rf.PowerAlarmTime");
            var ProcessUnit = unit as TCPUnit;
            if(ProcessUnit.MaxReflectedPower > 0 && Chamber.ReflectPower > ProcessUnit.MaxReflectedPower && sRFStopWatch.ElapsedMilliseconds > _scPowerAlarmTime*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() > ProcessUnit.HoldTime * 1000)
            {
                Chamber.GeneratorSetpower(0);
                Chamber.GeneratorPowerOn(false);
            }

            return RState.Running;
        }

        static private void TCPUnit_End(ProcessUnitBase unit, RecipeStep step)
        {
            Chamber.GeneratorSetpower(0);
            Chamber.GeneratorPowerOn(false);
        }

        static private RState BiasUnit_Start(ProcessUnitBase unit, RecipeStep step)
        {
            bRFStopWatch.Restart();
            var ProcessUnit = unit as BiasUnit;
            if (ProcessUnit.BiasRFPower > 5)
            {
                Chamber.GeneratorBiasSetpower(ProcessUnit.BiasRFPower);
                Chamber.GeneratorBiasPowerOn(true);
            }
           
            Chamber.SetBiasMatchPosition(ProcessUnit.BiasTuneCapPreset, ProcessUnit.BiasLoadCapPreset);
            if(ProcessUnit.BiasGeneratorMode == GeneratorMode.Pulsing)
            {
                Chamber.SetBiasPulseMode(true);
                Chamber.SetBiasPulseRateFreq(ProcessUnit.PulseRateFreq);
                Chamber.SetDiasPulseDutyCycle(ProcessUnit.PulseDutyCycle);
            }
            return RState.Running;
        }

        static 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 && bRFStopWatch.ElapsedMilliseconds > _scPowerAlarmTime * 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() > ProcessUnit.BiasRFHoldTime * 1000)
            {
                Chamber.GeneratorBiasSetpower(0);
                Chamber.GeneratorBiasPowerOn(false);
            }

            return RState.Running;
        }

        static private void BiasUnit_End(ProcessUnitBase unit, RecipeStep step)
        {
            Chamber.GeneratorBiasSetpower(0);
            Chamber.GeneratorBiasPowerOn(false);
        }

        static private RState GasControlUnit_Start(ProcessUnitBase unit, RecipeStep step)
        {
            Chamber.OpenValve(ValveType.GasFinal, true);
            var ProcessUnit = unit as GasControlUnit;
            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);
            Chamber.FlowGas(5, ProcessUnit.Gas6);
            Chamber.FlowGas(6, ProcessUnit.Gas7);
            Chamber.FlowGas(7, ProcessUnit.Gas8);
            return RState.Running;
        }

        static 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);
            }
            return RState.Running;
        }

        static private void GasControlUnit_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);
        }

        static private RState ESCHVUnit_Start(ProcessUnitBase unit, RecipeStep step)
        {
            var ProcessUnit = unit as ESCHVUnit;
            Chamber.SetESCClampVoltage(ProcessUnit.ESCClampValtage);
            Chamber.SetBacksideHePressure(ProcessUnit.BacksideHelum * 1000);
            Chamber.SetBacksideHeThreshold(ProcessUnit.MinHeFlow, ProcessUnit.MaxHeFlow);
            return RState.Running;
        }

        static private RState ESCHVUnit_Check(ProcessUnitBase unit, RecipeStep step)
        {
            if(Chamber.BackSideHeOutOfRange)
            {
                LOG.Write(eEvent.ERR_PROCESS, Chamber.Module, $"Step:{step.StepNo} failed, Backside Helium out of range.");
                return RState.Failed;
            }

            return RState.Running;
        }

        static private void ESCHVUnit_End(ProcessUnitBase unit, RecipeStep step)
        {
            Chamber.SetESCClampVoltage(0);
            //Chamber.SetBacksideHePressure(0);
            Chamber.SetBacksideHeThreshold(0, 0);
        }

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

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

        static private void ProcessKitUnit_End(ProcessUnitBase unit, RecipeStep step)
        {
        }

        public static bool LoadMethods(ProcessUnitBase unit)
        {
            var className = 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;
        }

        private static RState stepStarter(RecipeStep step)
        {
            step.StartStepTimer();
            switch (step.Type)
            {
                case StepType.EndPoint:
                    Chamber.EPDStepStart(step.EPDConfigName);
                    break;
            }
            return RState.Running;
        }

        private static RState stepChecker(RecipeStep step)
        {
            switch(step.Type)
            {
                case StepType.Time:
                    return step.ElapsedTime() >= step.Time * 1000 ? RState.End : RState.Running;
                case StepType.OverEtch:
                    return step.ElapsedTime() >= (step.GetLastEPDStepTime() * step.OverEtchPercent / 100) ? 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.Timeout;
                    }
                    else
                        return Chamber.EPDCaptured ? RState.End : RState.Running;
                
            }

            return RState.Running;
        }

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

            //Chamber.GeneratorBiasPowerOn(false);
            //Chamber.GeneratorPowerOn(false);
            //Chamber.TurnPendulumValve(false);
            //Chamber.CloseValves();
            //Chamber.OpenValve(ValveType.TurboPumpPumping, true);
            //Chamber.OpenValve(ValveType.TurboPumpPurge, true);
            return RState.End;
        }

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