add VPWMain HomeRoutine

PunkHPX8_Core/RtState.cs

@@ -77,85 +77,6 @@ namespace PunkHPX8_Core
         RobotCycleing,
         ErrorInitingAL,
     }
-    public enum PUFSTATE
-    {
-        Unknown,            // 0
-        Homing,       // 1
-        Idle,               // 2
-        Error,
-        Init,
-        SwitchOning,
-        SwitchOffing,
-        Calibrating,
-        Picking,
-        Placing,
-        Positioning,
-        GotoRobotPositionForPlace,
-        GotoRobotPositionForPick,
-        WaitForRobotPlacing,
-        WaitForRobotPlace,
-        WaitForSwaping,
-        WaitForSwap,
-        Swaping,
-        AferSwapParkStation,
-        WaitForRobotPicking,
-        WaitForRobotPick,
-        BackToPackStationing,
-        Retrying,
-        ConfirmCompleting,
-        Fliping
-    }
-    public enum LOADERSTATE
-    {
-        Unknown,            // 0
-        Homing,       // 1
-        Idle,               // 2
-        Error,
-        Init,
-        Positioning,
-        SwitchOning,
-        SwitchOffing,
-        Loading,
-        Unloading,
-        InstallCRSing,
-        PrepreForPlacing,
-        WaitForUnload,
-        WaitForLoad,
-        WaitForPick,
-        Retrying,
-        ConfirmCompleting,
-        WaitForFlip
-    }
-    public enum TransporterState
-    {
-        Unknown,
-        Init,
-        Initialized,
-        Homing,
-        Idle,
-        Error,
-        ErrorGantryPositioning,
-        GantryPositioning,
-        Positioning,
-        SwitchOning,
-        SwitchOffing,
-        Parking,
-        ElevatorUping,
-        ElevatorLowing,
-        PickUping,
-        MovingTo,
-        Placing,
-        Transfering,
-        PickUpMoveToing,
-        PickUpMoveToComplete,
-        PickUpValidating,
-        PickUpValidateComplete,
-        ValidateMoveTo, 
-        ValidateMoveToComplete,
-        GantrySafeMoving,
-        Retrying,
-        ConfirmCompleting
-    }
 
     public enum SRDState
     {
@@ -185,83 +106,19 @@ namespace PunkHPX8_Core
         Unloading
     }
 
-    public enum PrewetState
-    {
-        Unknown,
-        Error,
-        Abort,
-        Init,
-        Initialized,
-        Idle,
-        Initializing,
-        PrepareToTransfering,
-        ReadyForPick,
-        KeepWeting,
-        Linmot_Scanning,
-        ManualProcessing,
-        CycleManualProcessing,
-        RunReciping,
-        Aborting,
-        PreparingToPick,
-        PreparingToPlace,
-        WaitForPick,
-        WaitForPlace,
-        RunRecipeComplete,
-        DelayKeepweting,
-        DelayKeepwetComplete
-    }
 
-    public enum DryerState
-    {
-        Unknown,
-        Disable,
-        Abort,
-        Error,
-        Init, 
-        Initialized,
-        Idle,
-        Initializing,
-        RunReciping,
-        CycleManualProcessing,
-        Retrying
-    }
-
-    public enum RinseState
+    public enum DummyState
     {
         Unknown,
         Disable,
         Error,
         Init,
-        Initialized,
-        Idle,
         Initializing,
-        CycleManualProcessing,
-        RunReciping,
-        RunRecipeComplete,
-        KeepWeting,
-        KeepWetComplete,
-        Retrying,
-        Aborting,
-        Abort,
-    }
-    public enum MetalState
-    {
-        Unknown,
-        Disable,
-        Error,
-        Init,
         Initialized,
-        Idle,
-        Initializing,
-        ShortTesting,
-        RunReciping,
-        CurrentShortTesting,
-        WaitCloseFlow,
-        WaitOpenFlow,
-        WaitForRunRecipe,
-        Abort
+        Idle
     }
-    public enum DummyState
+
+    public enum VPWMainState
     {
         Unknown,
         Disable,
@@ -269,10 +126,9 @@ namespace PunkHPX8_Core
         Init,
         Initializing,
         Initialized,
-        Idle
+        Idle,
     }
