2022 last update

Venus/Framework/Common/Device/Bases/RfPowerBase.cs

@@ -162,6 +162,21 @@ namespace MECF.Framework.Common.Device.Bases
              
         }
 
+        public virtual void SetPulseMode(bool on)
+        {
+            
+        }
+
+        public virtual void SetPulseRateFreq(int nFreq)
+        {
+
+        }
+
+        public virtual void SetPulseDutyCycle(int percentage)
+        {
+
+        }
+
         public virtual void Terminate()
         {
         }

Venus/Venus_Core/EventDefine.cs

@@ -28,5 +28,11 @@ namespace Aitex.Core.RT.Log{
 		WARN_DEVICE_CHILLER = 1009,
 		ERR_DEVICE_CHILLER = 1010,
 		WARN_RF = 1011,
+		ERR_ENDPOINT = 1012,
+		INFO_ENDPOINT = 1013,
+		WARN_ENDPOINT = 1014,
+		ERR_BACKSIDE_HE = 1015,
+		INFO_BACKSIDE_HE = 1016,
+		WARN_BACKSIDE_HE = 1017,
 	}
 }

Venus/Venus_Core/Recipe.cs

@@ -2,7 +2,7 @@
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.ComponentModel;
-using System.Dynamic;
+using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using System.Reflection;
@@ -131,28 +131,36 @@ namespace Venus_Core
     public class ProcessUnitBase
     {
         [JsonIgnore]
-        public Func<RState> checker;
+        public Func<ProcessUnitBase, RecipeStep, RState> checker;
         [JsonIgnore]
-        public Func<RState> starter;
+        public Func<ProcessUnitBase, RecipeStep, RState> starter;
+        [JsonIgnore]
+        public Action<ProcessUnitBase, RecipeStep> end;
         //[JsonIgnore]
         //public string Name { get; set; }
         //[JsonIgnore]
         //public ProcessModule Moudle { get; set; }
 
-        public RState Start()
+        public RState Start(RecipeStep step)
         {
             if (starter != null)
-                return starter();
+                return starter(this, step);
 
             return RState.Running;
         }
-        public RState Run()
+        public RState Run(RecipeStep step)
         {
             if (checker != null)
-                return checker();
+                return checker(this, step);
 
             return RState.Running;
         }
+
+        public void End(RecipeStep step)
+        {
+            if (end != null)
+                end(this, step);
+        }
     }
 
     public class RecipeStep:INotifyPropertyChanged
@@ -164,6 +172,11 @@ namespace Venus_Core
         //    set { m_UnitName = value; InvokePropertyChanged("UnitName"); }
         //}
 
+        [JsonIgnore]
+        public Func<RecipeStep, RState> checker;
+        [JsonIgnore]
+        public Func<RecipeStep, RState> starter;
+
         private StepType m_StepType;
         [JsonConverter(typeof(StringEnumConverter))]
         public StepType Type
@@ -220,30 +233,74 @@ namespace Venus_Core
             set { lstUnit = value; InvokePropertyChanged("LstUnit"); }
         }
 
+        private Stopwatch _stepTimer = new Stopwatch();
+
+        [JsonIgnore]
+        public long ElapsedTime
+        {
+            get { return _stepTimer.ElapsedMilliseconds; }
+        }
 
         public RState Start()
