update Drive of HONGHU Robot to Dual-Arms && add VCE cassette in UI.RT && add SMIF/ISMIF.cs,LoadWithSMIFRoutine,UnloadWithSMIFRoutine

Venus/Venus_Core/RtState.cs

@@ -207,7 +207,8 @@ namespace Venus_Core
         Goting,//指定槽到达窗口 对应 GC
         GotingLP,
         Resetting,//重置
-        LoadingWithoutSMIF,//没有SMIF的load
+        LoadingWithSMIF,//有SMIF的load
+        UnLoadingWithSMIF,//有SMIF的load
         LoadPreparing,//准备
         SafeLoading,
         SafeUnloading,

Venus/Venus_MainPages/ViewModels/VenusSeOperationOverViewModel.cs

@@ -278,6 +278,14 @@ namespace Venus_MainPages.ViewModels
         private DelegateCommand __VCELoad;
         public DelegateCommand VCELoad =>
             __VCELoad ?? (__VCELoad = new DelegateCommand(vceLoad));
+
+        private DelegateCommand __VCELoadWithSMIF;
+        public DelegateCommand VCELoadWithSMIF =>
+            __VCELoadWithSMIF ?? (__VCELoadWithSMIF = new DelegateCommand(vceLoadWithSMIF));
+        private DelegateCommand __VCEUnLoadWithSMIF;
+        public DelegateCommand VCEUnLoadWithSMIF =>
+            __VCEUnLoadWithSMIF ?? (__VCEUnLoadWithSMIF = new DelegateCommand(vceUnLoadWithSMIF));
+        
         private DelegateCommand _VCEUnLoad;
         public DelegateCommand VCEUnLoad =>
             _VCEUnLoad ?? (_VCEUnLoad = new DelegateCommand(vceUnLoad));
@@ -498,6 +506,7 @@ namespace Venus_MainPages.ViewModels
             m_RtDataKeys.Add($"SETM.PMCSlitDoorClosed");
             m_RtDataKeys.Add($"SETM.VCEPressure.Value");
             m_RtDataKeys.Add($"VCE1.VCEOutDoorClosed");
+            m_RtDataKeys.Add($"VCE1.CassetteArrive");
             m_RtDataKeys.Add($"SEScheduler.CycledWafer");
             m_RtDataKeys.Add($"SEScheduler.CycleSetPoint");
             m_RtDataKeys.Add($"SEScheduler.CycleCount");
@@ -585,6 +594,14 @@ namespace Venus_MainPages.ViewModels
         {
             InvokeClient.Instance.Service.DoOperation("VCE1.SafeLoad");
         }
+        private void vceLoadWithSMIF()
+        {
+            InvokeClient.Instance.Service.DoOperation("VCE1.LoadWithSMIF");
+        }
+        private void vceUnLoadWithSMIF()
+        {
+            InvokeClient.Instance.Service.DoOperation("VCE1.UnLoadWithSMIF");
+        }
         private void vceUnLoad() 
         {
             InvokeClient.Instance.Service.DoOperation("VCE1.SafeUnload");
@@ -628,26 +645,26 @@ namespace Venus_MainPages.ViewModels
                 PMBDoorIsOpen = !CommonFunction.GetValue<bool>(RtDataValues, "SETM.PMBSlitDoorClosed");
                 PMCDoorIsOpen = !CommonFunction.GetValue<bool>(RtDataValues, "SETM.PMCSlitDoorClosed");
                 VCEOutDoorIsOpen = !CommonFunction.GetValue<bool>(RtDataValues, "VCE1.VCEOutDoorClosed");
-                VCEPercent = CommonFunction.GetValue<double>(RtDataValues, "SETM.VCEPressure.Value") * 248 / 760000;
+                VCEPercent = CommonFunction.GetValue<double>(RtDataValues, "SETM.VCEPressure.Value") * 260 / 750000;
                 if (PMAIsInstalled == true)
                 {
                     PMAModuleInfo = ModuleManager.ModuleInfos["PMA"];
                     PMAWafer = PMAModuleInfo.WaferManager.Wafers[0];
-                    PMAPercent = CommonFunction.GetValue<double>(RtDataValues, "PMA.ProcessHighPressure") * 248 / 760000;
+                    PMAPercent = CommonFunction.GetValue<double>(RtDataValues, "PMA.ProcessHighPressure") * 260 / 750000;
                     PMARecipeResult = CommonFunction.GetValue<RecipeResult>(RtDataValues, "PMA.CurrentRecipeResult");
                 }
                 if (PMBIsInstalled == true)
                 {
                     PMBModuleInfo = ModuleManager.ModuleInfos["PMB"];
                     PMBWafer = PMBModuleInfo.WaferManager.Wafers[0];
-                    PMBPercent = CommonFunction.GetValue<double>(RtDataValues, "PMB.ProcessHighPressure") * 248 / 760000;
+                    PMBPercent = CommonFunction.GetValue<double>(RtDataValues, "PMB.ProcessHighPressure") * 260 / 750000;
                     PMBRecipeResult = CommonFunction.GetValue<RecipeResult>(RtDataValues, "PMB.CurrentRecipeResult");
                 }
                 if (PMCIsInstalled == true)
                 {
                     PMCModuleInfo = ModuleManager.ModuleInfos["PMC"];
                     PMCWafer = PMCModuleInfo.WaferManager.Wafers[0];
-                    PMCPercent = CommonFunction.GetValue<double>(RtDataValues, "PMC.ProcessHighPressure") * 248 / 760000;
+                    PMCPercent = CommonFunction.GetValue<double>(RtDataValues, "PMC.ProcessHighPressure") * 260 / 750000;
                     PMCRecipeResult = CommonFunction.GetValue<RecipeResult>(RtDataValues, "PMC.CurrentRecipeResult");
                 }
                 if (VCEIsInstalled == true)

Venus/Venus_RT/Config/System.sccfg

@@ -332,6 +332,7 @@
 			<config default="1" name="Manufacturer" nameView="Manufacturer" description="厂商, 1:Fortrend;" max="2" min="1" paramter="" tag="" unit="" type="Integer" />
 			<config default="1" name="CommunicationType" nameView="Communication Type" description="0:Analogue; 1:RS232; 2:Ethernet" max="10" min="0" paramter="" tag="" unit="" type="Integer" />
 			<config default="COM24" name="Port" nameView="Port" description="serial port" max="" min="" paramter="" tag="" unit="" type="String" />
+			<config default="15" name="MotionTimeout" nameView="" description="" max="60" min="0" paramter="" tag="" unit="s" type="Integer" />
 		</configs>
 	</configs>
 

Venus/Venus_RT/Devices/SMIF/FortrendPLUS500.cs

@@ -25,7 +25,7 @@ namespace Venus_RT.Devices.SMIF
     /// Loader/Unloader
     /// 执行标准 E84
     /// </summary>
-    public class FortrendPLUS500
+    public class FortrendPLUS500 : ISMIF
     {
 
         public enum StreamType

Venus/Venus_RT/Devices/SMIF/ISMIF.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Venus_RT.Devices.SMIF
+{
+    public interface ISMIF
+    {
+       void Home();
+       void Load();
+       void Unload();
+       void Lock();
+       void Unlock();
+       void Reset();
+       void Query();
+       void Abort();
+       
+    }
+}

Venus/Venus_RT/Devices/TM/HongHuVR.cs

@@ -125,7 +125,7 @@ namespace Venus_RT.Devices.VCE
             _currentStep = VRStep.Pick;
             _status = RState.Running;
             SetRobotMovingInfo(RobotAction.Picking, hand, station);
-            return _SendCommand($"PICK {_StationNumbers[station]}");
+            return _SendCommand($"PICK {_StationNumbers[station]} ARM {Hand2Arm(hand)}");
         }
 
         public bool PickExtend(ModuleName station, int slot, Hand hand)
@@ -136,7 +136,7 @@ namespace Venus_RT.Devices.VCE
             _currentStep = VRStep.PickExtend;
             _status = RState.Running;
             SetRobotMovingInfo(RobotAction.Picking, hand, station);
-            return _SendCommand($"PICK {_StationNumbers[station]} ENRT NR");
+            return _SendCommand($"PICK {_StationNumbers[station]} ARM {Hand2Arm(hand)} ENRT NR");
         }
 
         public bool PickRetract(ModuleName station, int slot, Hand hand)
