update wafer scheduler

PunkHPX8_Core/RtState.cs

@@ -147,7 +147,9 @@ namespace PunkHPX8_Core
         RunReciping,
         ManualReciping,
         CycleManualProcessing,
-        Aborting
+        Aborting,
+        ChamberDowning,
+        ChamberUping
     }
     public enum ReservoirState
     {

PunkHPX8_RT/Modules/VpwCell/VpwCellEntity.cs

@@ -34,13 +34,6 @@ namespace PunkHPX8_RT.Modules.VpwMain
 {
     public class VpwCellEntity : Entity, IEntity, IModuleEntity
     {
-
-        public enum MSG
-        {
-            Home
-        }
-
-
         #region 常量
         private const string STRATUS = "Stratus";
         private const string AUTO = "Auto";
@@ -73,6 +66,14 @@ namespace PunkHPX8_RT.Modules.VpwMain
         /// </summary>
         private VpwRecipeRoutine _recipeRoutine;
         /// <summary>
+        /// Chamber down
+        /// </summary>
+        private VpwChamberDownRoutine _chamberDownRoutine;
+        /// <summary>
+        /// Chamber Up
+        /// </summary>
+        private VpwChamberUpRoutine _chamberUpRoutine;
+        /// <summary>
         /// 循环routine
         /// </summary>
         private VpwCycleManualProcessRecipeRoutine _cycleManualProcessRoutine;
@@ -174,15 +175,6 @@ namespace PunkHPX8_RT.Modules.VpwMain
         /// </summary>
         public int RecipeTime { get { return _recipeTime; } }
         /// <summary>
-        /// 是否在做recipe
-        /// </summary>
-        public bool IsInReceiping
-        {
-            get { return fsm.State == (int)VPWCellState.RunReciping ||
-                        fsm.State == (int)VPWCellState.ManualReciping ||
-                         fsm.State == (int)VPWCellState.CycleManualProcessing;}
-        }
-        /// <summary>
         /// 当前Vpw设置的WaferSize
         /// </summary>
         public int VpwWaferSize { get { return _persistentValue.VpwCellWaferSize; } }
@@ -208,7 +200,7 @@ namespace PunkHPX8_RT.Modules.VpwMain
         /// <param name="module"></param>
         public VpwCellEntity(ModuleName module)
         {
-            this.Module = module;
+            Module = module;
         }
         /// <summary>
         /// 初始化
@@ -278,7 +270,12 @@ namespace PunkHPX8_RT.Modules.VpwMain
             Transition(VPWCellState.Preparing, FSM_MSG.TIMER, PrepareMonitor, VPWCellState.WaitForRunRecipe);
             Transition(VPWCellState.WaitForRunRecipe, VPWCellMsg.RunRecipe, RunRecipe, VPWCellState.RunReciping);
             Transition(VPWCellState.RunReciping, FSM_MSG.TIMER, RunRecipeMonitor, VPWCellState.Idle);
-
+            //ChamberUp
+            Transition(VPWCellState.Idle, VPWCellMsg.ChamberUp, ChamberUp, VPWCellState.ChamberUping);
+            Transition(VPWCellState.ChamberUping, FSM_MSG.TIMER, ChamberUpMonitor, VPWCellState.Idle);
+            //ChamberDown
+            Transition(VPWCellState.Idle, VPWCellMsg.ChamberDown, ChamberDown, VPWCellState.ChamberDowning);
+            Transition(VPWCellState.ChamberDowning, FSM_MSG.TIMER, ChamberDownMonitor, VPWCellState.Idle);
             //Retry
             Transition(VPWCellState.Error, VPWCellMsg.Retry, NullFunc, VPWCellState.Retrying);
             Transition(VPWCellState.Retrying, FSM_MSG.TIMER, VpwCellRetry, VPWCellState.Retrying);
@@ -321,6 +318,8 @@ namespace PunkHPX8_RT.Modules.VpwMain
             _homeRoutine = new VPWHomeRoutine(Module.ToString());
             _prepareRoutine=new VpwPrepareRoutine(Module.ToString());
             _recipeRoutine=new VpwRecipeRoutine(Module.ToString());
+            _chamberDownRoutine=new VpwChamberDownRoutine(Module.ToString());
+            _chamberUpRoutine=new VpwChamberUpRoutine(Module.ToString());   
             _cycleManualProcessRoutine = new VpwCycleManualProcessRecipeRoutine(Module.ToString());
         }
         /// <summary>
@@ -499,7 +498,6 @@ namespace PunkHPX8_RT.Modules.VpwMain
         }
         #endregion
 
-
         #region cycle manual process
         private bool CycleManualProcess(object[] param)
         {
@@ -595,6 +593,60 @@ namespace PunkHPX8_RT.Modules.VpwMain
         }
         #endregion
 
+        #region ChamberUp
+        /// <summary>
+        /// Chamber Up
+        /// </summary>
+        /// <param name="param"></param>
+        /// <returns></returns>
+        private bool ChamberUp(object[] param)
+        {
+            return _chamberUpRoutine.Start(param) == RState.Running;
+        }
+        /// <summary>
+        /// ChamberUp Monitor
+        /// </summary>
+        /// <param name="param"></param>
+        /// <returns></returns>
+        private bool ChamberUpMonitor(object[] param)
+        {
+            RState state = _chamberUpRoutine.Monitor();
+            if (state == RState.Failed || state == RState.Timeout)
+            {
+                PostMsg(VPWCellMsg.Error);
+                return false;
+            }
+            return state == RState.End;
+        }
+        #endregion
+
+        #region ChamberDown
+        /// <summary>
+        /// Chamber Down
+        /// </summary>
+        /// <param name="param"></param>
+        /// <returns></returns>
+        private bool ChamberDown(object[] param)
+        {
+            return _chamberDownRoutine.Start(param) == RState.Running;
+        }
+        /// <summary>
+        /// ChamberUp Monitor
+        /// </summary>
+        /// <param name="param"></param>
+        /// <returns></returns>
+        private bool ChamberDownMonitor(object[] param)
+        {
+            RState state = _chamberDownRoutine.Monitor();
+            if (state == RState.Failed || state == RState.Timeout)
+            {
+                PostMsg(VPWCellMsg.Error);
+                return false;
+            }
+            return state == RState.End;
+        }
+        #endregion
+
         public bool Check(int msg, out string reason, params object[] args)
         {
             reason = "";

PunkHPX8_RT/Modules/VpwCell/VpwCellMsg.cs

@@ -19,6 +19,8 @@ namespace PunkHPX8_RT.Modules.VpwCell
         Retry,
         ManualRecipe,
         RunRecipe,
-        CycleProcessRecipe
+        CycleProcessRecipe,
+        ChamberUp,
+        ChamberDown
     }
 }