-        { 
-            //foreach(var unit in lstUnit)
-            //{
-            //    var state = unit.Start();
-            //    if (state != RState.Running)
-            //        return state;
-            //}
+        {
+            _stepTimer.Restart();
+            starter(this);
+
+            foreach (var unit in lstUnit)
+            {
+                var processUnit = unit as ProcessUnitBase;
+                if (processUnit != null)
+                {
+                    var state = processUnit.Start(this);
+                    if (state != RState.Running)
+                        return state;
+                }
+                else
+                    return RState.Failed;
+                
+            }
 
             return RState.Running;
         }
         public RState Run()
         {
-            //foreach (var unit in lstUnit)
-            //{
-            //    var state = unit.Run();
-            //    if (state != RState.Running)
-            //        return state;
-            //}
+            if (checker(this) == RState.End)
+                return RState.End;
+
+            foreach (var unit in lstUnit)
+            {
+                var processUnit = unit as ProcessUnitBase;
+                if (processUnit != null)
+                {
+                    var state = processUnit.Run(this);
+                    if (state != RState.Running)
+                        return state;
+                }
+                else
+                    return RState.Failed;
+
+            }
 
             return RState.Running;
         }
 
+        public void End()
+        {
+            foreach (var unit in lstUnit)
+            {
+                var processUnit = unit as ProcessUnitBase;
+                if (processUnit != null)
+                {
+                    processUnit.End(this);
+                }
+            }
+        }
+
+        public double RampFactor()
+        {
+            return _stepTimer.ElapsedMilliseconds / (Time * 1000.0);
+        }
+
         public void AppendUnit(ProcessUnitBase unit)
         {
             lstUnit.Append(unit);
@@ -426,6 +483,4 @@ namespace Venus_Core
             return recipeString;
         }
     }
-
-
 }

Venus/Venus_RT/Config/LogDefine.json

@@ -241,5 +241,59 @@
     "GlobalDescription_en": "RF warning: {0}",
     "Module": "PM",
     "Note": "RF warning"
+  },
+  {
+    "Id": 1012,
+    "Level": "Error",
+    "LogEnum": "ERR_ENDPOINT",
+    "GlobalDescription_zh": "EndPoint alarm: {0}",
+    "GlobalDescription_en": "EndPoint alarm: {0}",
+    "Module": "PM",
+    "Note": "EndPoint Alarm"
+  },
+  {
+    "Id": 1013,
+    "Level": "Info",
+    "LogEnum": "INFO_ENDPOINT",
+    "GlobalDescription_zh": "EndPoint log: {0}",
+    "GlobalDescription_en": "EndPoint log: {0}",
+    "Module": "PM",
+    "Note": "EndPoint log"
+  },
+  {
+    "Id": 1014,
+    "Level": "Warning",
+    "LogEnum": "WARN_ENDPOINT",
+    "GlobalDescription_zh": "EndPoint warning: {0}",
+    "GlobalDescription_en": "EndPoint warning: {0}",
+    "Module": "PM",
+    "Note": "EndPoint warning"
+  },
+  {
+    "Id": 1015,
+    "Level": "Error",
+    "LogEnum": "ERR_BACKSIDE_HE",
+    "GlobalDescription_zh": "BacksideHelium alarm: {0}",
+    "GlobalDescription_en": "BacksideHelium alarm: {0}",
+    "Module": "PM",
+    "Note": "BacksideHelium Alarm"
+  },
+  {
+    "Id": 1016,
+    "Level": "Info",
+    "LogEnum": "INFO_BACKSIDE_HE",
+    "GlobalDescription_zh": "BacksideHelium log: {0}",
+    "GlobalDescription_en": "BacksideHelium log: {0}",
+    "Module": "PM",
+    "Note": "BacksideHelium log"
+  },
+  {
+    "Id": 1017,
+    "Level": "Warning",
+    "LogEnum": "WARN_BACKSIDE_HE",
+    "GlobalDescription_zh": "BacksideHelium warning: {0}",
+    "GlobalDescription_en": "BacksideHelium warning: {0}",
+    "Module": "PM",
+    "Note": "BacksideHelium warning"
   }
 ]

Venus/Venus_RT/Devices/CometRF.cs

@@ -39,6 +39,9 @@ namespace Venus_RT.Devices
         public const int FrequencyMode = 1101;
         public const int ControlMode = 1201;
         public const int PowerSetPoint = 1206;
+        public const int TurnPulseMode = 1301;
+        public const int PulsePeriod = 1302;
+        public const int PulseDutyCycle = 1303;
         public const int RFOnTime = 1701;
         public const int ForwardPowerLimit = 1702;
         public const int ReflectedPowerLimit = 1703;
@@ -924,6 +927,36 @@ namespace Venus_RT.Devices
 
             return true;
         }