@@ -147,7 +147,7 @@ namespace Venus_RT.Devices.VCE
             _currentStep = VRStep.PickRetract;
             _status = RState.Running;
             SetRobotMovingInfo(RobotAction.Picking, hand, station);
-            return _SendCommand($"PICK {_StationNumbers[station]} STRT NR");
+            return _SendCommand($"PICK {_StationNumbers[station]} ARM {Hand2Arm(hand)} STRT NR");
         }
         public bool Place(ModuleName station, int slot, Hand hand)
         {
@@ -157,7 +157,7 @@ namespace Venus_RT.Devices.VCE
             _currentStep = VRStep.Place;
             _status = RState.Running;
             SetRobotMovingInfo(RobotAction.Picking, hand, station);
-            return _SendCommand($"PLACE {_StationNumbers[station]}");
+            return _SendCommand($"PLACE {_StationNumbers[station]} ARM {Hand2Arm(hand)}");
         }
         public bool PlaceExtend(ModuleName station, int slot, Hand hand)
         {
@@ -167,7 +167,7 @@ namespace Venus_RT.Devices.VCE
             _currentStep = VRStep.Place;
             _status = RState.Running;
             SetRobotMovingInfo(RobotAction.Picking, hand, station);
-            return _SendCommand($"PLACE {_StationNumbers[station]} ENRT NR");
+            return _SendCommand($"PLACE {_StationNumbers[station]} ARM {Hand2Arm(hand)} ENRT NR");
         }
         public bool PlaceRetract(ModuleName station, int slot, Hand hand)
         {
@@ -177,7 +177,7 @@ namespace Venus_RT.Devices.VCE
             _currentStep = VRStep.Place;
             _status = RState.Running;
             SetRobotMovingInfo(RobotAction.Picking, hand, station);
-            return _SendCommand($"PLACE {_StationNumbers[station]} STRT NR");
+            return _SendCommand($"PLACE {_StationNumbers[station]} ARM {Hand2Arm(hand)} STRT NR");
         }
         public bool Transfer(ModuleName fromstation, ModuleName tostation, Hand hand)
         {
@@ -196,7 +196,7 @@ namespace Venus_RT.Devices.VCE
 
             _currentStep = hand == Hand.Blade2 ? VRStep.CheckLoad_ArmB : VRStep.CheckLoad_ArmA;
             _status = RState.Running;
-            return _SendCommand($"CHECK LOAD");
+            return _SendCommand($"CHECK LOAD ARM {Hand2Arm(hand)}");
         }
 
 
@@ -209,7 +209,7 @@ namespace Venus_RT.Devices.VCE
         {
             _currentStep = VRStep.Goto;
             _status = RState.Running;
-            return _SendCommand($"GOTO N {_StationNumbers[station]}");
+            return _SendCommand($"GOTO N {_StationNumbers[station]} ARM {Hand2Arm(hand)}");
         }
 
         public bool MoveTo(ModuleName stnFrom, ModuleName stnTo, Hand hand)

Venus/Venus_RT/Modules/VCE/LoadRoutine.cs