-
-    public enum ReservoirState
+    public enum VPWCellState
     {
         Unknown,
         Disable,

PunkHPX8_MainPages/Converters/LoaderStateConverter.cs

@@ -1,35 +0,0 @@
-using System;
-using System.Windows.Data;
-using System.Windows.Media;
-using PunkHPX8_Core;
-
-namespace PunkHPX8_MainPages.Converters
-{
-    internal class LoaderStateConverter : IValueConverter
-    {
-        public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
-        {
-            LOADERSTATE currentState = (LOADERSTATE)Enum.Parse(typeof(LOADERSTATE), value.ToString());
-            switch (currentState)
-            {
-                case LOADERSTATE.Init:
-                    return new SolidColorBrush(Colors.Yellow);
-
-                case LOADERSTATE.Idle:
-                    return new SolidColorBrush(Colors.WhiteSmoke);
-
-                case LOADERSTATE.Error:
-                    return new SolidColorBrush(Colors.Red);
-
-                default:
-                    return new SolidColorBrush(Colors.Lime);
-
-            }
-        }
-
-        public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
-        {
-            return null;
-        }
-    }
-}

PunkHPX8_MainPages/Converters/PUFStateConverter.cs

@@ -1,35 +0,0 @@
-using System;
-using System.Windows.Data;
-using System.Windows.Media;
-using PunkHPX8_Core;
-
-namespace PunkHPX8_MainPages.Converters
-{
-    internal class PUFStateConverter : IValueConverter
-    {
-        public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
-        {
-            PUFSTATE currentState = (PUFSTATE)Enum.Parse(typeof(PUFSTATE), value.ToString());
-            switch (currentState)
-            {
-                case PUFSTATE.Init:
-                    return new SolidColorBrush(Colors.Yellow);
-
-                case PUFSTATE.Idle:
-                    return new SolidColorBrush(Colors.WhiteSmoke);
-
-                case PUFSTATE.Error:
-                    return new SolidColorBrush(Colors.Red);
-
-                default:
-                    return new SolidColorBrush(Colors.Lime);
-
-            }
-        }
-
-        public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
-        {
-            return null;
-        }
-    }
-}

PunkHPX8_MainPages/Converters/TransporterStateConverter.cs

@@ -1,35 +0,0 @@
-using System;
-using System.Windows.Data;
-using System.Windows.Media;
-using PunkHPX8_Core;
-
-namespace PunkHPX8_MainPages.Converters
-{
-    internal class TransporterStateConverter : IValueConverter
-    {
-        public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
-        {
-            TransporterState currentState = (TransporterState)Enum.Parse(typeof(TransporterState), value.ToString());
-            switch (currentState)
-            {
-                case TransporterState.Init:
-                    return new SolidColorBrush(Colors.Yellow);
-
-                case TransporterState.Idle:
-                    return new SolidColorBrush(Colors.WhiteSmoke);
-
-                case TransporterState.Error:
-                    return new SolidColorBrush(Colors.Red);
-
-                default:
-                    return new SolidColorBrush(Colors.Lime);
-
-            }
-        }
-
-        public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
-        {
-            return null;
-        }
-    }
-}

PunkHPX8_MainPages/PunkHPX8_MainPages.csproj

@@ -114,9 +114,6 @@
     <Compile Include="Converters\BoolReverseConverter.cs" />
     <Compile Include="Converters\DisplayNameConverter.cs" />
     <Compile Include="Converters\SRDStateConverter.cs" />
-    <Compile Include="Converters\TransporterStateConverter.cs" />
-    <Compile Include="Converters\LoaderStateConverter.cs" />
-    <Compile Include="Converters\PUFStateConverter.cs" />
     <Compile Include="Converters\EFEMStateConverter.cs" />
     <Compile Include="Converters\EventItemToStringConverter.cs" />
     <Compile Include="Converters\HeaterToStringConverter.cs" />

PunkHPX8_MainPages/Views/TopView.xaml

@@ -22,9 +22,6 @@
         <converters2:EventItemToStringConverter x:Key="EventItemToStringConverter"/>
         <converters2:SystemStateConverter x:Key="SystemStateConverter"/>
         <converters2:EFEMStateConverter x:Key="EFEMStateConverter"/>
-        <converters2:PUFStateConverter x:Key="PUFStateConverter"/>
-        <converters2:LoaderStateConverter x:Key="LoaderStateConverter"/>
-        <converters2:TransporterStateConverter x:Key="TransporterStateConverter"/>
         <converters2:SRDStateConverter x:Key="SRDStateConverter"/>
         <converters2:IsOnlineToColorConverter x:Key="IsOnlineConverter"/>
 
@@ -58,23 +55,7 @@
                                      LabelColor="#396293" 
                                      Visibility="{Binding EFEMIsInstalled,Converter={StaticResource bool2VisibilityConverter}}" />
 
-            <userControls:StateTitle Title="PUF1"  Grid.Column="2"  TextBoxValue="{Binding RtDataValues[PUF1.FsmState]}"   
-                          TextBoxColor="{Binding RtDataValues[PUF1.FsmState],Converter={StaticResource PUFStateConverter}}"     
-                          LabelColor="#396293"  
-                          Visibility="{Binding PUF1IsInstalled,Converter={StaticResource bool2VisibilityConverter}}" />
-
-            <userControls:StateTitle Title="Loader1" Grid.Row="0"  Grid.Column="3"  TextBoxValue="{Binding RtDataValues[Loader1.FsmState]}"   
-              TextBoxColor="{Binding RtDataValues[Loader1.FsmState],Converter={StaticResource LoaderStateConverter}}"     
-              LabelColor="#396293"  
-              Visibility="{Binding Loader1IsInstalled,Converter={StaticResource bool2VisibilityConverter}}" />
-            <userControls:StateTitle Title="L-Trans" Grid.Row="1"  Grid.Column="0"  TextBoxValue="{Binding RtDataValues[Transporter2.FsmState]}"   
-                                     TextBoxColor="{Binding RtDataValues[Transporter2.FsmState],Converter={StaticResource TransporterStateConverter}}"    
-                                     LabelColor="#396293" 
-                                     Visibility="{Binding Transporter2IsInstalled,Converter={StaticResource bool2VisibilityConverter}}" />
-            <userControls:StateTitle Title="P-Trans" Grid.Row="1"  Grid.Column="1"  TextBoxValue="{Binding RtDataValues[Transporter1.FsmState]}"  
-                                     TextBoxColor="{Binding RtDataValues[Transporter1.FsmState],Converter={StaticResource TransporterStateConverter}}"                                
-                                     LabelColor="#396293"  
-                                     Visibility="{Binding Transporter2IsInstalled,Converter={StaticResource bool2VisibilityConverter}}" />
+
             <userControls:StateTitle Title="SRD1" Grid.Row="1"  Grid.Column="2"  TextBoxValue="{Binding RtDataValues[SRD1.FsmState]}"  
                           TextBoxColor="{Binding RtDataValues[SRD1.FsmState],Converter={StaticResource SRDStateConverter}}"                                
                           LabelColor="#396293"  

PunkHPX8_RT/Devices/AXIS/Kollmorgen/KollmorgenStopPositionRoutine.cs

@@ -18,8 +18,8 @@ namespace PunkHPX8_RT.Devices.AXIS.Kollmorgen
             WriteTargePosition,
             NoneModeOfOperation,
             QuickStop,
-            Control6,
-            Control7,
+            ControlOffControlWord,
+            ControlOnControlWord,
             EnableOperation,
             End
         }