+        public override void SetPulseMode(bool on)
+        {
+            SendCmd(Mode.Write, CometRFCommand.TurnPulseMode, on ? 1 : 0);
+        }
+
+        public override void SetPulseRateFreq(int nFreq)
+        {
+            if(nFreq > 0)
+            {
+                int nPeriod = 10000000 / nFreq;
+                SendCmd(Mode.Write, CometRFCommand.PulsePeriod, nPeriod);
+            }
+            else
+            {
+                LOG.Write(eEvent.ERR_RF, Module, $"SetPulseRateFreq() parameter error: {nFreq}");
+            }
+            
+        }
+
+        public override void SetPulseDutyCycle(int percentage)
+        {
+            if(percentage >= 10 && percentage <= 90)
+            {
+                SendCmd(Mode.Write, CometRFCommand.PulseDutyCycle, percentage * 10);
+            }
+            else
+            {
+                LOG.Write(eEvent.ERR_RF, Module, $"SetPulseDutyCycle() parameter error: {percentage}");
+            }
+        }
 
         private bool SendCmd(Mode mode, int command, int argument)
         {

Venus/Venus_RT/Devices/DeviceManager.cs

@@ -5,7 +5,7 @@ using Aitex.Core.Common;
 using Aitex.Core.RT.Device;
 using Aitex.Core.RT.OperationCenter;
 using Aitex.Core.RT.SCCore;
-//using Aitex.RT.Device.Custom;
+using Aitex.RT.Device.Custom;
 using MECF.Framework.Common.Equipment;
 using Venus_RT.Modules;
 using Venus_RT.Devices;
@@ -100,10 +100,10 @@ namespace Venus_RT.Instances
             BigPinWaferSize = MapWaferSize(SC.GetValue<int>($"System.BigWafer"));
 
 
-            //if (SC.GetValue<bool>($"{mod}.EPD.IsEnabled") && SC.GetValue<bool>("System.SetUp.EPDInstalled"))
-            //{
-            //    AddCustomModuleDevice(new EPDDevice(mod.ToString(), "EPD"));
-            //}
+            if (SC.GetValue<bool>($"{mod}.EPD.IsEnabled") && SC.GetValue<bool>("System.SetUp.EPDInstalled"))
+            {
+                AddCustomModuleDevice(new EPDDevice(mod.ToString(), "EPD"));
+            }
         }
 
         private WaferSize MapWaferSize(int value)

Venus/Venus_RT/Devices/JetPM.cs

@@ -1,14 +1,15 @@
-using System;
+using Aitex.Core.Common.DeviceData;
 using Aitex.Core.RT.Device;
 using Aitex.Core.RT.Device.Unit;
 using Aitex.Core.RT.Event;
-using Aitex.Core.Common.DeviceData;
 using Aitex.Core.RT.SCCore;
+using Aitex.RT.Device.Custom;
 using MECF.Framework.Common.Device.Bases;
 using MECF.Framework.Common.Equipment;
 using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.PMs;
-using Venus_RT.Devices.IODevices;
+using System;
 using Venus_Core;
+using Venus_RT.Devices.IODevices;
 namespace Venus_RT.Devices
 {
     enum ValveType
@@ -110,7 +111,7 @@ namespace Venus_RT.Devices
 
         private readonly IoGasStick[] _gasLines;
         private readonly IoGasStick _gasLineN2;
-        private readonly IoGasStick _gasLineHe;
+        private readonly IoBacksideHe _backsideHe;
 
         // 盖子的状态
         public bool IsLidClosed => _Lid.OFFFeedback;
@@ -162,6 +163,11 @@ namespace Venus_RT.Devices
         public bool LoadlockArmRetract => _LoadLockArm.OFFSetPoint;
         public bool LoadlockArmExtend => _LoadLockArm.ONSetPoint;
 
+        public float ReflectPower => _Generator.ReflectPower;
+        public float BiasReflectPower => _GeneratorBias.ReflectPower;
+
+        public bool BackSideHeOutOfRange => _backsideHe.OutOfRange;
+
         public new ModuleName Module { get; }
 
         public MovementPosition LiftPinPosition
@@ -293,7 +299,7 @@ namespace Venus_RT.Devices
             }
 
             _gasLineN2 = DEVICE.GetDevice<IoGasStick>($"{Module}.GasStickN2");