@@ -21,12 +21,12 @@ namespace Venus_RT.Modules.VCE
 {
     public class LoadRoutine : ModuleRoutineBase, IRoutine
     {
-        public enum LoadStep
+        private enum LoadStep
         {
             CloseOutDoor,
             Mapping,
             ReadMap,
-            PumpDown,
+            VcePumpDown,
             OpenInnerDoor,
             NotifyOver
         }
@@ -39,15 +39,16 @@ namespace Venus_RT.Modules.VCE
         public LoadRoutine(ModuleName module, VceModuleBase vce) : base(module)
         {
             _vce = vce;
-            pumpRoutine = new SEMFPumpRoutine(DEVICE.GetDevice<HongHuTM>("SETM"),module);
+            _tm = DEVICE.GetDevice<HongHuTM>("SETM");
+            pumpRoutine = new SEMFPumpRoutine(_tm, module);
         }
 
         public RState Start(params object[] objs)
         {
 
-            _tm = DEVICE.GetDevice<HongHuTM>("SETM");
             _timeout = SC.GetValue<int>($"{Module}.MotionTimeout") *1000;
             //if vce inner door not close cannot do it as it will pump
+
             if (!Singleton<RouteManager>.Instance.seTM.IsVCESlitDoorClosed)
             {
                 LOG.Write(eEvent.ERR_VCE_COMMON_Failed, Module, $"VCE Inner Door is open! Please close it First!");
@@ -62,7 +63,7 @@ namespace Venus_RT.Modules.VCE
             Runner.Run(LoadStep.CloseOutDoor,       CloseOutDoor,       CheckVceIdle,        _timeout)
                   .Run(LoadStep.Mapping,            Mapping,            CheckVceIdle,        25 *1000)
                   .Run(LoadStep.ReadMap,            ReadMap,            CheckVceIdle,        _timeout)
-                  .Run(LoadStep.PumpDown,           PumpDown,           CheckPumpOver)
+                  .Run(LoadStep.VcePumpDown,        PumpDown,           CheckPumpOver)
                   .Run(LoadStep.OpenInnerDoor,      OpenInnerDoor,      CheckInnerDoorOpen)
                   .End(LoadStep.NotifyOver,         NullFun,            100);
             return Runner.Status;
@@ -84,7 +85,7 @@ namespace Venus_RT.Modules.VCE
             RState ret = pumpRoutine.Monitor();
             if (ret == RState.Failed || ret == RState.Timeout)
             {
-                _vce.PostMsg(VceMSG.Error);
+                Singleton<RouteManager>.Instance.VCE.PostMsg(VceMSG.Error);
             }
             return ret == RState.End;
         }

Venus/Venus_RT/Modules/VCE/LoadWithSMIFRoutine.cs

@@ -0,0 +1,182 @@
+using Aitex.Core.RT.Device;
+using Aitex.Core.RT.Log;
+using Aitex.Core.RT.Routine;
+using Aitex.Core.RT.SCCore;
+using Aitex.Core.Util;
+using MECF.Framework.Common.Equipment;
+using MECF.Framework.RT.ModuleLibrary.VceModules;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Venus_Core;
+using Venus_RT.Devices;
+using Venus_RT.Devices.SMIF;
+using Venus_RT.Modules.TM;
+using Venus_RT.Modules.TM.VenusEntity;
+using static Venus_RT.Modules.VCE.LoadRoutine;
+
+namespace Venus_RT.Modules.VCE
+{
+
+    public class LoadWithSMIFRoutine : ModuleRoutineBase, IRoutine
+    {
+        private enum LoadWithSMIFStep
+        {
+            VceGotoLP,
+            VceOuterDoorOpen,
+            SMIFLoad,
+            CloseOutDoor,
+            Mapping,
+            ReadMap,
+            VcePumpDown,
+            OpenInnerDoor,
+            NotifyOver
+        }
+        private HongHuTM _tm;
+        private VceModuleBase _vce;
+        private ISMIF _smif;
+        private int _VceMotionTimeout;
+        private int _SMIFMotionTimeout;
+        private SEMFPumpRoutine pumpRoutine;
+
+        public LoadWithSMIFRoutine(ModuleName module, VceModuleBase vce, ISMIF smif) : base(module)
+        {
+            _vce = vce;
+            _smif = smif;
+            _tm = DEVICE.GetDevice<HongHuTM>("SETM");
+            pumpRoutine = new SEMFPumpRoutine(_tm, module);
+        }
+
+
+        public RState Start(params object[] objs)
+        {
+            _VceMotionTimeout = SC.GetValue<int>($"{Module}.MotionTimeout") * 1000;
+            _SMIFMotionTimeout = SC.GetValue<int>($"{Module}.SMIF.MotionTimeout") * 1000;
+            //如果不是ATM 不允许执行
+            if (!Singleton<RouteManager>.Instance.seTM.VCEIsATM)
+            {
+                LOG.Write(eEvent.ERR_VCE_COMMON_Failed, Module, $"VCE is not atm cannot load prepare! Please Vent it First!");
+                return RState.Failed;
+            }
+
+
+            if (!Singleton<RouteManager>.Instance.seTM.IsVCESlitDoorClosed)
+            {
+                LOG.Write(eEvent.ERR_VCE_COMMON_Failed, Module, $"VCE Inner Door is open! Please close it First!");
+                return RState.Failed;
+            }
+            Reset();
+            return Runner.Start(Module,"Start Load with smif");
+        }
+
+        public RState Monitor()
+        {
+            Runner
+                .Run(LoadWithSMIFStep.VceGotoLP,        VceGotoLP,          CheckVceStageDownDone,          _VceMotionTimeout)
+                .Run(LoadWithSMIFStep.VceOuterDoorOpen, VceOuterDoorOpen,   CheckVceOuterDoorOpenDone,      _VceMotionTimeout)
+                .Run(LoadWithSMIFStep.SMIFLoad,         SMIFLoad,           CheckSMIFLoadDone,              _SMIFMotionTimeout)
+                .Run(LoadWithSMIFStep.CloseOutDoor,     CloseOutDoor,       CheckVceIdle,                   _VceMotionTimeout)
+                .Run(LoadWithSMIFStep.Mapping,          Mapping,            CheckVceIdle,                   _VceMotionTimeout)
+                .Run(LoadWithSMIFStep.ReadMap,          ReadMap,            CheckVceIdle,                   _VceMotionTimeout)
+                .Run(LoadWithSMIFStep.VcePumpDown,      PumpDown,           CheckPumpOver,                  2*60*1000)
+                .Run(LoadWithSMIFStep.OpenInnerDoor,    OpenInnerDoor,      CheckInnerDoorOpen,             _VceMotionTimeout)
+                .End(LoadWithSMIFStep.NotifyOver,       NullFun,                                            100);
+            return Runner.Status;
+        }
+
+        private bool SMIFLoad()
+        {
+            //_smif.Load();
+            return true;
+        }
+
+        private bool CheckSMIFLoadDone()
+        { 
+            return true;
+        }
+
+        private bool VceGotoLP()
+        {
+            return _vce.GotoLP();
+        }
+
+        private bool VceOuterDoorOpen()
+        {
+            return _vce.OpenDoor();
+        }
+        private bool CheckVceStageDownDone()
+        {
+            if (_vce.Status == RState.Timeout || _vce.Status == RState.Failed)
+            {
+                LOG.Write(eEvent.ERR_VCE_COMMON_Failed, Module, $"VCE Stage Down failed");
+            }
+            return _vce.Status == RState.End;
+        }
+
+        private bool CheckVceOuterDoorOpenDone()
+        {
+            if (_vce.Status == RState.Timeout || _vce.Status == RState.Failed)
+            {
+                LOG.Write(eEvent.ERR_VCE_COMMON_Failed, Module, $"VCE OuterDoor Open failed");
+            }
+            return _vce.Status == RState.End;
+        }
+
+        private bool CheckInnerDoorOpen()
+        {
+            return !_tm.VCESlitDoorClosed;
+        }
+
+        private bool OpenInnerDoor()
+        {
+            return _tm.TurnSlitDoor(Module, true);
+        }
+
+        //
+        private bool CheckPumpOver()
+        {
+            RState ret = pumpRoutine.Monitor();
+            if (ret == RState.Failed || ret == RState.Timeout)
+            {
+                Singleton<RouteManager>.Instance.VCE.PostMsg(VceMSG.Error);
+            }
+            return ret == RState.End;
+        }
+
+        private bool CheckVceIdle()
+        {
+            if (_vce.Status == RState.Failed || _vce.Status == RState.Timeout)
+            {
+                Singleton<RouteManager>.Instance.GetVCE(Module).PostMsg(VceMSG.Error);
+                return false;
+            }
+            return _vce.Status == RState.End;
+        }
+
+        private bool PumpDown()
+        {
+            return pumpRoutine.Start() == RState.Running;
+        }
+
+        private bool ReadMap()
+        {
+            return _vce.ReadMap();
+        }
+        private bool Mapping()
+        {
+            return _vce.Map();
+        }
+
+        private bool CloseOutDoor()
+        {
+            return _vce.CloseDoor();
+        }
+
+        public void Abort()
+        {
+
+        }
+    }
+}

Venus/Venus_RT/Modules/VCE/UnloadWithSMIFRoutine.cs

@@ -0,0 +1,132 @@
+using Aitex.Core.RT.Device;
+using Aitex.Core.RT.OperationCenter;
+using Aitex.Core.RT.Routine;
+using Aitex.Core.RT.SCCore;
+using Aitex.Core.Util;
+using MECF.Framework.Common.Equipment;
+using MECF.Framework.RT.ModuleLibrary.VceModules;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Venus_Core;
+using Venus_RT.Devices;
+using Venus_RT.Devices.SMIF;
+using Venus_RT.Modules.TM.VenusEntity;
+
+namespace Venus_RT.Modules.VCE
+{
+    public class UnloadWithSMIFRoutine : ModuleRoutineBase, IRoutine
+    {
+        public enum UnloadWithSMIFStep
+        {
+            CloseDoor,
+            Vent,
+            GotoUnload,
+            OpenOutDoor,
+            SMIFUnload,
+            CloseOutDoor,
+            NotifyOver
+        }
+
+        VceModuleBase _vce;
+        ISMIF _smif;
+        int _vcetimeout;
+        int _smiftimeout;
+        SEMFVentRoutine ventRoutine;
+        public UnloadWithSMIFRoutine(ModuleName module,VceModuleBase vce,ISMIF smif) : base(module)
+        {
+            _vce = vce;
+            _smif = smif;
+            ventRoutine = new SEMFVentRoutine(DEVICE.GetDevice<HongHuTM>("SETM"), module);
+        }
+
+        public RState Start(params object[] objs)
+        {
+            _vcetimeout = SC.GetValue<int>($"{Module}.MotionTimeout") * 1000;
+            _smiftimeout = SC.GetValue<int>($"{Module}.SMIF.MotionTimeout") * 1000;
+            Reset();
+            return Runner.Start(Module, "VCE Unload with SMIF");
+        }
+        public RState Monitor()
+        {
+            Runner.Run(UnloadWithSMIFStep.CloseDoor,        CloseDoor,          CheckDoorIsClose)
+                  .Run(UnloadWithSMIFStep.Vent,             Vent,               CheckVentOver)
+                  .Run(UnloadWithSMIFStep.GotoUnload,       GotoUnload,         CheckVceIdle,       _vcetimeout)
+                  .Run(UnloadWithSMIFStep.OpenOutDoor,      OpenOutDoor,        CheckVceIdle,       _vcetimeout)
+                  .Run(UnloadWithSMIFStep.SMIFUnload,       SMIFUnload,         CheckSMIFIdle,      _smiftimeout)
+                  .Run(UnloadWithSMIFStep.CloseOutDoor,     CloseOutDoor,       CheckVceIdle,       _vcetimeout)
+                  .End(UnloadWithSMIFStep.NotifyOver,       NullFun, 100);
+            return Runner.Status;
+        }
+
+        private bool CloseDoor()
+        {
+            OP.DoOperation("SETM.SetSlitDoor", ModuleName.VCE1, false);
+            return true;
+        }
+
+        private bool CheckDoorIsClose()
+        {
+            return Singleton<RouteManager>.Instance.seTM.IsVCESlitDoorClosed;
+        }
+
+        private bool CheckVentOver()
+        {
+            RState ret = ventRoutine.Monitor();
+            if (ret == RState.Failed || ret == RState.Timeout)
+            {
+                _vce.PostMsg(VceMSG.Error);
+            }
+            return ret == RState.End;
+        }
+
+        private bool Vent()
+        {
+            return ventRoutine.Start() == RState.Running;
+        }
+
+        private bool SMIFUnload()
+        {
+            _smif.Unload();
+            return true;
+        }
+
+        private bool CheckSMIFIdle()
+        {
+            return true;
+        }
+
+        private bool CloseOutDoor()
+        {
+            return _vce.CloseDoor();
+        }
+        private bool OpenOutDoor()
+        {
+            return _vce.OpenDoor();
+        }
+
+        private bool GotoUnload()
+        {
+            return _vce.GotoLP();
+        }
+
+        private bool CheckVceIdle()
+        {
+            if (_vce.Status == RState.Failed || _vce.Status == RState.Timeout)
+            {
+                Singleton<RouteManager>.Instance.GetVCE(Module).PostMsg(VceMSG.Error);
+                return false;
+            }
+            return _vce.Status == RState.End;
+        }
+
+
+        public void Abort()
+        {
+
+        }
+
+    }
+}

Venus/Venus_RT/Modules/VCE/VceEntity.cs

@@ -17,6 +17,7 @@ using System.Threading.Tasks;
 using System.Windows;
 using Venus_Core;
 using Venus_RT.Devices;
+using Venus_RT.Devices.SMIF;
 using Venus_RT.Devices.VCE;
 using Venus_RT.Modules.PMs;
 using Venus_RT.Modules.TM;
@@ -37,7 +38,8 @@ namespace Venus_RT.Modules.VCE
         Load,
         UnLoad,
         LoadPrepare,
-        LoadWithoutSMIF,
+        LoadWithSMIF,
+        UnLoadWithSMIF,
         Reset,
         Goto,
         GotoLP,
@@ -54,6 +56,8 @@ namespace Venus_RT.Modules.VCE
     {
         private ModuleName _modulename;
         private readonly VceModuleBase _vce;
+        private readonly ISMIF _smif;
+        private bool _CassetteArrive;
 
         public bool IsIdle => fsm.State == (int)VceSTATE.Idle;
 
@@ -64,24 +68,31 @@ namespace Venus_RT.Modules.VCE
         public bool IsError => fsm.State == (int)VceSTATE.Error;
 
         public bool VCEOutDoorClosed => !_vce.OutDoorIsOpen;
+        public bool CassetteArrive => _CassetteArrive;
 
         private int currentSlot;
         private int targetSlot;
         private LoadRoutine _loadRoutine;
         private LoadPrepareRoutine _prepareRoutine;
         private UnloadRoutine _unloadRoutine;
+        private LoadWithSMIFRoutine _loadwithSMIFRoutine;
+        private UnloadWithSMIFRoutine _unloadwithSMIFRoutine;
 
         private readonly SEMFPumpRoutine _pumpRoutine;
         private readonly SEMFVentRoutine _ventRoutine;
         public VceEntity(ModuleName moduleName)
         {
-        	currentSlot = 0;
+            currentSlot = 0;
             _modulename = moduleName;
             _vce = new HongHuVce(25, _modulename);
+            _smif = new FortrendPLUS500(_modulename);
 
-            _loadRoutine = new LoadRoutine(_modulename,_vce);
-            _prepareRoutine = new LoadPrepareRoutine(_modulename,_vce);
+            _loadRoutine = new LoadRoutine(_modulename, _vce);
+            _prepareRoutine = new LoadPrepareRoutine(_modulename, _vce);
             _unloadRoutine = new UnloadRoutine(_modulename, _vce);
+            _loadwithSMIFRoutine = new LoadWithSMIFRoutine(_modulename, _vce, _smif);
+            _unloadwithSMIFRoutine = new UnloadWithSMIFRoutine(_modulename, _vce, _smif);
+
             _pumpRoutine = new SEMFPumpRoutine(DEVICE.GetDevice<HongHuTM>("SETM"), _modulename);
             _ventRoutine = new SEMFVentRoutine(DEVICE.GetDevice<HongHuTM>("SETM"), _modulename);
             InitFsmMap();
@@ -93,18 +104,18 @@ namespace Venus_RT.Modules.VCE
             DATA.Subscribe($"{_modulename}.CurrentSlot", () => currentSlot);
 
             DATA.Subscribe($"{_modulename}.FsmState", () => ((VceSTATE)fsm.State).ToString());
-            //DATA.Subscribe($"{_modulename}.IsRunning", () => IsIdle);
+            DATA.Subscribe($"{_modulename}.CassetteArrive", () => CassetteArrive);
             //DATA.Subscribe($"{_modulename}.IsRunning", () => IsIdle);
 
-            OP.Subscribe($"{_modulename}.HOME", (cmd,args) => { PostMsg(VceMSG.Home);return true; });
-            OP.Subscribe($"{_modulename}.DoorOpen", (cmd,args) => { PostMsg(VceMSG.DoorOpen);return true; });
-            OP.Subscribe($"{_modulename}.DoorClose", (cmd,args) => { PostMsg(VceMSG.DoorClose);return true; });
-            OP.Subscribe($"{_modulename}.Map", (cmd,args) => { PostMsg(VceMSG.Map);return true; });
-            OP.Subscribe($"{_modulename}.ReadMap", (cmd,args) => { PostMsg(VceMSG.ReadMap);return true; });
-            OP.Subscribe($"{_modulename}.Load", (cmd,args) => { PostMsg(VceMSG.Load);return true; });
-            OP.Subscribe($"{_modulename}.UnLoad", (cmd,args) => { PostMsg(VceMSG.UnLoad);return true; });
-            OP.Subscribe($"{_modulename}.Reset", (cmd,args) => { PostMsg(VceMSG.Reset);return true; });
-            OP.Subscribe($"{_modulename}.Goto", (cmd,args) => { PostMsg(VceMSG.Goto, args[0]);return true; });
+            OP.Subscribe($"{_modulename}.HOME", (cmd, args) => { PostMsg(VceMSG.Home); return true; });
+            OP.Subscribe($"{_modulename}.DoorOpen", (cmd, args) => { PostMsg(VceMSG.DoorOpen); return true; });
+            OP.Subscribe($"{_modulename}.DoorClose", (cmd, args) => { PostMsg(VceMSG.DoorClose); return true; });
+            OP.Subscribe($"{_modulename}.Map", (cmd, args) => { PostMsg(VceMSG.Map); return true; });
+            OP.Subscribe($"{_modulename}.ReadMap", (cmd, args) => { PostMsg(VceMSG.ReadMap); return true; });
+            OP.Subscribe($"{_modulename}.Load", (cmd, args) => { PostMsg(VceMSG.Load); return true; });
+            OP.Subscribe($"{_modulename}.UnLoad", (cmd, args) => { PostMsg(VceMSG.UnLoad); return true; });
+            OP.Subscribe($"{_modulename}.Reset", (cmd, args) => { PostMsg(VceMSG.Reset); return true; });
+            OP.Subscribe($"{_modulename}.Goto", (cmd, args) => { PostMsg(VceMSG.Goto, args[0]); return true; });
             OP.Subscribe($"{_modulename}.GotoLP", (cmd, args) => { PostMsg(VceMSG.GotoLP); return true; });
             OP.Subscribe($"{_modulename}.Abort", (cmd, args) => { PostMsg(VceMSG.Abort); return true; });
             OP.Subscribe($"{_modulename}.PumpDown", (cmd, args) => { PostMsg(VceMSG.Pump); return true; });
@@ -114,6 +125,8 @@ namespace Venus_RT.Modules.VCE
             OP.Subscribe($"{_modulename}.LoadPrepare", (cmd, args) => { PostMsg(VceMSG.LoadPrepare); return true; });
             OP.Subscribe($"{_modulename}.SafeLoad", (cmd, args) => { PostMsg(VceMSG.SafeLoad); return true; });
             OP.Subscribe($"{_modulename}.SafeUnload", (cmd, args) => { PostMsg(VceMSG.SafeUnload); return true; });
+            OP.Subscribe($"{_modulename}.LoadWithSMIF", (cmd, args) => { PostMsg(VceMSG.LoadWithSMIF); return true; });
+            OP.Subscribe($"{_modulename}.UnLoadWithSMIF", (cmd, args) => { PostMsg(VceMSG.UnLoadWithSMIF); return true; });
 
             return true;
         }
@@ -130,65 +143,71 @@ namespace Venus_RT.Modules.VCE
             AnyStateTransition(VceMSG.Abort, fnAbort, VceSTATE.Idle);
             AnyStateTransition(VceMSG.Home, fnStartHome, VceSTATE.Homing);
             //HOME init->homing idle->homing
-            Transition(VceSTATE.Init, VceMSG.Home, fnStartHome, VceSTATE.Homing);
-            Transition(VceSTATE.Idle, VceMSG.Home, fnStartHome, VceSTATE.Homing);
-            Transition(VceSTATE.Error, VceMSG.Home, fnStartHome, VceSTATE.Homing);
-            Transition(VceSTATE.Homing, FSM_MSG.TIMER, fnHomeTimeout, VceSTATE.Idle);
+            Transition(VceSTATE.Init,               VceMSG.Home,            fnStartHome,            VceSTATE.Homing);
+            Transition(VceSTATE.Idle,               VceMSG.Home,            fnStartHome,            VceSTATE.Homing);
+            Transition(VceSTATE.Error,              VceMSG.Home,            fnStartHome,            VceSTATE.Homing);
+            Transition(VceSTATE.Homing,             FSM_MSG.TIMER,          fnHomeTimeout,          VceSTATE.Idle);
 
             //Open Door 开门
-            Transition(VceSTATE.Idle, VceMSG.DoorOpen, fnStartOpenDoor, VceSTATE.DoorOpenning);
-            Transition(VceSTATE.DoorOpenning, FSM_MSG.TIMER, fnOpenDoorTimeout, VceSTATE.Idle);
+            Transition(VceSTATE.Idle,               VceMSG.DoorOpen,        fnStartOpenDoor,        VceSTATE.DoorOpenning);
+            Transition(VceSTATE.DoorOpenning,       FSM_MSG.TIMER,          fnOpenDoorTimeout,      VceSTATE.Idle);
             //Close Door 关门
-            Transition(VceSTATE.Idle, VceMSG.DoorClose, fnStartCloseDoor, VceSTATE.DoorClosing);
-            Transition(VceSTATE.DoorClosing, FSM_MSG.TIMER, fnCloseDoorTimeout, VceSTATE.Idle);
+            Transition(VceSTATE.Idle,               VceMSG.DoorClose,       fnStartCloseDoor,       VceSTATE.DoorClosing);
+            Transition(VceSTATE.DoorClosing,        FSM_MSG.TIMER,          fnCloseDoorTimeout,     VceSTATE.Idle);
 
             //Map 扫片
-            Transition(VceSTATE.Idle, VceMSG.Map, fnStartMapping, VceSTATE.Mapping);
-            Transition(VceSTATE.Mapping, FSM_MSG.TIMER, fnMappingTimeout, VceSTATE.Idle);
+            Transition(VceSTATE.Idle,               VceMSG.Map,             fnStartMapping,         VceSTATE.Mapping);
+            Transition(VceSTATE.Mapping,            FSM_MSG.TIMER,          fnMappingTimeout,       VceSTATE.Idle);
 
             //Load 取cassette
-            Transition(VceSTATE.Idle, VceMSG.Load, fnStartLoading, VceSTATE.Loading);
-            Transition(VceSTATE.Loading, FSM_MSG.TIMER, fnLoadingTimeout, VceSTATE.Idle);
+            Transition(VceSTATE.Idle,               VceMSG.Load,            fnStartLoading,         VceSTATE.Loading);
+            Transition(VceSTATE.Loading,            FSM_MSG.TIMER,          fnLoadingTimeout,       VceSTATE.Idle);
 
             //UnLoad 放cassette
-            Transition(VceSTATE.Idle, VceMSG.UnLoad, fnStartUnLoading, VceSTATE.UnLoading);
-            Transition(VceSTATE.UnLoading, FSM_MSG.TIMER, fnUnLoadingTimeout, VceSTATE.Idle);
+            Transition(VceSTATE.Idle,               VceMSG.UnLoad,          fnStartUnLoading,       VceSTATE.UnLoading);
+            Transition(VceSTATE.UnLoading,          FSM_MSG.TIMER,          fnUnLoadingTimeout,     VceSTATE.Idle);
 
             //Goto 指定槽对准窗口
-            Transition(VceSTATE.Idle, VceMSG.Goto, fnStartGoto, VceSTATE.Goting);
-            Transition(VceSTATE.Goting, FSM_MSG.TIMER, fnGotingTimeout, VceSTATE.Idle);
+            Transition(VceSTATE.Idle,               VceMSG.Goto,            fnStartGoto,            VceSTATE.Goting);
+            Transition(VceSTATE.Goting,             FSM_MSG.TIMER,          fnGotingTimeout,        VceSTATE.Idle);
 
             //ReadMap
-            Transition(VceSTATE.Idle, VceMSG.ReadMap, fnStartReadingMap, VceSTATE.ReadingMap);
-            Transition(VceSTATE.ReadingMap, FSM_MSG.TIMER, fnReadingMapTimeout, VceSTATE.Idle);
+            Transition(VceSTATE.Idle,               VceMSG.ReadMap,         fnStartReadingMap,      VceSTATE.ReadingMap);
+            Transition(VceSTATE.ReadingMap,         FSM_MSG.TIMER,          fnReadingMapTimeout,    VceSTATE.Idle);
 
             //Load Prepare
-            Transition(VceSTATE.Idle, VceMSG.LoadPrepare,fnStartLoadPrepare,VceSTATE.LoadPreparing) ;
-            Transition(VceSTATE.LoadPreparing, FSM_MSG.TIMER, fnLoadingPrepareTimeout,VceSTATE.Idle) ;
+            Transition(VceSTATE.Idle,               VceMSG.LoadPrepare,     fnStartLoadPrepare,     VceSTATE.LoadPreparing);
+            Transition(VceSTATE.LoadPreparing,      FSM_MSG.TIMER,          fnLoadingPrepareTimeout,VceSTATE.Idle);
 
             //Safe Load
-            Transition(VceSTATE.Idle,VceMSG.SafeLoad,fnStartSafeLoad,VceSTATE.SafeLoading) ;
-            Transition(VceSTATE.SafeLoading, FSM_MSG.TIMER,fnSafeLoadTimeout,VceSTATE.Idle);
+            Transition(VceSTATE.Idle,               VceMSG.SafeLoad,        fnStartSafeLoad,        VceSTATE.SafeLoading);
+            Transition(VceSTATE.SafeLoading,        FSM_MSG.TIMER,          fnSafeLoadTimeout,      VceSTATE.Idle);
+
+            //LoadWithSMIF => LoadPrepare & SMIF Load & Load
+            Transition(VceSTATE.Idle,               VceMSG.LoadWithSMIF,    fnStartLoadWithSMIF,    VceSTATE.LoadingWithSMIF);
+            Transition(VceSTATE.LoadingWithSMIF,    FSM_MSG.TIMER,          fnLoadWithSMIFTimeout,  VceSTATE.Idle);
 
             //Safe UnLoad
-            Transition(VceSTATE.Idle, VceMSG.SafeUnload, fnStartSafeUnLoad, VceSTATE.SafeUnloading);
-            Transition(VceSTATE.SafeUnloading, FSM_MSG.TIMER, fnSafeUnLoadTimeout, VceSTATE.Idle);
+            Transition(VceSTATE.Idle,               VceMSG.SafeUnload,      fnStartSafeUnLoad,      VceSTATE.SafeUnloading);
+            Transition(VceSTATE.SafeUnloading,      FSM_MSG.TIMER,          fnSafeUnLoadTimeout,    VceSTATE.Idle);
 
-            //Goto LP
-            Transition(VceSTATE.Idle, VceMSG.GotoLP, fnStartGotoLP, VceSTATE.GotingLP);
-            Transition(VceSTATE.GotingLP, FSM_MSG.TIMER, fnGotoLPTimeout, VceSTATE.Idle);
+            //UnLoad With SMIF => UnLoad with smif
+            Transition(VceSTATE.Idle,               VceMSG.UnLoadWithSMIF,  fnStartUnLoadWithSMIF,  VceSTATE.UnLoadingWithSMIF);
+            Transition(VceSTATE.UnLoadingWithSMIF,  FSM_MSG.TIMER,          fnUnLoadWithSMIFTimeout,VceSTATE.Idle);
 
-            //Pump down
+            //Goto LP
+            Transition(VceSTATE.Idle,               VceMSG.GotoLP,          fnStartGotoLP,          VceSTATE.GotingLP);
+            Transition(VceSTATE.GotingLP,           FSM_MSG.TIMER,          fnGotoLPTimeout,        VceSTATE.Idle);
 
             //Pump
-            Transition(VceSTATE.Idle, VceMSG.Pump, fnStartPump, VceSTATE.Pumping);
-            Transition(VceSTATE.Pumping, FSM_MSG.TIMER, fnPumpTimeout, VceSTATE.Idle);
-            Transition(VceSTATE.Pumping, VceMSG.Abort, fnAbortPump, VceSTATE.Idle);
+            Transition(VceSTATE.Idle,               VceMSG.Pump,            fnStartPump,            VceSTATE.Pumping);
+            Transition(VceSTATE.Pumping,            FSM_MSG.TIMER,          fnPumpTimeout,          VceSTATE.Idle);
+            Transition(VceSTATE.Pumping,            VceMSG.Abort,           fnAbortPump,            VceSTATE.Idle);
 
             //Vent
-            Transition(VceSTATE.Idle, VceMSG.Vent, fnStartVent, VceSTATE.Venting);
-            Transition(VceSTATE.Venting, FSM_MSG.TIMER, fnVentTimeout, VceSTATE.Idle);
-            Transition(VceSTATE.Venting, VceMSG.Abort, fnAbortVent, VceSTATE.Idle);
+            Transition(VceSTATE.Idle,               VceMSG.Vent,            fnStartVent,            VceSTATE.Venting);
+            Transition(VceSTATE.Venting,            FSM_MSG.TIMER,          fnVentTimeout,          VceSTATE.Idle);
+            Transition(VceSTATE.Venting,            VceMSG.Abort,           fnAbortVent,            VceSTATE.Idle);
 
             EnumLoop<VceSTATE>.ForEach((item) => { fsm.MapState((int)item, item.ToString()); });
 
@@ -257,7 +276,7 @@ namespace Venus_RT.Modules.VCE
 
         private bool fnStartGotoLP(object[] param)
         {
-         	if (_vce.GotoLP())
+            if (_vce.GotoLP())
             {
                 targetSlot = -1;
                 return true;
@@ -275,6 +294,13 @@ namespace Venus_RT.Modules.VCE
                 PostMsg(VceMSG.Error);
                 return false;
             }
+
+            if (ret == RState.End)
+            {
+                _CassetteArrive = false;
+                WaferManager.Instance.DeleteWafer(_modulename, 0, 25);
+            }
+
             return ret == RState.End;
         }
 
@@ -291,6 +317,55 @@ namespace Venus_RT.Modules.VCE
                 PostMsg(VceMSG.Error);
                 return false;
             }
+            if (ret == RState.End)
+            {
+                _CassetteArrive = true;
+            }
+
+            return ret == RState.End;
+        }
+
+        private bool fnStartLoadWithSMIF(object[] param)
+        {
+            return _loadwithSMIFRoutine.Start(param) == RState.Running;
+        }
+
+        private bool fnLoadWithSMIFTimeout(object[] param)
+        {
+            RState ret = _loadwithSMIFRoutine.Monitor();
+            if (ret == RState.Timeout || ret == RState.Failed)
+            {
+                PostMsg(VceMSG.Error);
+                return false;
+            }
+
+            if (ret == RState.End)
+            {
+                _CassetteArrive = true;
+            }
+
+            return ret == RState.End;
+        }
+
+        private bool fnStartUnLoadWithSMIF(object[] param)
+        {
+            return _unloadwithSMIFRoutine.Start(param) == RState.Running;
+        }
+
+        private bool fnUnLoadWithSMIFTimeout(object[] param)
+        {
+            RState ret = _unloadwithSMIFRoutine.Monitor();
+            if (ret == RState.Timeout || ret == RState.Failed)
+            {
+                PostMsg(VceMSG.Error);
+                return false;
+            }
+
+            if (ret == RState.End)
+            {
+                _CassetteArrive = false;
+                WaferManager.Instance.DeleteWafer(_modulename, 0, 25);
+            }
             return ret == RState.End;
         }
 

Venus/Venus_RT/Venus_RT.csproj

@@ -178,6 +178,7 @@
     <Compile Include="Devices\SkyPump.cs" />
     <Compile Include="Devices\SMCChiller.cs" />
     <Compile Include="Devices\SMIF\FortrendPLUS500.cs" />
+    <Compile Include="Devices\SMIF\ISMIF.cs" />
     <Compile Include="Modules\SMIF\SMIFEntity.cs" />
     <Compile Include="Devices\TM\HongHuTM.cs" />
     <Compile Include="Devices\TM\ITransferRobot.cs" />
@@ -296,7 +297,9 @@
     <Compile Include="Modules\TM\VenusEntity\SETMEntity.cs" />
     <Compile Include="Modules\VCE\LoadPrepareRoutine.cs" />
     <Compile Include="Modules\VCE\LoadRoutine.cs" />
+    <Compile Include="Modules\VCE\LoadWithSMIFRoutine.cs" />
     <Compile Include="Modules\VCE\UnloadRoutine.cs" />
+    <Compile Include="Modules\VCE\UnloadWithSMIFRoutine.cs" />
     <Compile Include="Modules\VCE\VceEntity.cs" />
     <Compile Include="Properties\AssemblyInfo.cs">
       <SubType>Code</SubType>

Venus/Venus_Simulator/Devices/SETMSimulatorServer.cs

@@ -12,10 +12,10 @@ namespace Venus_Simulator.Devices
 {
     public class SETMSimulatorServer : SocketDeviceSimulator
     {
-        private readonly Regex _check_load = new Regex(@"CHECK LOAD\s*");
-        //private readonly Regex _check_load = new Regex(@"CHECK LOAD\s+(\d+)\s+ARM\s+(A|B)\s*");
-        private readonly Regex _move_arm = new Regex(@"(PLACE|PICK)\s+(\d+)\s*");
-        private readonly Regex _move_wafer = new Regex(@"(PLACE|PICK)\s+(\d+)\s*");
+
+        private readonly Regex _check_load = new Regex(@"CHECK LOAD\s+(\d+)\s+ARM\s+(A|B)\s*");
+        private readonly Regex _move_arm = new Regex(@"(PLACE|PICK)\s+(\d+)\s+ARM\s+(A|B)\s+(\w{4})\s*");
+        private readonly Regex _move_wafer = new Regex(@"(PLACE|PICK)\s+(\d+)\s+ARM\s+(A|B)\s*");
 
         private PeriodicJob _HwThread;
         public SETMSimulatorServer() : base(1103, -1, "\r", ' ')

Venus/Venus_Themes/UserControls/TMChamber.xaml

@@ -57,8 +57,8 @@
 
 
             <Canvas Width="200" Height="200" Grid.Row="1">
-                <Border Canvas.Top="-54" Canvas.Left="-5" Height="44" Width="270" Background="Transparent" BorderBrush="Black" CornerRadius="3" BorderThickness="3" Visibility="{Binding ElementName=tmChamber,Path=IsVenting,Converter={StaticResource bool2VisibilityConverter}}">
-                    <Border Background="Transparent" BorderBrush="Gray" CornerRadius="1" BorderThickness="1">
+                <Border Canvas.Top="-54" Canvas.Left="-9" Height="44" Width="277" Background="Transparent" BorderBrush="Gainsboro" BorderThickness="0,0,3,3" CornerRadius="3" Visibility="{Binding ElementName=tmChamber,Path=IsVenting,Converter={StaticResource bool2VisibilityConverter}}">
+                    <Border Background="Transparent" CornerRadius="1"  BorderBrush="Black" BorderThickness="3,3,0,0">
                         <StackPanel Margin="-160,0,0,0" Height="44">
 
                             <StackPanel   Width="49" Margin="-40 0 45 10">
@@ -68,7 +68,7 @@
                                 <!--矩形-->
                                 <Rectangle x:Name="rec_Water"  Fill="#42a5f5" Height="{Binding ElementName=tmChamber,Path=PercentValue,Mode=TwoWay,UpdateSourceTrigger=PropertyChanged}" Width="50" Margin="-20,6,0,0"/>
                                 <!--水波-->
-                                <Path Fill="#42a5f5" Margin="0,0,0,-1" Height="20" Stretch="Fill">
+                                <Path Fill="#42a5f5" Margin="0,-16,0,0" Height="10" Stretch="Fill">
                                     <Path.RenderTransform>
                                         <RotateTransform Angle="180" CenterX="19.5" CenterY="10"></RotateTransform>
                                     </Path.RenderTransform>

Venus/Venus_Themes/UserControls/Vce.xaml

@@ -48,8 +48,9 @@
                     </ContextMenu>
                 </Rectangle.ContextMenu>
             </Rectangle>-->
-            <Border Canvas.Bottom="0" Canvas.Left="10" HorizontalAlignment="Center" Width="180">
-                <Rectangle Fill="#fac090"  Width="180" Height="10" >
+            <Canvas>
+                <Border Canvas.Bottom="-120" Canvas.Left="10" HorizontalAlignment="Center" Width="180">
+                <Rectangle Fill="#fac090"  Width="180" Height="10">
                     <Rectangle.Style>
                         <Style TargetType="Rectangle">
                             <Style.Triggers>
@@ -74,38 +75,38 @@
                     </Rectangle.Style>
                 </Rectangle>
             </Border>
-            <Border Canvas.Top="129" Canvas.Left="-5" Height="44" Width="270" Background="Transparent" BorderBrush="Black" CornerRadius="3" BorderThickness="3" Visibility="{Binding ElementName=vceChamber,Path=IsVenting,Converter={StaticResource bool2VisibilityConverter}}">
+                
+                <Border Canvas.Top="129" Canvas.Left="-5" Height="44" Width="270" Background="Transparent" BorderBrush="Gainsboro" BorderThickness="0,0,3,3" CornerRadius="3" Visibility="{Binding ElementName=vceChamber,Path=IsVenting,Converter={StaticResource bool2VisibilityConverter}}">
                 <Border.RenderTransform>
                     <ScaleTransform ScaleX="0.77" ScaleY="0.58"></ScaleTransform>
                 </Border.RenderTransform>
-                <Border Background="Transparent" BorderBrush="Gray" CornerRadius="1" BorderThickness="1">
-                        <StackPanel Margin="-160,0,0,0" Height="44">
+                    <Border Background="Transparent" CornerRadius="1" BorderBrush="Black" BorderThickness="3,3,0,0">
+                    <StackPanel Margin="-160,0,0,0" Height="44">
 
-                            <StackPanel   Width="49" Margin="-40 0 45 10">
-                                <StackPanel.RenderTransform>
-                                    <RotateTransform Angle="-90" CenterX="19.5" CenterY="10"></RotateTransform>
-                                </StackPanel.RenderTransform>
-                                <!--矩形-->
+                        <StackPanel   Width="49" Margin="-40 0 45 10">
+                            <StackPanel.RenderTransform>
+                                <RotateTransform Angle="-90" CenterX="19.5" CenterY="10"></RotateTransform>
+                            </StackPanel.RenderTransform>
+                            <!--矩形-->
                             <Rectangle x:Name="rec_Water"  Fill="#42a5f5" Height="{Binding ElementName=vceChamber,Path=PercentValue,Mode=TwoWay,UpdateSourceTrigger=PropertyChanged}" Width="50" Margin="-20,6,0,0"/>
-                                <!--水波-->
-                                <Path Fill="#42a5f5" Margin="0,0,0,-1" Height="20" Stretch="Fill">
-                                    <Path.RenderTransform>
-                                        <RotateTransform Angle="180" CenterX="19.5" CenterY="10"></RotateTransform>
-                                    </Path.RenderTransform>
-                                    <Path.Data>
-                                        <PathGeometry>
-                                            <PathFigure StartPoint="0,0">
-                                                <BezierSegment x:Name="bs_Water" Point1="15,-5" Point2="35,5"  Point3="50,0"></BezierSegment>
-                                                <PolyLineSegment Points="50,10 0,10"></PolyLineSegment>
-                                            </PathFigure>
-                                        </PathGeometry>
-                                    </Path.Data>
-                                </Path>
-                            </StackPanel>
+                            <!--水波-->
+                            <Path Fill="#42a5f5" Margin="0,-16,0,0" Height="10" Stretch="Fill">
+                                <Path.RenderTransform>
+                                    <RotateTransform Angle="180" CenterX="19.5" CenterY="10"></RotateTransform>
+                                </Path.RenderTransform>
+                                <Path.Data>
+                                    <PathGeometry>
+                                        <PathFigure StartPoint="0,0">
+                                            <BezierSegment x:Name="bs_Water" Point1="15,-5" Point2="35,5"  Point3="50,0"></BezierSegment>
+                                            <PolyLineSegment Points="50,10 0,10"></PolyLineSegment>
+                                        </PathFigure>
+                                    </PathGeometry>
+                                </Path.Data>
+                            </Path>
                         </StackPanel>
-                    </Border>
+                    </StackPanel>
                 </Border>
-                
+            </Border>
             <StackPanel Width="200" Canvas.Top="130" HorizontalAlignment="Center" VerticalAlignment="Center">
                 <TextBlock Canvas.Top="130" Canvas.Left="90" TextAlignment="Center" FontSize="20" FontWeight="Normal">
                     <TextBlock.Text>
@@ -116,6 +117,10 @@
                     </TextBlock.Text>
                 </TextBlock>
             </StackPanel>
+            </Canvas>
+
+
+            <Image Width="100"  Canvas.Left="50" Canvas.Top="10" Source="pack://application:,,,/Venus_Themes;component/Resources/cassette.png"  Opacity="0.8"  Visibility="{Binding ElementName=vceChamber,Path=CassetteArrive,Mode=TwoWay,UpdateSourceTrigger=PropertyChanged,Converter={StaticResource bool2VisibilityConverter}}" ></Image>
         </Canvas>
     </Viewbox>
 </UserControl>

Venus/Venus_Themes/UserControls/Vce.xaml.cs

@@ -82,5 +82,13 @@ namespace Venus_Themes.UserControls
             }
         }
 
+        public static readonly DependencyProperty CassetteArriveProperty = DependencyProperty.Register(
+        "CassetteArrive", typeof(bool), typeof(Vce));
+        public bool CassetteArrive
+        {
+            get { return (bool)this.GetValue(CassetteArriveProperty); }
+            set { this.SetValue(CassetteArriveProperty, value); }
+        }
+
     }
 }