PunkHPX8_RT/Modules/VpwCell/VpwChamberDownRoutine.cs

@@ -0,0 +1,118 @@
+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.Common.RecipeCenter;
+using MECF.Framework.Common.Routine;
+using MECF.Framework.Common.SubstrateTrackings;
+using PunkHPX8_Core;
+using PunkHPX8_RT.Devices.AXIS;
+using PunkHPX8_RT.Devices.VpwCell;
+using PunkHPX8_RT.Devices.VpwMain;
+using PunkHPX8_RT.Modules.VpwMain;
+using PunkHPX8_RT.Schedulers;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace PunkHPX8_RT.Modules.VpwCell
+{
+    public class VpwChamberDownRoutine : RoutineBase, IRoutine
+    {
+        private enum PrepareStep
+        {
+            CheckPreCondition,
+            ChamerDown,
+            Delay,
+            End
+        }
+        #region 内部变量
+        /// <summary>
+        /// Main设备
+        /// </summary>
+        private VpwMainDevice _mainDevice;
+        #endregion
+        /// <summary>
+        /// 构造函数
+        /// </summary>
+        /// <param name="module"></param>
+        public VpwChamberDownRoutine(string module) : base(module)
+        {
+        }
+        /// <summary>
+        /// 中止
+        /// </summary>
+        public void Abort()
+        {
+            Runner.Stop("Manual abort");
+        }
+        /// <summary>
+        /// 监控
+        /// </summary>
+        /// <returns></returns>
+        public RState Monitor()
+        {
+            Runner.Run(PrepareStep.CheckPreCondition, CheckPreCondition, _delay_1ms)
+                .Run(PrepareStep.ChamerDown, ChamberDown, CheckChamberOpend,_delay_10s)              
+                .End(PrepareStep.End,NullFun,_delay_1ms);
+            return Runner.Status;
+        }
+        /// <summary>
+        /// 打开 Chamber
+        /// </summary>
+        /// <returns></returns>
+        private bool ChamberDown()
+        {
+            return _mainDevice.ChamberDown();
+        }
+        /// <summary>
+        /// 检验Chamber是否打开
+        /// </summary>
+        /// <returns></returns>
+        private bool CheckChamberOpend()
+        {
+            return _mainDevice.CommonData.ChamberOpened && !_mainDevice.CommonData.ChamberClosed;
+        }
+        /// <summary>
+        /// 检验前置条件
+        /// </summary>
+        /// <returns></returns>
+        private bool CheckPreCondition()
+        {
+            string matcher = ModuleMatcherManager.Instance.GetMatcherByModule(Module);
+            VpwCellEntity vpwCellEntity = Singleton<RouteManager>.Instance.GetModule<VpwCellEntity>(matcher);
+            if (vpwCellEntity == null)
+            {
+                return true;
+            }
+            if (vpwCellEntity.IsDisable)
+            {
+                return true;
+            }
+            if (!vpwCellEntity.IsAuto)
+            {
+                return true;
+            }
+            bool result = vpwCellEntity.IsIdle;
+            if (!result)
+            {
+                NotifyError(eEvent.ERR_PLATINGCELL, $"{vpwCellEntity.Module} is not idle,cannot chamber up", 0);
+            }
+            return result;
+        }
+        /// <summary>
+        /// 启动
+        /// </summary>
+        /// <param name="objs"></param>
+        /// <returns></returns>
+        public RState Start(params object[] objs)
+        {
+            _mainDevice = DEVICE.GetDevice<VpwMainDevice>(ModuleName.VPWMain1.ToString());
+            return Runner.Start(Module, $"{Module} chamber down");
+        }
+    }
+}