-            _gasLineHe = DEVICE.GetDevice<IoGasStick>($"{Module}.GasStickHe");
+            _backsideHe = DEVICE.GetDevice<IoBacksideHe>($"{Module}.BacksideHelium");
 
             _MainPump = DEVICE.GetDevice<PumpBase>($"{Module}.{VenusDevice.MainPump}");
 
@@ -680,5 +686,112 @@ namespace Venus_RT.Devices
             _GeneratorBias.SetMatchPosition(c1, c2, out reason);
             return true;
         }
+
+        public bool SetBiasPulseMode(bool on)
+        {
+            if (_GeneratorBias == null) return false;
+            _GeneratorBias.SetPulseMode(on);
+            return true;
+        }
+        public bool SetBiasPulseRateFreq(int nFreq)
+        {
+            if (_GeneratorBias == null) return false;
+            _GeneratorBias.SetPulseRateFreq(nFreq);
+            return true;
+        }
+
+        public bool SetDiasPulseDutyCycle(int percentage)
+        {
+            if (_GeneratorBias == null) return false;
+            _GeneratorBias.SetPulseDutyCycle(percentage);
+            return true;
+        }
+
+        public bool SetESCClampVoltage(int nVoltage)
+        {
+            if (_ESCHV == null) return false;
+
+            return _ESCHV.SetOutputVoltage(nVoltage);
+        }
+
+
+
+        #region EndPoint
+
+        public bool CheckEndPoint()
+        {
+            EPDDevice epd = DEVICE.GetDevice<EPDDevice>($"{Module}.EPD");
+
+            if (epd == null)
+                return false;
+
+            return epd.IsEnd;
+        }
+
+
+        public void StartEndPoint(string config, int index)
+        {
+            EPDDevice epd = DEVICE.GetDevice<EPDDevice>($"{Module}.EPD");
+
+            if (epd == null)
+                return;
+
+            epd.StepStart(config, index);
+
+        }
+
+        public void StopEndPoint()
+        {
+            EPDDevice epd = DEVICE.GetDevice<EPDDevice>($"{Module}.EPD");
+
+            if (epd == null)
+                return;
+
+            epd.StepStop();
+
+        }
+
+        public void EndPointRecipeStop()
+        {
+            EPDDevice epd = DEVICE.GetDevice<EPDDevice>($"{Module}.EPD");
+
+            if (epd == null)
+                return;
+
+            epd.RecipeStop();
+
+        }
+
+        public void EndPointRecipeStart(string recipeName)
+        {
+            EPDDevice epd = DEVICE.GetDevice<EPDDevice>($"{Module}.EPD");
+
+            if (epd == null)
+                return;
+
+            epd.RecipeStart(recipeName);
+
+        }
+
+
+        #endregion
+
+        public void SetBacksideHeFlow(double flow)
+        {
+            if (_backsideHe == null) return ;
+            _backsideHe.Flow(flow);
+        }
+
+        public bool SetBacksideHePressure(int mTorr)
+        {
+            if (_backsideHe == null) return false;
+            return _backsideHe.SetBacksideHelium(mTorr);
+        }
+
+        public bool SetBacksideHeThreshold(int nMin, int nMax)
+        {
+            if (_backsideHe == null) return false;
+            return _backsideHe.SetFlowThreshold(nMin, nMax);
+        }
     }
 }

Venus/Venus_RT/Modules/PMs/PMProcessRoutine.cs

@@ -35,6 +35,10 @@ namespace Venus_RT.Modules.PMs
         private double _tolerance;
         private double _OffsetTemp = 0.0f;
 
+        private bool _bLoopMode = false;
+        private int _loopStartStep = 0;
+        private int _loopCounter = 0;
+
         private double ChillerTemp
         {
             get
@@ -132,6 +136,10 @@ namespace Venus_RT.Modules.PMs
                     break;
             }
 