@@ -57,11 +57,9 @@ namespace PunkHPX8_RT.Devices.AXIS.Kollmorgen
                 .Run(StopPositionStep.WriteTargePosition, () => { return WriteTargetPosition(); }, NullFun, 100)
                 .Run(StopPositionStep.NoneModeOfOperation, () => { return _beckhoffCommonAxis.WriteModeOfMode(AxisModeOfOperation.None); }, () => { return CheckModeOfOperation((byte)AxisModeOfOperation.None); }, 1000)
                 .Run(StopPositionStep.QuickStop, () => { return _beckhoffCommonAxis.WriteControlWord(0x02); }, () => { return CheckControlWord(0x02); }, 1000)
-                .Run(StopPositionStep.Control6, () => { return _beckhoffCommonAxis.WriteControlWord(0x06); }, () => { return CheckControlWord(0x06); }, 1000)
-                .Run(StopPositionStep.Control7, () => { return _beckhoffCommonAxis.WriteControlWord(0x07); }, () => { return CheckControlWord(0x07); }, 1000)
-
+                .Run(StopPositionStep.ControlOffControlWord, () => { return _beckhoffCommonAxis.WriteControlWord(0x06); }, () => { return CheckControlWord(0x06); }, 1000)
+                .Run(StopPositionStep.ControlOnControlWord, () => { return _beckhoffCommonAxis.WriteControlWord(0x07); }, () => { return CheckControlWord(0x07); }, 1000)
                 .Run(StopPositionStep.EnableOperation, () => { return _beckhoffCommonAxis.WriteControlWord(0x0F); }, () => { return CheckControlWord(0x0F); }, 1000)
-              
                 .End(StopPositionStep.End, NullFun, 100);
             return Runner.Status;
         }

PunkHPX8_RT/Devices/VpwCell/VpwCellDevice.cs

@@ -8,6 +8,7 @@ using MECF.Framework.Common.CommonData.Prewet;
 using MECF.Framework.Common.CommonData.Vpw;
 using MECF.Framework.Common.IOCore;
 using MECF.Framework.Common.Persistent.SRD;
+using MECF.Framework.Common.Persistent.Temperature;
 using MECF.Framework.Common.Persistent.VpwCell;
 using MECF.Framework.Common.Persistent.VpwMain;
 using PunkHPX8_RT.Devices.AXIS;
@@ -61,6 +62,14 @@ namespace PunkHPX8_RT.Devices.VpwCell
         /// 数据
         /// </summary>
         public VpwCellCommonData CommonData { get { return _commonData; } }
+        /// <summary>
+        /// 操作模式
+        /// </summary>
+        public string OperationMode { get { return _vpwCellPersistentValue.OperatingMode; } }
+        /// <summary>
+        /// 工程模式
+        /// </summary>
+        public string EngineerMode { get { return _vpwCellPersistentValue.RecipeOperatingMode; } }
         #endregion
         /// <summary>
         /// 构造函数
@@ -91,8 +100,7 @@ namespace PunkHPX8_RT.Devices.VpwCell
         private void InitializeParameter()
         {
             _rotationAxis = DEVICE.GetDevice<JetAxisBase>($"{Module}.Rotation");
-            _vpwCellPersistentValue = VpwCellPersistentManager.Instance.GetPersistentValue(Module);
-           
+            _vpwCellPersistentValue = VpwCellPersistentManager.Instance.GetPersistentValue(Module);           
         }
         /// <summary>
         /// 初始化Routine
@@ -230,56 +238,7 @@ namespace PunkHPX8_RT.Devices.VpwCell
         }
         #endregion
 