PunkHPX8_RT/Modules/VpwCell/VpwChamberUpRoutine.cs

@@ -0,0 +1,120 @@
+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.Common.RecipeCenter;
+using MECF.Framework.Common.Routine;
+using MECF.Framework.Common.SubstrateTrackings;
+using PunkHPX8_Core;
+using PunkHPX8_RT.Devices.AXIS;
+using PunkHPX8_RT.Devices.VpwCell;
+using PunkHPX8_RT.Devices.VpwMain;
+using PunkHPX8_RT.Modules.VpwMain;
+using PunkHPX8_RT.Schedulers;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace PunkHPX8_RT.Modules.VpwCell
+{
+    public class VpwChamberUpRoutine : RoutineBase, IRoutine
+    {
+        private enum PrepareStep
+        {
+            CheckPreCondition,
+            ChamerUp,
+            Delay,
+            End
+        }
+
+        #region 内部变量
+        /// <summary>
+        /// Main设备
+        /// </summary>
+        private VpwMainDevice _mainDevice;
+        #endregion
+
+        /// <summary>
+        /// 构造函数
+        /// </summary>
+        /// <param name="module"></param>
+        public VpwChamberUpRoutine(string module) : base(module)
+        {
+        }
+        /// <summary>
+        /// 中止
+        /// </summary>
+        public void Abort()
+        {
+            Runner.Stop("Manual abort");
+        }
+        /// <summary>
+        /// 监控
+        /// </summary>
+        /// <returns></returns>
+        public RState Monitor()
+        {
+            Runner.Run(PrepareStep.CheckPreCondition,CheckPreCondition,_delay_1ms)
+                .Run(PrepareStep.ChamerUp, ChamberUp, CheckChamberClosed,_delay_10s)              
+                .End(PrepareStep.End,NullFun,_delay_1ms);
+            return Runner.Status;
+        }
+        /// <summary>
+        /// 打开 Chamber
+        /// </summary>
+        /// <returns></returns>
+        private bool ChamberUp()
+        {
+            return _mainDevice.ChamberUp();
+        }
+        /// <summary>
+        /// 检验Chamber是否关闭
+        /// </summary>
+        /// <returns></returns>
+        private bool CheckChamberClosed()
+        {
+            return !_mainDevice.CommonData.ChamberOpened && _mainDevice.CommonData.ChamberClosed;                
+        }
+        /// <summary>
+        /// 检验前置条件
+        /// </summary>
+        /// <returns></returns>
+        private bool CheckPreCondition()
+        {
+            string matcher = ModuleMatcherManager.Instance.GetMatcherByModule(Module);
+            VpwCellEntity vpwCellEntity = Singleton<RouteManager>.Instance.GetModule<VpwCellEntity>(matcher);
+            if (vpwCellEntity == null)
+            {
+                return true;
+            }
+            if (vpwCellEntity.IsDisable)
+            {
+                return true;
+            }
+            if (!vpwCellEntity.IsAuto)
+            {
+                return true;
+            }
+            bool result= vpwCellEntity.IsIdle;
+            if (!result)
+            {
+                NotifyError(eEvent.ERR_PLATINGCELL, $"{vpwCellEntity.Module} is not idle,cannot chamber up",0);
+            }
+            return result;
+        }
+        /// <summary>
+        /// 启动
+        /// </summary>
+        /// <param name="objs"></param>
+        /// <returns></returns>
+        public RState Start(params object[] objs)
+        {
+            _mainDevice = DEVICE.GetDevice<VpwMainDevice>(ModuleName.VPWMain1.ToString());
+            return Runner.Start(Module, $"{Module} chamber up");
+        }
+    }
+}