Venus/Venus_Themes/UserControls/VceControl.xaml.cs

@@ -135,34 +135,34 @@ namespace Venus_Themes.UserControls
         {
             if (d is VceControl vceControl)
             {
-                if (Convert.ToInt32(e.NewValue) >= 0 && Convert.ToInt32(e.OldValue) >= 0)
-                {
-                    VceWaferNames[(int)e.NewValue].Source = new BitmapImage(new Uri(@"pack://application:,,,/Venus_Themes;component/Themes/Images/parts/vce/WaferSelected.png", UriKind.RelativeOrAbsolute));
-                    VceWaferNames[(int)e.OldValue].Source = new BitmapImage(new Uri(@"pack://application:,,,/Venus_Themes;component/Themes/Images/parts/vce/Wafer.png", UriKind.RelativeOrAbsolute));
-                    DoubleAnimation floatY = new DoubleAnimation(
-                    430 - 7 * (25 - (int)e.NewValue),
-                    TimeSpan.FromSeconds(3)
-                    );
-                    vceControl.Foup.BeginAnimation(Canvas.TopProperty, floatY);
-                }
-                else if (Convert.ToInt32(e.NewValue) >= 0 && Convert.ToInt32(e.OldValue) < 0)
-                {
-                    VceWaferNames[(int)e.NewValue].Source = new BitmapImage(new Uri(@"pack://application:,,,/Venus_Themes;component/Themes/Images/parts/vce/WaferSelected.png", UriKind.RelativeOrAbsolute));
-                    DoubleAnimation floatY = new DoubleAnimation(
-                        430 - 7 * (25 - (int)e.NewValue),
-                        TimeSpan.FromSeconds(3)
-                        );
-                    vceControl.Foup.BeginAnimation(Canvas.TopProperty, floatY);
-                }
-                else if (Convert.ToInt32(e.NewValue) < 0 && Convert.ToInt32(e.OldValue) > 0)
-                {
-                    VceWaferNames[(int)e.OldValue].Source = new BitmapImage(new Uri(@"pack://application:,,,/Venus_Themes;component/Themes/Images/parts/vce/Wafer.png", UriKind.RelativeOrAbsolute));
-                    DoubleAnimation floatY = new DoubleAnimation(
-                        430,
-                        TimeSpan.FromSeconds(3)
-                    );
-                    vceControl.Foup.BeginAnimation(Canvas.TopProperty, floatY);
-                }
+                //if (Convert.ToInt32(e.NewValue) >= 0 && Convert.ToInt32(e.OldValue) >= 0)
+                //{
+                //    VceWaferNames[(int)e.NewValue].Source = new BitmapImage(new Uri(@"pack://application:,,,/Venus_Themes;component/Themes/Images/parts/vce/WaferSelected.png", UriKind.RelativeOrAbsolute));
+                //    VceWaferNames[(int)e.OldValue].Source = new BitmapImage(new Uri(@"pack://application:,,,/Venus_Themes;component/Themes/Images/parts/vce/Wafer.png", UriKind.RelativeOrAbsolute));
+                //    DoubleAnimation floatY = new DoubleAnimation(
+                //    430 - 7 * (25 - (int)e.NewValue),
+                //    TimeSpan.FromSeconds(3)
+                //    );
+                //    vceControl.Foup.BeginAnimation(Canvas.TopProperty, floatY);
+                //}
+                //else if (Convert.ToInt32(e.NewValue) >= 0 && Convert.ToInt32(e.OldValue) < 0)
+                //{
+                //    VceWaferNames[(int)e.NewValue].Source = new BitmapImage(new Uri(@"pack://application:,,,/Venus_Themes;component/Themes/Images/parts/vce/WaferSelected.png", UriKind.RelativeOrAbsolute));
+                //    DoubleAnimation floatY = new DoubleAnimation(
+                //        430 - 7 * (25 - (int)e.NewValue),
+                //        TimeSpan.FromSeconds(3)
+                //        );
+                //    vceControl.Foup.BeginAnimation(Canvas.TopProperty, floatY);
+                //}
+                //else if (Convert.ToInt32(e.NewValue) < 0 && Convert.ToInt32(e.OldValue) > 0)
+                //{
+                //    VceWaferNames[(int)e.OldValue].Source = new BitmapImage(new Uri(@"pack://application:,,,/Venus_Themes;component/Themes/Images/parts/vce/Wafer.png", UriKind.RelativeOrAbsolute));
+                //    DoubleAnimation floatY = new DoubleAnimation(
+                //        430,
+                //        TimeSpan.FromSeconds(3)
+                //    );
+                //    vceControl.Foup.BeginAnimation(Canvas.TopProperty, floatY);
+                //}
             }
         }
         private Image CreateImage(string ImagePath, int ImageHeight)