-        /// <summary>
-        /// Vent Valve On
-        /// </summary>
-        /// <returns></returns>
-        private bool VentValveOn()
-        {
-            return WriteVariableValue(VENT_VALVE, true);
-        }
-        /// <summary>
-        /// Vent Valve Off
-        /// </summary>
-        /// <returns></returns>
-        private bool VentValveOff()
-        {
-            return WriteVariableValue(VENT_VALVE, false);
-        }
-        /// <summary>
-        /// Vent Valve On
-        /// </summary>
-        /// <returns></returns>
-        private bool DrainValveOn()
-        {
-            return WriteVariableValue(DRAIN_VALVE, true);
-        }
-        /// <summary>
-        /// Vent Valve Off
-        /// </summary>
-        /// <returns></returns>
-        private bool DrainValveOff()
-        {
-            return WriteVariableValue(DRAIN_VALVE, false);
-        }
-        /// <summary>
-        /// Vacuum valve on
-        /// </summary>
-        /// <returns></returns>
-        private bool VacuumValveOn()
-        {
-            return WriteVariableValue(VACUUM_VALVE, true);
-        }
-        /// <summary>
-        /// Vacuum valve off
-        /// </summary>
-        /// <returns></returns>
-        private bool VacuumValveOff()
-        {
-            return WriteVariableValue(VACUUM_VALVE, false);
-        }
-
-
+        #region Mode Switch
         /// <summary>
         /// DisabledAction
         /// </summary>
@@ -393,6 +352,56 @@ namespace PunkHPX8_RT.Devices.VpwCell
             VpwCellPersistentManager.Instance.UpdatePersistentValue(Module);
             return true;
         }
+        #endregion
+
+        /// <summary>
+        /// Vent Valve On
+        /// </summary>
+        /// <returns></returns>
+        public bool VentValveOn()
+        {
+            return WriteVariableValue(VENT_VALVE, true);
+        }
+        /// <summary>
+        /// Vent Valve Off
+        /// </summary>
+        /// <returns></returns>
+        public bool VentValveOff()
+        {
+            return WriteVariableValue(VENT_VALVE, false);
+        }
+        /// <summary>
+        /// Vent Valve On
+        /// </summary>
+        /// <returns></returns>
+        public bool DrainValveOn()
+        {
+            return WriteVariableValue(DRAIN_VALVE, true);
+        }
+        /// <summary>
+        /// Vent Valve Off
+        /// </summary>
+        /// <returns></returns>
+        public bool DrainValveOff()
+        {
+            return WriteVariableValue(DRAIN_VALVE, false);
+        }
+        /// <summary>
+        /// Vacuum valve on
+        /// </summary>
+        /// <returns></returns>
+        public bool VacuumValveOn()
+        {
+            return WriteVariableValue(VACUUM_VALVE, true);
+        }
+        /// <summary>
+        /// Vacuum valve off
+        /// </summary>
+        /// <returns></returns>
+        public bool VacuumValveOff()
+        {
+            return WriteVariableValue(VACUUM_VALVE, false);
+        }
         /// <summary>
         /// 写变量
         /// </summary>
@@ -405,8 +414,6 @@ namespace PunkHPX8_RT.Devices.VpwCell
             return IOModuleManager.Instance.WriteIoValue(ioName, value);
         }
 
-
-
         #endregion
 
         /// <summary>

PunkHPX8_RT/Devices/VpwMain/VpwDeviceTimer.cs

@@ -2,8 +2,6 @@
 using Aitex.Core.Util;
 using MECF.Framework.Common.Equipment;
 using MECF.Framework.Common.ToolLayout;
-using PunkHPX8_RT.Devices.AXIS;
-using PunkHPX8_RT.Devices.SRD;
 using PunkHPX8_RT.Devices.VpwCell;
 using System;
 using System.Collections.Generic;

PunkHPX8_RT/Devices/VpwMain/VpwMainDevice.cs

@@ -487,8 +487,6 @@ namespace PunkHPX8_RT.Devices.VpwMain
         {
             return WriteVariableValue(BOOSTER_PUMP_SPEED, speed == 0 ? _lastBoosterPumpSpeed : speed);
         }
-
-
         /// Booster Pump Speed回车操作
         /// </summary>
         /// <param name="cmd"></param>
@@ -512,25 +510,7 @@ namespace PunkHPX8_RT.Devices.VpwMain
             }
             return true;
         }
-        #endregion
 
-        #region Chamber
-        /// <summary>
-        /// 上升
-        /// </summary>
-        /// <returns></returns>
-        public bool ChamberUp()
-        {
-            return WriteVariableValue(CHAMBER_CLOSE, false);
-        }
-        /// <summary>
-        /// 下降
-        /// </summary>
-        /// <returns></returns>
-        public bool ChamberDown()
-        {
-            return WriteVariableValue(CHAMBER_CLOSE, true);
-        }
         /// <summary>
         /// Pump Speed手动模式
         /// </summary>
@@ -559,6 +539,28 @@ namespace PunkHPX8_RT.Devices.VpwMain
             _commonData.BoosterPumpStatusContent = $"{_commonData.BoosterPumpModel}: {statusContent}";
             return true;
         }