+            _bLoopMode = false;
+            _loopStartStep = 0;
+            _loopCounter = 0;
+
             _tolerance = SC.GetValue<double>($"System.MaxTemperatureToleranceToTarget");
             _OffsetTemp = SC.GetValue<double>($"{Module}.Chiller.ChillerTemperatureOffset");
             return Runner.Start(Module, Name);
@@ -180,7 +188,6 @@ namespace Venus_RT.Modules.PMs
         private bool PrepareTemp()
         {
             return SetCoolantTemp(ChillerTemp, _OffsetTemp);
-            //return true;
         }
 
         private bool IsTempReady()
@@ -188,6 +195,25 @@ namespace Venus_RT.Modules.PMs
             return CheckCoolantTemp(ChillerTemp, _tolerance);
         }
 
+        private RState StartNewStep()
+        {
+            var state = _currentRecipe.Steps[_currentStep].Start();
+            if (state != RState.Running)
+                return state;
+
+            if (_currentRecipe.Steps[_currentStep].CycleStart)
+            {
+                if (!_bLoopMode)
+                {
+                    _bLoopMode = true;
+                    _loopStartStep = _currentStep;
+                    _loopCounter = _currentRecipe.Steps[_currentStep].CycleNumber;
+                }
+            }
+
+            return RState.Running;
+        }
+
         private bool StartNewRecipe()
         {
             if(_qeRecipes.Count > 0)
@@ -195,9 +221,9 @@ namespace Venus_RT.Modules.PMs
                 _currentStep = 0;
                 _currentRecipe = _qeRecipes.Dequeue();
                 CurrentRunningRecipe = _currentRecipe.Header.Name;
-                _currentRecipe.Steps[_currentStep].Start();
+
                 Notify($"Recipe:{CurrentRunningRecipe} start");
-                return true;
+                return StartNewStep() == RState.Running;
             }
             
             return false;