Venus/Venus_Themes/Venus_Themes.csproj

@@ -486,6 +486,7 @@
     <Resource Include="Resources\foup2.png">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
     </Resource>
+    <Resource Include="Resources\cassette.png" />
     <Content Include="Styles\Folder_Close.png" />
     <Content Include="Styles\Folder_Open.png" />
     <Content Include="Styles\Folder_Unable.png" />

Venus/Venus_UI/Config/UIMenu.json

@@ -1,34 +1,47 @@
 [
-
   {
-    "Id": "Operation",
-    "Name": "Operation",
+
+    "Id": "SETM",
+    "Name": "SETM",
     "IsShow": "true",
 
     "MenuItem": [
       {
-        "Id": "OperationOverView",
-        "IsShow": "true",
-        "Name": "OverView",
-        "View": "OperationOverView"
+        "Id": "IO",
+        "Name": "IO",
+        "View": "IOView",
+        "IsShow": "true"
       },
       {
-        "Id": "Platform",
-        "IsShow": "false",
-        "Name": "Platform",
-        "View": "PlatformView"
+        "Id": "SEOperation",
+        "IsShow": "true",
+        "Name": "SE Operation",
+        "View": "VenusSeOperationOverView"
       },
       {
-        "Id": "Sequence",
+        "Id": "seSequenceView",
         "IsShow": "true",
         "Name": "Sequence",
         "View": "SequenceView"
       },
       {
-        "Id": "Fa",
+        "Id": "SETMView",
+        "IsShow": "true",
+        "Name": "SE TM",
+        "View": "SETMOperationView"
+      },
+      {
+
+        "Id": "SETMTransfer",
+        "IsShow": "true",
+        "Name": "TM Transfer",
+        "View": "SeTMView"
+      },
+      {
+        "Id": "VceView",
         "IsShow": "true",
-        "Name": "FA",
-        "View": "FaView"
+        "Name": "VCE",
+        "View": "VceView"
       }
     ]
   },
@@ -94,7 +107,7 @@
         "Id": "CleanRecipe",
         "Name": "Idle Clean",
         "View": "CleanRecipeView",
-        "IsShow": "false"
+        "IsShow": "true"
       }
 
     ]