+        #endregion
+
+        #region Chamber
+        /// <summary>
+        /// 上升
+        /// </summary>
+        /// <returns></returns>
+        public bool ChamberUp()
+        {
+            return WriteVariableValue(CHAMBER_CLOSE, false);
+        }
+        /// <summary>
+        /// 下降
+        /// </summary>
+        /// <returns></returns>
+        public bool ChamberDown()
+        {
+            return WriteVariableValue(CHAMBER_CLOSE, true);
+        }
+        #endregion
+
+        #region Mode switch
 
         /// <summary>
         /// DisabledAction

PunkHPX8_RT/Modules/EFEM/EfemEntity.cs

@@ -1361,7 +1361,7 @@ namespace PunkHPX8_RT.Modules
                 }
                 else
                 {
-                    PostMsg(PUFSTATE.Error);
+                    PostMsg(EFEMSTATE.Error);
                 }
             }
             return false;

PunkHPX8_RT/Modules/SRD/SRDEntity.cs

@@ -513,7 +513,7 @@ namespace PunkHPX8_RT.Modules.SRD
         /// <returns></returns>
         private bool InitializeAll(object[] param)
         {
-            if (fsm.State == (int)MetalState.Initializing)
+            if (fsm.State == (int)SRDState.Initializing)
             {
                 LOG.WriteLog(eEvent.WARN_SRD, Module.ToString(), "state is Initializing,cannot do initialize");
                 return false;

PunkHPX8_RT/Modules/VpwCell/VpwCellEntity.cs

@@ -1,8 +1,14 @@
-using Aitex.Core.RT.Fsm;
+using Aitex.Core.RT.Device;
+using Aitex.Core.RT.Fsm;
+using Aitex.Core.RT.Log;
 using MECF.Framework.Common.Equipment;
+using MECF.Framework.Common.Persistent.Temperature;
+using MECF.Framework.Common.Persistent.VpwCell;
+using MECF.Framework.Common.Persistent.VpwMain;
 using MECF.Framework.Common.SubstrateTrackings;
 using MECF.Framework.Common.ToolLayout;
 using PunkHPX8_Core;
+using PunkHPX8_RT.Devices.VpwCell;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -19,63 +25,80 @@ namespace PunkHPX8_RT.Modules.VpwMain
             Home
         }
 
+
+        #region 常量
+        private const string STRATUS = "Stratus";
+        private const string AUTO = "Auto";
+        private const string MANUAL = "Manual";
+        private const string DISABLED = "Disabled";
+        private const string ENGINEERING = "Engineering";
+        private const string PRODUCTION = "Production";
+        #endregion
+
         #region 内部变量
+        /// <summary>
+        /// 持久化数值
+        /// </summary>
+        private VpwCellPersistentValue _persistentValue;
         #endregion
 
         #region 属性
         public ModuleName Module { get; private set; }
         /// <summary>
-        /// 初始化状态
+        /// 是否Init
         /// </summary>
         public bool IsInit
         {
-            get { return false; }
+            get { return fsm.State == (int)VPWMainState.Init; }
         }
-
         /// <summary>
-        /// 空闲状态
+        /// 是否Idle
         /// </summary>
         public bool IsIdle
         {
             get
             {
-                return true;
+                return fsm.State == (int)VPWMainState.Idle;
             }
         }
         /// <summary>
-        /// 是否发生错误
+        /// 是否错误
         /// </summary>
         public bool IsError
         {
-            get { return false; }
+            get { return fsm.State == (int)VPWMainState.Error; }
         }
         /// <summary>
-        /// 是否正在作业
+        /// 正在忙碌
         /// </summary>
         public bool IsBusy
         {
-            get { return false; }
+            get { return fsm.State == (int)VPWMainState.Initializing; }
         }
 
-        public bool IsAuto { get; } = true;
+        /// <summary>
+        /// 是否禁用
+        /// </summary>
+        public bool IsDisable { get { return _persistentValue == null || _persistentValue.OperatingMode == DISABLED; } }
 
         /// <summary>
-        /// 是否为工程模式
+        /// 自动模式
         /// </summary>
-        public bool IsEngineering { get; } = false;
+        public bool IsAuto { get { return _persistentValue != null && _persistentValue.OperatingMode == AUTO; } }
         /// <summary>
-        /// 是否为产品模式
+        /// 自动模式
         /// </summary>
-        public bool IsProduction { get; } = true;
+        public bool IsManual { get { return _persistentValue != null && _persistentValue.OperatingMode == MANUAL; } }
         /// <summary>
-        /// 是否禁用
+        /// 是否为工程模式
         /// </summary>
-        public bool IsDisable { get; internal set; } = false;
+        public bool IsEngineering { get { return _persistentValue != null && _persistentValue.RecipeOperatingMode == ENGINEERING; } }
         /// <summary>
-        /// 最大Slot数量
+        /// 是否为产品模式
         /// </summary>
-        public int MaxSlotNumber { get; internal set; }
+        public bool IsProduction { get { return _persistentValue != null && _persistentValue.RecipeOperatingMode == PRODUCTION; } }
         #endregion
+
         /// <summary>
         /// 构造函数
         /// </summary>
@@ -84,6 +107,28 @@ namespace PunkHPX8_RT.Modules.VpwMain
         {
             this.Module = module;
         }
+        /// <summary>
+        /// 初始化
+        /// </summary>
+        /// <returns></returns>
+        protected override bool Init()
+        {
+            InitializeParameter();
+            return true;
+        }
+
+        /// <summary>
+        /// 初始化参数
+        /// </summary>
+        private void InitializeParameter()
+        {
+            _persistentValue = VpwCellPersistentManager.Instance.GetPersistentValue(Module.ToString());
+            if (_persistentValue == null)
+            {
+                LOG.WriteLog(eEvent.ERR_VPW, Module.ToString(), "Persistent Value Object is not exist");
+            }
+        }
+
         public bool Check(int msg, out string reason, params object[] args)
         {
             reason = "";
@@ -99,11 +144,7 @@ namespace PunkHPX8_RT.Modules.VpwMain
         /// </summary>
         public void EnterInit()
         {
-            //if ((VpwMainState)fsm.State != PrewetState.Idle) return;
-            //else
-            //{
-            //    CheckToPostMessage<PrewetState, PrewetMsg>(eEvent.ERR_PREWET, Module.ToString(), (int)PrewetMsg.Init);
-            //}
+
         }
         public int Invoke(string function, params object[] args)
         {

PunkHPX8_RT/Modules/VpwMain/VPWHomeRoutine.cs

@@ -0,0 +1,148 @@
+using Aitex.Core.RT.Device;
+using Aitex.Core.RT.Log;
+using Aitex.Core.RT.Routine;
+using Aitex.Core.Util;
+using MECF.Framework.Common.Routine;
+using PunkHPX8_Core;
+using PunkHPX8_RT.Devices.VpwCell;
+using PunkHPX8_RT.Devices.VpwMain;
+using SecsGem.Core.ItemModel;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace PunkHPX8_RT.Modules.VpwMain
+{
+    public class VPWHomeRoutine : RoutineBase, IRoutine
+    {
+        private enum HomeStep
+        {
+            ChameberUp,
+            OpenCellDrainValve,
+            End
+        }
+
+        #region 常量 
+        #endregion
+
+        #region 内部变量
+        /// <summary>
+        /// Cell device集合
+        /// </summary>
+        private List<VpwCellDevice> _vpwCellDevices;
+        /// <summary>
+        /// Main Device
+        /// </summary>
+        private VpwMainDevice _mainDevice;
+        /// <summary>
+        /// cell集合
+        /// </summary>
+        private List<VpwCellDevice> _cellLst=new List<VpwCellDevice>();
+        #endregion
+
+        /// <summary>
+        /// 构造函数
+        /// </summary>
+        /// <param name="module"></param>
+        /// <param name="device"></param>
+        public VPWHomeRoutine(string module) : base(module)
+        {
+        }
+        /// <summary>
+        /// 中止
+        /// </summary>
+        public void Abort()
+        {
+            Runner.Stop("Manual abort");
+        }
+        /// <summary>
+        /// 监控
+        /// </summary>
+        /// <returns></returns>
+        public RState Monitor()
+        {
+            Runner.Run(HomeStep.ChameberUp, _mainDevice.ChamberUp, CheckChamberClosed, _delay_1s)
+                .Run(HomeStep.OpenCellDrainValve, OpenCellDrainValve, CheckCellDrainValveStatus, _delay_2s)
+                .End(HomeStep.End,NullFun, _delay_1ms);
+            return Runner.Status;
+        }
+        /// <summary>
+        /// 检验Chamber关闭
+        /// </summary>
+        /// <returns></returns>
+        private bool CheckChamberClosed()
+        {
+            return _mainDevice.CommonData.ChamberClosed && !_mainDevice.CommonData.ChamberOpened;
+        }
+        /// <summary>
+        /// 打开所有cell valve
+        /// </summary>
+        /// <returns></returns>
+        private bool OpenCellDrainValve()
+        {
+            foreach(var device in _vpwCellDevices)
+            {
+                VpwCellEntity vpwCellEntity = Singleton<RouteManager>.Instance.GetModule<VpwCellEntity>(device.Module);
+                if (vpwCellEntity.IsAuto||vpwCellEntity.IsManual)
+                {
+                    _cellLst.Add(device);
+                    bool result= device.DrainValveOn();
+                    if (!result)
+                    {
+                        LOG.WriteLog(eEvent.ERR_VPWMAIN, Module, $"{device.Module} open drain valve failed");
+                        CloseCellDrainValve();
+                        return false;
+                    }
+                }
+            }
+            return true;
+        }
+        /// <summary>
+        /// 检验Cell Drain状态
+        /// </summary>
+        /// <returns></returns>
+        private bool CheckCellDrainValveStatus()
+        {
+            foreach (var item in _cellLst)
+            {
+                bool result = item.CommonData.DrainValve;
+                if (!result)
+                {
+                    LOG.WriteLog(eEvent.ERR_VPWMAIN, Module, $"{item.Module} drain valve is not opened");
+                    CloseCellDrainValve();
+                    return false;
+                }
+            }
+            return true;
+        }
+        /// <summary>
+        /// 关闭所有cell的Drain valve
+        /// </summary>
+        private void CloseCellDrainValve()
+        {
+            foreach (var item in _cellLst)
+            {
+                item.DrainValveOff();
+            }
+        }
+        /// <summary>
+        /// 启动
+        /// </summary>
+        /// <param name="objs"></param>
+        /// <returns></returns>
+        public RState Start(params object[] objs)
+        {
+            List<VpwCellDevice> lstDevice = (List<VpwCellDevice>)objs[0];
+            _vpwCellDevices.Clear();
+            _cellLst.Clear();
+            for (int i = 0; i < lstDevice.Count; i++)
+            {
+                _vpwCellDevices.Add(lstDevice[i]);
+            }
+            _mainDevice = DEVICE.GetDevice<VpwMainDevice>(Module.ToString());
+            return Runner.Start(Module,"VPW Home");
+        }
+    }
+}

PunkHPX8_RT/Modules/VpwMain/VPWMsg.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace PunkHPX8_RT.Modules.VpwMain
+{
+    public enum VPWMainMsg
+    {
+        Error,
+        Initialize,
+        ResumeError,
+        Init,
+        Abort
+    }
+}

PunkHPX8_RT/Modules/VpwMain/VpwMainEntity.cs

@@ -1,7 +1,13 @@
-using Aitex.Core.RT.Fsm;
+using Aitex.Core.RT.Device;
+using Aitex.Core.RT.Fsm;
 using Aitex.Core.RT.Log;
+using Aitex.Core.Utilities;
 using MECF.Framework.Common.Equipment;
+using MECF.Framework.Common.Persistent.Reservoirs;
+using MECF.Framework.Common.Persistent.VpwMain;
+using MECF.Framework.Common.ToolLayout;
 using PunkHPX8_Core;
+using PunkHPX8_RT.Devices.VpwCell;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -18,59 +24,87 @@ namespace PunkHPX8_RT.Modules.VpwMain
             Home
         }
 
+        #region 常量
+        private const string STRATUS = "Stratus";
+        private const string AUTO = "Auto";
+        private const string MANUAL = "Manual";
+        private const string DISABLED = "Disabled";
+        private const string ENGINEERING = "Engineering";
+        private const string PRODUCTION = "Production";
+        #endregion
+
         #region 内部变量
+        /// <summary>
+        /// 持久化数值
+        /// </summary>
+        private VpwMainPersistentValue _persistentValue;
+        /// <summary>
+        /// VPW cell集合
+        /// </summary>
+        private List<VpwCellDevice> _vpwCellDevices = new List<VpwCellDevice>();
+        /// <summary>
+        /// Home Routine
+        /// </summary>
+        private VPWHomeRoutine _homeRoutine;
         #endregion
 
         #region 属性
         public ModuleName Module { get; private set; }
         /// <summary>
-        /// 初始化状态
+        /// 是否Init
         /// </summary>
         public bool IsInit
         {
-            get { return false; }
+            get { return fsm.State == (int)VPWMainState.Init; }
         }
-
         /// <summary>
-        /// 空闲状态
+        /// 是否Idle
         /// </summary>
         public bool IsIdle
         {
             get
             {
-                return true;
+                return fsm.State == (int)VPWMainState.Idle;
             }
         }
         /// <summary>
-        /// 是否发生错误
+        /// 是否错误
         /// </summary>
         public bool IsError
         {
-            get { return false; }
+            get { return fsm.State == (int)VPWMainState.Error; }
         }
         /// <summary>
-        /// 是否正在作业
+        /// 正在忙碌
         /// </summary>
         public bool IsBusy
         {
-            get { return false; }
+            get { return fsm.State == (int)VPWMainState.Initializing; }
         }
 
-        public bool IsAuto { get; } = true;
+        /// <summary>
+        /// 是否禁用
+        /// </summary>
+        public bool IsDisable { get { return _persistentValue == null || _persistentValue.OperatingMode == DISABLED; } }
 
         /// <summary>
-        /// 是否为工程模式
+        /// 自动模式
         /// </summary>
-        public bool IsEngineering { get; } = false;
+        public bool IsAuto { get { return _persistentValue != null && _persistentValue.OperatingMode == AUTO; } }
         /// <summary>
-        /// 是否为产品模式
+        /// 自动模式
         /// </summary>
-        public bool IsProduction { get; } = true;
+        public bool IsManual { get { return _persistentValue != null && _persistentValue.OperatingMode == MANUAL; } }
         /// <summary>
-        /// 是否禁用
+        /// 是否为工程模式
         /// </summary>
-        public bool IsDisable { get; internal set; } = false;
+        public bool IsEngineering { get { return _persistentValue != null && _persistentValue.RecipeOperatingMode == ENGINEERING; } }
+        /// <summary>
+        /// 是否为产品模式
+        /// </summary>
+        public bool IsProduction { get { return _persistentValue != null && _persistentValue.RecipeOperatingMode == PRODUCTION; } }
         #endregion
+
         /// <summary>
         /// 构造函数
         /// </summary>
@@ -79,6 +113,104 @@ namespace PunkHPX8_RT.Modules.VpwMain
         {
             this.Module = module;
         }
+
+        /// <summary>
+        /// 初始化
+        /// </summary>
+        /// <returns></returns>
+        protected override bool Init()
+        {
+            InitialFsm();
+            InitializeParameter();
+            InitializeRoutine();
+            return true;
+        }
+        /// 初始化状态机
+        /// </summary>
+        private void InitialFsm()
+        {
+            fsm = new StateMachine<VpwMainEntity>(Module.ToString(), (int)VPWMainState.Init, 100);
+            fsm.EnableRepeatedMsg(true);
+
+            AnyStateTransition(VPWMainState.Error, NullFunc, VPWMainState.Error);
+            //Initialized
+            Transition(VPWMainState.Error, VPWMainMsg.Initialize, InitializeAll, VPWMainState.Initializing);
+            Transition(VPWMainState.Init, VPWMainMsg.Initialize, InitializeAll, VPWMainState.Initializing);
+            Transition(VPWMainState.Idle, VPWMainMsg.Initialize, InitializeAll, VPWMainState.Initializing);
+            Transition(VPWMainState.Initializing, FSM_MSG.TIMER, InitializeAllMonitor, VPWMainState.Idle);
+
+            //直接进入Idle
+            Transition(VPWMainState.Initialized, FSM_MSG.TIMER, NullFunc, VPWMainState.Idle);
+            //Enter Init
+            Transition(VPWMainState.Idle, VPWMainMsg.Init, NullFunc, VPWMainState.Init);
+
+            EnumLoop<VPWMainState>.ForEach((item) => { fsm.MapState((int)item, item.ToString()); });
+
+            EnumLoop<VPWMainMsg>.ForEach((item) => { fsm.MapMessage((int)item, item.ToString()); });
+        }
+        /// <summary>
+        /// 初始化参数
+        /// </summary>
+        private void InitializeParameter()
+        {
+            _persistentValue = VpwMainPersistentManager.Instance.GetPersistentValue(Module.ToString());
+            if (_persistentValue == null)
+            {
+                LOG.WriteLog(eEvent.ERR_VPWMAIN, Module.ToString(), "Persistent Value Object is not exist");
+            }
+            _vpwCellDevices.Clear();
+            VpwMainItem vpwMainItem = VpwMainItemManager.Instance.GetItem(Module.ToString());
+            if (vpwMainItem == null || vpwMainItem.VpwCells == null)
+            {
+                return;
+            }
+            foreach(var item in vpwMainItem.VpwCells)
+            {
+                VpwCellDevice cellDevice = DEVICE.GetDevice<VpwCellDevice>(item.ModuleName);
+                _vpwCellDevices.Add(cellDevice);
+            }
+        }
+        /// <summary>
+        /// 初始化Routine
+        /// </summary>
+        private void InitializeRoutine()
+        {
+            _homeRoutine = new VPWHomeRoutine(Module.ToString());
+        }
+
+        #region InitializeAll
+        /// <summary>
+        /// Initialize
+        /// </summary>
+        /// <param name="param"></param>
+        /// <returns></returns>
+        private bool InitializeAll(object[] param)
+        {
+            if (_vpwCellDevices == null || _vpwCellDevices.Count == 0)
+            {
+                LOG.WriteLog(eEvent.ERR_VPWMAIN, Module.ToString(), "cell device is empty");
+                return false;
+            }
+            return _homeRoutine.Start(_vpwCellDevices) == RState.Running;
+        }
+        /// <summary>
+        /// Initialize 监控
+        /// </summary>
+        /// <param name="param"></param>
+        /// <returns></returns>
+        private bool InitializeAllMonitor(object[] param)
+        {
+            RState ret = _homeRoutine.Monitor();
+            if (ret == RState.Failed || ret == RState.Timeout)
+            {
+                PostMsg(VPWMainMsg.Error);
+                return false;
+            }
+
+            return ret == RState.End;
+        }
+        #endregion
+
         public bool Check(int msg, out string reason, params object[] args)
         {
             reason = "";
@@ -95,11 +227,7 @@ namespace PunkHPX8_RT.Modules.VpwMain
         /// </summary>
         public void EnterInit()
         {
-            //if ((VpwMainState)fsm.State != PrewetState.Idle) return;
-            //else
-            //{
-            //    CheckToPostMessage<PrewetState, PrewetMsg>(eEvent.ERR_PREWET, Module.ToString(), (int)PrewetMsg.Init);
-            //}
+
         }
 
         public int Invoke(string function, params object[] args)

PunkHPX8_RT/PunkHPX8_RT.csproj

@@ -313,7 +313,9 @@
     <Compile Include="Modules\Dummy\DummyEntity.cs" />
     <Compile Include="Modules\DVIDName.cs" />
     <Compile Include="Modules\VpwCell\VpwCellEntity.cs" />
+    <Compile Include="Modules\VpwMain\VPWHomeRoutine.cs" />
     <Compile Include="Modules\VpwMain\VpwMainEntity.cs" />
+    <Compile Include="Modules\VpwMain\VPWMsg.cs" />
     <Compile Include="Schedulers\EfemRobot\RobotMoveHelper.cs" />
     <Compile Include="Schedulers\EfemRobot\SchedulerEfemRobot.cs" />
     <Compile Include="Schedulers\EfemRobot\SchedulerRobot.cs" />