PunkHPX8_RT/Modules/VpwMain/VpwMainEntity.cs

@@ -12,6 +12,7 @@ using MECF.Framework.Common.Persistent.VpwMain;
 using MECF.Framework.Common.ToolLayout;
 using PunkHPX8_Core;
 using PunkHPX8_RT.Devices.VpwCell;
+using PunkHPX8_RT.Devices.VpwMain;
 using PunkHPX8_RT.Modules.VpwCell;
 using PunkHPX8_RT.Modules.VpwCelMain;
 using System;
@@ -57,6 +58,10 @@ namespace PunkHPX8_RT.Modules.VpwMain
         /// purge Routine
         /// </summary>
         private VpwPurgeRoutine _vpwPurgeRoutine;
+        /// <summary>
+        /// 设备
+        /// </summary>
+        private VpwMainDevice _mainDevice;
 
         #endregion
 
@@ -122,6 +127,14 @@ namespace PunkHPX8_RT.Modules.VpwMain
         /// 是否为产品模式
         /// </summary>
         public bool IsProduction { get { return _persistentValue != null && _persistentValue.RecipeOperatingMode == PRODUCTION; } }
+        /// <summary>
+        /// Chamber打开状态
+        /// </summary>
+        public bool IsChamberOpened { get { return _mainDevice.CommonData.ChamberOpened && !_mainDevice.CommonData.ChamberClosed; } }
+        /// <summary>
+        /// Chamber关闭状态
+        /// </summary>
+        public bool IsChamberClosed { get { return _mainDevice.CommonData.ChamberClosed && !_mainDevice.CommonData.ChamberOpened; } }
         #endregion
 
         /// <summary>
@@ -130,7 +143,8 @@ namespace PunkHPX8_RT.Modules.VpwMain
         /// <param name="module"></param>
         public VpwMainEntity(ModuleName module)
         {
-            this.Module = module;
+            Module = module;
+            _mainDevice = DEVICE.GetDevice<VpwMainDevice>(Module.ToString());
         }
 
         /// <summary>

PunkHPX8_RT/PunkHPX8_RT.csproj

@@ -337,10 +337,12 @@
     <Compile Include="Devices\Resistivity\ResistivityController.cs" />
     <Compile Include="Devices\Temperature\TemperatureController.cs" />
     <Compile Include="Modules\DVIDName.cs" />
+    <Compile Include="Modules\VpwCell\VpwChamberUpRoutine.cs" />
     <Compile Include="Modules\VpwCell\VpwLotTrackUtil.cs" />
     <Compile Include="Modules\VpwCell\VpwCellEntity.cs" />
     <Compile Include="Modules\VpwCell\VpwCycleManualProcessRecipeRoutine.cs" />
     <Compile Include="Modules\VpwCell\VpwExtendCleanRoutine.cs" />