@@ -162,7 +175,7 @@
         "Id": "CleanRecipe",
         "Name": "Idle Clean",
         "View": "CleanRecipeView",
-        "IsShow": "false"
+        "IsShow": "true"
       }
 
     ]
@@ -224,7 +237,7 @@
         "Id": "CleanRecipe",
         "Name": "Idle Clean",
         "View": "CleanRecipeView",
-        "IsShow": "false"
+        "IsShow": "true"
       }
 
     ]
@@ -288,48 +301,10 @@
         "Id": "CleanRecipe",
         "Name": "Idle Clean",
         "View": "CleanRecipeView",
-        "IsShow": "false"
-      }
-
-    ]
-  },
-  {
-    "Id": "TM",
-    "Name": "Transfer",
-    "IsShow": "true",
-    "MenuItem": [
-      {
-        "Id": "Efem",
-        "IsShow": "true",
-        "Name": "EFEM",
-        "View": "EfemView"
-      },
-      {
-        "Id": "TMOperation",
-        "IsShow": "true",
-        "Name": "TM Operation",
-        "View": "TMOperationView"
-      },
-      {
-        "Id": "TMTransfer",
-        "IsShow": "true",
-        "Name": "TM Transfer",
-        "View": "TMView"
-      },
-      {
-        "Id": "IO",
-        "Name": "TM IO",
-        "View": "IOView",
         "IsShow": "true"
-      },
-      {
-        "Id": "WaferOffset",
-        "IsShow": "true",
-        "Name": "Wafer Offset",
-        "View": "WaferOffsetView"
       }
-    ]
 
+    ]
   },
   {
     "Id": "Configuration",