@@ -213,10 +239,26 @@ namespace Venus_RT.Modules.PMs
             }
             else if(result == RState.End)
             {
+                _currentRecipe.Steps[_currentStep].End();
+                if(_currentRecipe.Steps[_currentStep].CycleEnd)
+                {
+                    if(_loopCounter > 0)
+                    {
+                        _loopCounter--;
+                        _currentStep = _loopStartStep;
+                        return StartNewStep() != RState.Running;
+                    }
+                    else
+                    {
+                        _bLoopMode = false;
+                        _loopStartStep = 0;
+                    }
+                }
+
                 if (_currentStep < _currentRecipe.Steps.Count - 1)
                 {
                     _currentStep++;
-                    _currentRecipe.Steps[_currentStep].Start();
+                    return StartNewStep() != RState.Running;
                 }
                 else
                 {

Venus/Venus_RT/Modules/PMs/ProcessDefine.cs

@@ -37,6 +37,18 @@ namespace Venus_RT.Modules.PMs
 
         };
 
+        private Dictionary<string, Action<ProcessUnitBase, RecipeStep>> endHelper = new Dictionary<string, Action<ProcessUnitBase, RecipeStep>>
+        {
+            {"PressureUnitByPressureMode",  PressureUnitByPressureMode_End},
+            {"PressureUnitByValveMode",     PressureUnitByValveMode_End},
+            {"TCPUnit",                     TCPUnit_End},
+            {"BiasUnit",                    BiasUnit_End},
+            {"GasControlUnit",              GasControlUnit_End},
+            {"ESCHVUnit",                   ESCHVUnit_End},
+            {"ProcessKitUnit",              ProcessKitUnit_End}
+
+        };
+
         public ProcessHelper(JetPM pm)
         {
             Chamber = pm;
@@ -44,7 +56,7 @@ namespace Venus_RT.Modules.PMs
 
         static private RState PressureUnitByPressureMode_Start(ProcessUnitBase unit, RecipeStep step)
         {
-            var ProcessUnit = unit as PressureUnitByPressureMode;
+            var ProcessUnit = unit as PressureByPressureModeUnit;
             if (Chamber.SetPVPressure(ProcessUnit.StartPressure))
             {
                 return RState.Running;
@@ -55,7 +67,7 @@ namespace Venus_RT.Modules.PMs
 
         static private RState PressureUnitByPressureMode_Check(ProcessUnitBase unit, RecipeStep step)
         {
-            var ProcessUnit = unit as PressureUnitByPressureMode;
+            var ProcessUnit = unit as PressureByPressureModeUnit;
             if(ProcessUnit.EnableRamp)
             {
                 if (Chamber.SetPVPressure(ProcessUnit.StartPressure + (int)((ProcessUnit.TargetPressure - ProcessUnit.StartPressure) * step.RampFactor())))
@@ -72,9 +84,14 @@ namespace Venus_RT.Modules.PMs
             return RState.Running;
         }
 
+        static private void PressureUnitByPressureMode_End(ProcessUnitBase unit, RecipeStep step)
+        {
+
+        }
+
         static private RState PressureUnitByValveMode_Start(ProcessUnitBase unit, RecipeStep step)
         {
-            var ProcessUnit = unit as PressureUnitByValveMode;
+            var ProcessUnit = unit as PressureByValveModeUnit;
             if(Chamber.SetPVPostion(ProcessUnit.StartPosition))
             {
                 return RState.Running;
@@ -85,7 +102,7 @@ namespace Venus_RT.Modules.PMs
 
         static private RState PressureUnitByValveMode_Check(ProcessUnitBase unit, RecipeStep step)
         {
-            var ProcessUnit = unit as PressureUnitByValveMode;
+            var ProcessUnit = unit as PressureByValveModeUnit;
             if(ProcessUnit.EnableRamp)
             {
                 if (Chamber.SetPVPostion(ProcessUnit.StartPosition + (int)((ProcessUnit.TargetPosition - ProcessUnit.StartPosition) * step.RampFactor())))
@@ -97,54 +114,151 @@ namespace Venus_RT.Modules.PMs
             return RState.Running;
         }
 
+        static private void PressureUnitByValveMode_End(ProcessUnitBase unit, RecipeStep step)
+        {
+
+        }
+
         static private RState TCPUnit_Start(ProcessUnitBase unit, RecipeStep step)
         {
             var ProcessUnit = unit as TCPUnit;
+            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 ProcessUnit = unit as TCPUnit;
+            if(ProcessUnit.MaxReflectedPower > 0 && Chamber.ReflectPower > 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)
         {
             var ProcessUnit = unit as BiasUnit;
+            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 ProcessUnit = unit as BiasUnit;
+            if (ProcessUnit.BiasMaxReflectedPower > 0 && Chamber.BiasReflectPower > 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)
         {
             var ProcessUnit = unit as GasControlUnit;
+            Chamber.FlowGas(0, ProcessUnit.Gas1);
+            Chamber.FlowGas(1, ProcessUnit.Gas2);
+            Chamber.FlowGas(2, ProcessUnit.Gas3);
+            Chamber.FlowGas(3, ProcessUnit.Gas4);
+            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)
         {
-            var ProcessUnit = unit as ESCHVUnit;
+            if(Chamber.BackSideHeOutOfRange)
+            {
+                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;
@@ -157,6 +271,10 @@ namespace Venus_RT.Modules.PMs
             return RState.Running;
         }
 
+        static private void ProcessKitUnit_End(ProcessUnitBase unit, RecipeStep step)
+        {
+        }
+
         public bool LoadMethods(ProcessUnitBase unit)
         {
             var className = unit.GetType().Name;
@@ -164,12 +282,71 @@ namespace Venus_RT.Modules.PMs
             {
                 unit.starter = startHelper[className];
                 unit.checker = checkerHelper[className];
+                unit.end = endHelper[className];
 
                 return true;
             }
 
             return false;
         }
+
+        private static RState stepStarter(RecipeStep step)
+        {
+            return RState.Running;
+        }
+
+        private static RState stepChecker(RecipeStep step)
+        {
+            switch(step.Type)
+            {
+                case StepType.Time:
+                    return step.ElapsedTime > step.Time ? RState.End : RState.Running;
+                case StepType.EndPoint:
+                    return Chamber.CheckEndPoint() ? RState.End : RState.Running;
+            }
+
+            return RState.Running;
+        }
+
+        public bool LoadStepFuns(RecipeStep step)
+        {
+            step.starter = stepStarter;
+            step.checker = stepChecker;
+            return true;
+        }
+
+        #region EndPoint
+
+        public static bool CheckEndPoint()
+        {
+            return Chamber.CheckEndPoint();
+        }
+
+
+        public static void StartEndPoint(string config, int index)
+        {
+            Chamber.StartEndPoint(config, index);
+        }
+
+        public static void StopEndPoint()
+        {
+            Chamber.StopEndPoint();
+        }
+
+        public static void EndPointRecipeStop()
+        {
+            Chamber.EndPointRecipeStop();
+
+        }
+
+        public static void EndPointRecipeStart(string recipeName)
+        {
+            Chamber.EndPointRecipeStart(recipeName);
+
+        }
+
+
+        #endregion
     }
 
     public class test

Venus/Venus_RT/Modules/PMs/ProcessUnitDefine.cs

@@ -1,121 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Venus_Core
-{
-    /// <summary>
-    /// 设计概述：
-    /// 本设计主要目的，为了满足复杂的刻蚀工艺需求(各个工艺参数之间相互关联)， 和应对未来不断新增的工艺需求（新的设备、
-    ///     新的工艺、新的材料等等）， 同时又能对现存的Recipe保持最大的兼容
-    /// 
-    /// 1. 将Process 的每道工艺分解为1个至多个逻辑工艺单元， 每个逻辑工艺单元通过 Class Name 和RT的工艺算法绑定， 
-    ///     同时也和 GUI Recipe Editor 的页面布局绑定。
-    ///     
-    /// 2. 一个逻辑单元功能调试好， 并且有在客户端使用后， 此逻辑单元想关联的 RT Process 代码和GUI 界面代码， 
-    ///     不允许再修改， 只能增加新的Class 来实现新的工艺需求
-    ///     
-    /// 3. 通过配置文件里面定义 ProcessUnit Class Name列表， 来定义当前机台支持的工艺功能， 也就是说如果Recipe文件里面保函了
-    ///     配置文件里面没有列出的工艺单元， 表明本机台不支持此Recipe， 并报警提示用户
-    /// </summary>
- 
-
-    public partial class PressureUnitByPressureMode : ProcessUnitBase
-    {
-        public string UnitName { get; set; } = "PressureUnitByPressureMode";
-        public bool EnableRamp { get; set; }
-        public int StartPressure { get; set; }
-        public int TargetPressure { get; set; }
-        public int ValvePositionPreset { get; set; }
-        public int HoldTime { get; set; }
-    }
-
-    public class PressureUnitByValveMode : ProcessUnitBase
-    {
-        public string UnitName { get; set; } = "PressureUnitByValveMode";
-
-        public bool EnableRamp { get; set; }
-        public int StartPosition { get; set; }
-        public int TargetPosition { get; set; }
-        public int HoldTime { get; set; }
-
-    }
-
-    public class TCPUnit : ProcessUnitBase
-    {
-        public string UnitName { get; set; } = "TCPUnit";
-
-        public bool EnableRamp { get; set; }
-        public int RFPower { get; set; }
-        public int StartPower { get; set; }
-        public int TargetPower { get; set; }
-        public int HoldTime { get; set; }
-        public int TuneCapPreset { get; set; }
-        public int LoadCapPreset { get; set; }
-        public int MaxReflectedPower { get; set; }
-    }
-
-
-    public class BiasUnit : ProcessUnitBase
-    {
-        public string UnitName { get; set; } = "BiasUnit";
-
-        public int BiasRFPower { get; set; }
-        public bool EnableRamp { get; set; }
-        public int StartBiasRFPower { get; set; }
-        public int TargetBiasRFPower { get; set; }
-        public int BiasRFHoldTime { get; set; }
-        public int BiasTuneCapPreset { get; set; }
-        public int BiasLoadCapPreset { get; set; }
-        public int BiasMaxReflectedPower { get; set; }
-        public GeneratorMode BiasGeneratorMode { get; set; }
-        public int PulseRateFreq { get; set; }
-        public int PulseDutyCycle { get; set; }
-
-    }
-
-    public class GasControlUnit : ProcessUnitBase
-    {
-        public string UnitName { get; set; } = "GasControlUnit";
-
-        public bool EnableRamp { get; set; }
-        public int Gas1 { get; set; }
-        public int Gas1Target { get; set; }
-        public int Gas2 { get; set; }
-        public int Gas2Target { get; set; }
-        public int Gas3 { get; set; }
-        public int Gas3Target { get; set; }
-        public int Gas4 { get; set; }
-        public int Gas4Target { get; set; }
-        public int Gas5 { get; set; }
-        public int Gas5Target { get; set; }
-        public int Gas6 { get; set; }
-        public int Gas6Target { get; set; }
-        public int Gas7 { get; set; }
-        public int Gas7Target { get; set; }
-        public int Gas8 { get; set; }
-        public int Gas8Target { get; set; }
-        public int FlowRatie { get; set; }
-    }
-
-    public class ESCHVUnit : ProcessUnitBase
-    {
-        public string UnitName { get; set; } = "ESCHVUnit";
-
-        public int BacksideHelum { get; set; }
-        public int MaxHeFlow { get; set; }
-        public int MinHeFlow { get; set; }
-        public int ESCClampValtage { get; set; }
-        public int Temperature { get; set; }
-    }
-
-    public class ProcessKitUnit : ProcessUnitBase
-    {
-        public string UnitName { get; set; } = "ProcessKitUnit";
-
-        public MovementPosition LiftPinPostion { get; set; }
-        public MovementPosition WeprBasrPinPosition { get; set; }
-    }
-}

Venus/Venus_RT/Venus_RT.csproj

@@ -69,6 +69,8 @@
     <Reference Include="System" />
     <Reference Include="System.Configuration" />
     <Reference Include="System.Data" />
+    <Reference Include="System.Runtime.Serialization" />
+    <Reference Include="System.ServiceModel" />
     <Reference Include="System.Text.Json, Version=4.0.1.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\ThirdParty\System.Text.Json.dll</HintPath>
@@ -103,8 +105,16 @@
     <Compile Include="Devices\DataDefine.cs" />
     <Compile Include="Devices\DeviceManager.cs" />
     <Compile Include="Devices\EdwardsPump.cs" />
+    <Compile Include="Devices\EPD\Datas\DataItemDefine.cs" />
+    <Compile Include="Devices\EPD\Datas\EPDConfig.cs" />
+    <Compile Include="Devices\EPD\EPDDevice.cs" />
+    <Compile Include="Devices\EPD\Interface\EPDClient.cs" />
+    <Compile Include="Devices\EPD\Interface\IEPDCallback.cs" />
+    <Compile Include="Devices\EPD\Interface\IEPDCallbackService.cs" />
+    <Compile Include="Devices\EPD\Interface\IEPDService.cs" />
     <Compile Include="Devices\ESC5HighVoltage.cs" />
     <Compile Include="Devices\FinsPlc.cs" />
+    <Compile Include="Devices\IODevices\IoBacksideHe.cs" />
     <Compile Include="Devices\IODevices\IoCylinder.cs" />
     <Compile Include="Devices\IODevices\IoGasStick.cs" />
     <Compile Include="Devices\IODevices\IoHeartbeat.cs" />
@@ -150,7 +160,7 @@
     <Compile Include="Modules\PMs\PMProcessRoutine.cs" />
     <Compile Include="Modules\PMs\PMPurgeRoutine.cs" />
     <Compile Include="Modules\PMs\PMRoutineBase.cs" />
-    <Compile Include="Modules\PMs\ProcessUnitDefine.cs" />
+    <Compile Include="Modules\PMs\ProcessDefine.cs" />
     <Compile Include="Modules\PMs\PumpDownRoutine.cs" />
     <Compile Include="Modules\PMs\RFPowerSwitchRoutine.cs" />
     <Compile Include="Modules\PMs\StartDryPumpRoutine.cs" />