+    <Compile Include="Modules\VpwCell\VpwChamberDownRoutine.cs" />
     <Compile Include="Modules\VpwCell\VpwSpinOffRoutine.cs" />
     <Compile Include="Modules\VpwCell\VpwVentPrewetRoutine.cs" />
     <Compile Include="Modules\VpwCell\VpwVacuumPrewetRoutine.cs" />

PunkHPX8_RT/Schedulers/EfemRobot/SchedulerRobot.cs

@@ -21,6 +21,7 @@ using Aitex.Sorter.Common;
 using PunkHPX8_RT.Dispatch;
 using MECF.Framework.Common.ToolLayout;
 using Aitex.Core.Common;
+using PunkHPX8_RT.Devices.VpwMain;
 
 namespace PunkHPX8_RT.Schedulers.EfemRobot
 {
@@ -174,10 +175,35 @@ namespace PunkHPX8_RT.Schedulers.EfemRobot
                 return false;
             }
 
-            if (ModuleHelper.IsVPWCell(moveItem.DestinationModule)||ModuleHelper.IsVPWCell(moveItem.SourceModule))
+            if (ModuleHelper.IsVPWCell(moveItem.DestinationModule))
             {
-                VpwCellEntity vpwEntity = Singleton<RouteManager>.Instance.GetModule<VpwCellEntity>(moveItem.DestinationModule.ToString());
-                if (vpwEntity != null)
+                return CheckVpw(moveItem, schedulerSequences, sequenceIndex, ref reason);
+            }
+            return true;
+        }
+        /// <summary>
+        /// 检验VPW
+        /// </summary>
+        /// <param name="moveItem"></param>
+        /// <param name="schedulerSequences"></param>
+        /// <param name="sequenceIndex"></param>
+        /// <param name="reason"></param>
+        /// <returns></returns>
+        private bool CheckVpw(MoveItem moveItem,List<SchedulerSequence> schedulerSequences, int sequenceIndex,ref string reason)
+        {
+            VpwCellEntity vpwEntity = Singleton<RouteManager>.Instance.GetModule<VpwCellEntity>(moveItem.DestinationModule.ToString());
+            if (vpwEntity != null)
+            {
+                bool nextVpwRecipe = false;
+                if (sequenceIndex + 1 < schedulerSequences.Count)
+                {
+                    SchedulerSequence nextSequence = schedulerSequences[sequenceIndex + 1];
+                    if (nextSequence.ModuleType == ModuleType.VPW)
+                    {
+                        nextVpwRecipe = true;
+                    }
+                }
+                if (nextVpwRecipe)
                 {
                     if (vpwEntity.State == (int)VPWCellState.WaitForRunRecipe)
                     {
@@ -187,12 +213,9 @@ namespace PunkHPX8_RT.Schedulers.EfemRobot
                     {
                         if (vpwEntity.IsIdle)
                         {
-                            if (sequenceIndex + 1 < schedulerSequences.Count)
-                            {
-                                SchedulerSequence nextSequence = schedulerSequences[sequenceIndex + 1];
-                                vpwEntity.CheckToPostMessage<VPWCellState, VPWCellMsg>(eEvent.INFO_VPW, Module.ToString(),
-                                    (int)VPWCellMsg.Prepare, nextSequence.Recipe);
-                            }
+                            SchedulerSequence nextSequence = schedulerSequences[sequenceIndex + 1];
+                            vpwEntity.CheckToPostMessage<VPWCellState, VPWCellMsg>(eEvent.INFO_VPW, Module.ToString(),
+                                (int)VPWCellMsg.Prepare, nextSequence.Recipe);
                         }
                         reason = $"{vpwEntity.Module} state is not WaitForRunRecipe";
                         return false;
@@ -200,10 +223,33 @@ namespace PunkHPX8_RT.Schedulers.EfemRobot
                 }
                 else
                 {
-                    reason = $"{moveItem.DestinationModule} is null";
+                    VpwMainEntity vpwMainEntity = Singleton<RouteManager>.Instance.GetModule<VpwMainEntity>(ModuleName.VPWMain1.ToString());
+                    if (vpwEntity.IsIdle)
+                    {
+                        if (vpwMainEntity.IsChamberOpened)
+                        {
+                            return true;
+                        }
+                        else
+                        {
+                            vpwEntity.CheckToPostMessage<VPWCellState, VPWCellMsg>(eEvent.INFO_VPW, Module.ToString(), (int)VPWCellMsg.ChamberDown);
+
+                            reason = $"{vpwEntity.Module} chamber is not opened";
+                            return false;
+                        }
+                    }
+                    else
+                    {
+                        reason = $"{vpwEntity.Module} is not idle";
+                        return false;
+                    }
                 }
             }
-            return true;
+            else
+            {
+                reason = $"{moveItem.DestinationModule} is null";
+            }
+            return false;
         }
         /// <summary>
         /// 更新未知源模块

PunkHPX8_RT/Schedulers/SchedulerSequenceManager.cs

@@ -60,7 +60,7 @@ namespace PunkHPX8_RT.Schedulers
             SchedulerSequence alignerRobotSequence = CreateEfemRobotSequence(alignerToMoveItem, null, sequenceRecipe.SubstrateSize, ref index);
             schedulerSequences.Add(alignerRobotSequence);
             //解析sequence recipe后续的工序
-            var sequences = AnalyseSequenceRecipeScheduler(sequenceRecipe,false);
+            var sequences = AnalyseSequenceRecipeScheduler(sequenceRecipe,vpw,false);
             if (sequences.Count == 0)
             {
                 return schedulerSequences;
@@ -88,7 +88,7 @@ namespace PunkHPX8_RT.Schedulers
                 {
                     //从VPW取至SRD
                     MoveItem lastToSrdItem = new MoveItem();
-                    lastToSrdItem.SourceModule = ModuleName.Unknown;
+                    lastToSrdItem.SourceModule = vpw;
                     //A面
                     lastToSrdItem.SourceSlot = 0;
                     lastToSrdItem.SourceType = ModuleType.VPW;
@@ -126,7 +126,7 @@ namespace PunkHPX8_RT.Schedulers
             {
                 //若无SRD，直接从VPW转LoadPort
                 MoveItem srdToLoadPortItem = new MoveItem();
-                srdToLoadPortItem.SourceModule = ModuleName.Unknown;
+                srdToLoadPortItem.SourceModule = vpw;
                 srdToLoadPortItem.SourceType = ModuleType.VPW;
                 srdToLoadPortItem.SourceSlot = 0;
                 srdToLoadPortItem.DestinationType = ModuleType.LoadPort;
@@ -159,7 +159,7 @@ namespace PunkHPX8_RT.Schedulers
             SchedulerSequence alignerRobotSequence = CreateEfemRobotSequence(alignerToMoveItem, null, sequenceRecipe.SubstrateSize, ref index);
             schedulerSequences.Add(alignerRobotSequence);
             //解析sequence recipe后续的工序
-            var sequences = AnalyseSequenceRecipeScheduler(sequenceRecipe, false);
+            var sequences = AnalyseSequenceRecipeScheduler(sequenceRecipe,vpw, false);
             if (sequences.Count == 0)
             {
                 return schedulerSequences;
@@ -200,7 +200,7 @@ namespace PunkHPX8_RT.Schedulers
         /// </summary>
         /// <param name="sequenceRecipe"></param>
         /// <returns></returns>
-        private List<SchedulerSequence> AnalyseSequenceRecipeScheduler(SequenceRecipe sequenceRecipe,bool isDummy)
+        private List<SchedulerSequence> AnalyseSequenceRecipeScheduler(SequenceRecipe sequenceRecipe,ModuleName vpw,bool isDummy)
         {
             List<SchedulerSequence> schedulerSequences= new List<SchedulerSequence>();
             List<SchedulerSequence> tmpLst = new List<SchedulerSequence>();
@@ -285,7 +285,7 @@ namespace PunkHPX8_RT.Schedulers
                         moveItem.SourceModule = tmpLst[i].ModuleName;
                         moveItem.SourceType = tmpLst[i].ModuleType;
                         moveItem.SourceSlot = 0;
-                        moveItem.DestinationModule = ModuleName.Unknown;
+                        moveItem.DestinationModule = vpw;
                         moveItem.DestinationSlot = 0;
                         moveItem.DestinationType = ModuleType.VPW;
                         moveItem.RobotHand = Hand.Blade2;