Modify LoaderLotTrack; Modify Thornton simulator;

CyberX8_RT/Config/Devices/ThorntonCfg.xml

@@ -6,7 +6,7 @@
     <Device Name="RP1-3" Address="5"/>
     <Device Name="RP1-4" Address="7"/>
   </ThorntonDeviceConfig>
-   <ThorntonDeviceConfig Name="RP2" Port="com19" BaudRate="19200" Parity="N" Data="8" StopBit="1">
+   <ThorntonDeviceConfig Name="RP2" Port="com20" BaudRate="19200" Parity="N" Data="8" StopBit="1">
     <Device Name="RP2-1" Address="1"/>
   </ThorntonDeviceConfig>
 </ThorntonConfig>

CyberX8_RT/CyberX8_RT.csproj

@@ -227,7 +227,6 @@
     <Compile Include="Devices\Loader\LoaderCRSAxisInterLock.cs" />
     <Compile Include="Devices\Loader\LoaderDeviceTimer.cs" />
     <Compile Include="Devices\Loader\LoaderFlowTestRoutine.cs" />
-    <Compile Include="Devices\Loader\LoaderLotTrackUtil.cs" />
     <Compile Include="Devices\Loader\LoaderPreTransferUnclampRoutine.cs" />
     <Compile Include="Devices\Loader\LoaderRotationAxisInterLock.cs" />
     <Compile Include="Devices\Loader\LoaderSideBernoulliN2PressureRoutine.cs" />
@@ -276,6 +275,7 @@
     <Compile Include="Modules\EFEM\RobotCycleMoveRoutine.cs" />
     <Compile Include="Modules\EFEM\RobotCycleRoutine.cs" />
     <Compile Include="Modules\FaModuleNotifier.cs" />
+    <Compile Include="Modules\Loader\LoaderLotTrackUtil.cs" />
     <Compile Include="Modules\Loader\LoaderLoadSideRoutine.cs" />
     <Compile Include="Modules\Loader\LoaderUnloadSideRoutine.cs" />
     <Compile Include="Modules\Metal\CompactEmbranceInitializeRoutine.cs" />

CyberX8_RT/Devices/Loader/LoaderLotTrackUtil.cs

@@ -1,529 +0,0 @@
-using Aitex.Common.Util;
-using Aitex.Core.Common;
-using Aitex.Core.RT.Log;
-using CyberX8_RT.Dispatch;
-using MECF.Framework.Common.CommonData;
-using MECF.Framework.Common.CommonData.Loader;
-using MECF.Framework.Common.Equipment;
-using MECF.Framework.Common.SubstrateTrackings;
-using MECF.Framework.Common.WaferHolder;
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Threading.Tasks;
-using static CyberX8_RT.Modules.Loader.LoaderEntity;
-
-namespace CyberX8_RT.Devices.Loader
-{
-    public class LoaderLotTrackUtil
-    {
-        /// <summary>
-        /// CSV文件分隔符
-        /// </summary>
-        private const char CVS_SPLIT_CHAR = ',';
-        /// <summary>
-        /// 首次写入
-        /// </summary>
-        private static bool _firstWriteFlagUnload;
-        /// <summary>
-        /// 首次写入
-        /// </summary>
-        private static bool _firstWriteFlagLoad;
-
-        /// <summary>
-        /// 导出至csv
-        /// </summary>
-        /// <param name="moduleName"></param>
-        /// <param name="datas"></param>
-        public static async void ExportLoaderLotTrack(string moduleName, List<LoaderLotTrackData> unloadDatas, List<LoaderLotTrackData> loadDatas, List<LoaderFlowLotTrackData> flowDatas, 
-            LotTrackFileHeaderCommonData headerData, Dictionary<string, List<string>> _loaderOperatingSlotsList, List<DateTime> loadTimeList, List<DateTime> unloadTimeList, DateTime unloadstartTime,
-            LotTrackDatasStatus unloadDatasStatus, LotTrackDatasStatus loadDatasStatus, LotTrackDatasStatus flowTestDatasStatus, List<LoaderLotTrackData> unloadDatasBuffer, LotTrackDatasStatus unloadDatasBufferStatus, bool isUnloadFailed = false)
-        {
-            await Task.Run(() =>
-            {
-                try
-                {                
-                    //文件流处理
-                    //Unload wafer file
-                    string strPathUnload = "";
-                    FileInfo fiUnload;
-                    WaferInfo unloadedWaferInfoA = WaferManager.Instance.GetWaferByWaferId(_loaderOperatingSlotsList["unload"].Count >= 1? _loaderOperatingSlotsList["unload"][0] : "");
-                    WaferInfo unloadedWaferInfoB = WaferManager.Instance.GetWaferByWaferId(_loaderOperatingSlotsList["unload"].Count >= 2 ? _loaderOperatingSlotsList["unload"][1] : "");
-
-                    if ((unloadedWaferInfoA != null && !string.IsNullOrEmpty(unloadedWaferInfoA.LotId)) || (unloadedWaferInfoB != null && !string.IsNullOrEmpty(unloadedWaferInfoB.LotId)))
-                    {
-                        if (unloadedWaferInfoA != null && !string.IsNullOrEmpty(unloadedWaferInfoA.LotId))
-                        {
-                            if (!string.IsNullOrEmpty(unloadedWaferInfoA.LotTrackPath))
-                            {
-                                strPathUnload = unloadedWaferInfoA.LotTrackPath;
-                            }
-                            else
-                            {
-                                int cycleCount = CycleManager.Instance.GetLoadportCycleCount($"LP{unloadedWaferInfoA.OriginStation}");
-                                int cycleSetPoint = CycleManager.Instance.GetLoadportCycleSetPoint($"LP{unloadedWaferInfoA.OriginStation}");
-                                string cycleStr = cycleSetPoint > 1 ? $"-{cycleCount + 1}": "";
-                                if (unloadedWaferInfoB != null && !string.IsNullOrEmpty(unloadedWaferInfoB.LotId) && !unloadedWaferInfoB.LotId.Equals(unloadedWaferInfoA.LotId))
-                                {
-                                    int cycleCountB = CycleManager.Instance.GetLoadportCycleCount($"LP{unloadedWaferInfoB.OriginStation}");
-                                    int cycleSetPointB = CycleManager.Instance.GetLoadportCycleSetPoint($"LP{unloadedWaferInfoB.OriginStation}");
-                                    string cycleStrB = cycleSetPointB > 1 ? $"-{cycleCountB + 1}" : "";
-                                    strPathUnload = $"Auto\\{unloadstartTime.Year}\\{unloadstartTime.Month}\\" + $"{unloadedWaferInfoA.LotId}{cycleStr}-{unloadedWaferInfoB.LotId}{cycleStrB}_LP{unloadedWaferInfoA.OriginStation}-{unloadedWaferInfoB.OriginStation}_Slots-{unloadedWaferInfoA.OriginSlot + 1}-{(!string.IsNullOrEmpty(unloadedWaferInfoB.LotId) ? unloadedWaferInfoB.OriginSlot + 1 : 0)}" +
-                                $"_M{unloadstartTime.ToString("MM")}_D{unloadstartTime.ToString("dd")}_H{unloadstartTime.ToString("HH")}_M{unloadstartTime.ToString("mm")}_S{unloadstartTime.ToString("ss")}.csv";
-                                }
-                                else
-                                {
-                                    strPathUnload = $"Auto\\{unloadstartTime.Year}\\{unloadstartTime.Month}\\" + $"{unloadedWaferInfoA.LotId}{cycleStr}_LP{unloadedWaferInfoA.OriginStation}_Slots-{unloadedWaferInfoA.OriginSlot + 1}-{(!string.IsNullOrEmpty(unloadedWaferInfoB.LotId) ? unloadedWaferInfoB.OriginSlot + 1 : 0)}" +
-                                $"_M{unloadstartTime.ToString("MM")}_D{unloadstartTime.ToString("dd")}_H{unloadstartTime.ToString("HH")}_M{unloadstartTime.ToString("mm")}_S{unloadstartTime.ToString("ss")}.csv";
-                                }                               
-                                WaferManager.Instance.UpdateWaferLotTrackPath((ModuleName)unloadedWaferInfoA.Station, unloadedWaferInfoA.Slot, strPathUnload);
-                            }
-                        }
-                        if (unloadedWaferInfoB != null && !string.IsNullOrEmpty(unloadedWaferInfoB.LotId))
-                        {
-                            if (!string.IsNullOrEmpty(unloadedWaferInfoB.LotTrackPath))
-                            {
-                                strPathUnload = unloadedWaferInfoB.LotTrackPath;
-                            }
-                            else
-                            {
-                                int cycleCount = CycleManager.Instance.GetLoadportCycleCount($"LP{unloadedWaferInfoB.OriginStation}");
-                                int cycleSetPoint = CycleManager.Instance.GetLoadportCycleSetPoint($"LP{unloadedWaferInfoB.OriginStation}");
-                                string cycleStr = cycleSetPoint > 1 ? $"-{cycleCount + 1}" : "";
-                                if (unloadedWaferInfoA != null && !string.IsNullOrEmpty(unloadedWaferInfoA.LotId) && !unloadedWaferInfoA.LotId.Equals(unloadedWaferInfoB.LotId))
-                                {
-                                    int cycleCountA = CycleManager.Instance.GetLoadportCycleCount($"LP{unloadedWaferInfoA.OriginStation}");
-                                    int cycleSetPointA = CycleManager.Instance.GetLoadportCycleSetPoint($"LP{unloadedWaferInfoA.OriginStation}");
-                                    string cycleStrA = cycleSetPointA > 1 ? $"-{cycleCountA + 1}" : "";
-                                    strPathUnload = $"Auto\\{unloadstartTime.Year}\\{unloadstartTime.Month}\\" + $"{unloadedWaferInfoA.LotId}{cycleStrA}-{unloadedWaferInfoB.LotId}{cycleStr}_LP{unloadedWaferInfoA.OriginStation}-{unloadedWaferInfoB.OriginStation}_Slots-{unloadedWaferInfoA.OriginSlot + 1}-{(!string.IsNullOrEmpty(unloadedWaferInfoB.LotId) ? unloadedWaferInfoB.OriginSlot + 1 : 0)}" +
-                                $"_M{unloadstartTime.ToString("MM")}_D{unloadstartTime.ToString("dd")}_H{unloadstartTime.ToString("HH")}_M{unloadstartTime.ToString("mm")}_S{unloadstartTime.ToString("ss")}.csv";
-                                }
-                                else
-                                {
-                                    strPathUnload = $"Auto\\{unloadstartTime.Year}\\{unloadstartTime.Month}\\" + $"{unloadedWaferInfoB.LotId}_LP{unloadedWaferInfoB.OriginStation}{cycleStr}_Slots-{(!string.IsNullOrEmpty(unloadedWaferInfoA.LotId) ? unloadedWaferInfoA.OriginSlot + 1 : 0)}-{unloadedWaferInfoB.OriginSlot + 1}" +
-                                $"_M{unloadstartTime.ToString("MM")}_D{unloadstartTime.ToString("dd")}_H{unloadstartTime.ToString("HH")}_M{unloadstartTime.ToString("mm")}_S{unloadstartTime.ToString("ss")}.csv";                                  
-                                }
-                                WaferManager.Instance.UpdateWaferLotTrackPath((ModuleName)unloadedWaferInfoB.Station, unloadedWaferInfoB.Slot, strPathUnload);
-                            }
-                        }
-                        fiUnload = new FileInfo(PathManager.GetLotTrackFilePath() + strPathUnload);
-                    }
-                    else
-                    {
-                        strPathUnload = $"{moduleName}_M{unloadstartTime.ToString("MM")}_D{unloadstartTime.ToString("dd")}_H{unloadstartTime.ToString("HH")}_M{unloadstartTime.ToString("mm")}_S{unloadstartTime.ToString("ss")}.csv";
-                        fiUnload = new FileInfo(PathManager.GetLotTrackFilePath() + $"Manual\\{unloadstartTime.Year}\\{unloadstartTime.Month}\\" + strPathUnload);
-                    }
-                    _firstWriteFlagUnload = false;
-                    //目录不存在则创建
-                    if (!fiUnload.Directory.Exists)
-                    {
-                        fiUnload.Directory.Create();
-                    }
-                    if (!File.Exists(fiUnload.FullName))
-                    {
-                        _firstWriteFlagUnload = true;
-                    }
-                    FileStream fsUnload = new FileStream(fiUnload.FullName, System.IO.FileMode.Append, System.IO.FileAccess.Write);
-                    StreamWriter swUnload = new StreamWriter(fsUnload, System.Text.Encoding.UTF8);
-                    //Header Data Unload
-                    if (_firstWriteFlagUnload && headerData != null)
-                    {
-                        swUnload.WriteLine(fiUnload.FullName);
-                        swUnload.WriteLine($"Date:{DateTime.Now.ToShortDateString()}");
-                        swUnload.WriteLine($"Tool ID:{headerData.ToolID}");
-                        swUnload.WriteLine($"SW Version:{headerData.SoftWareVersion}");
-                        swUnload.WriteLine($"Sequence Recipe:{headerData.SequenceRecipe}");
-                    }
-                    //输入数据    
-                    //unloadWafers
-                    //Unload Datas
-                    if (unloadDatasStatus == LotTrackDatasStatus.None)
-                    {
-                        //unload数据头
-                        if (headerData.ProcessTransferList != null)
-                        {
-                            foreach (var item in headerData.ProcessTransferList)
-                            {
-                                swUnload.WriteLine(item);
-                            }
-                        }
-                        swUnload.WriteLine($"StartUnloadWaferShuttle:{(unloadTimeList.Count >= 1 ? unloadTimeList[0].ToString() : "")}");
-                        swUnload.WriteLine(moduleName);
-                        swUnload.Write(CVS_SPLIT_CHAR);
-                        string str = $"TimeStamp{CVS_SPLIT_CHAR}LoaderABernoulliBladderEnable{CVS_SPLIT_CHAR}LoaderABernoulliExtended{CVS_SPLIT_CHAR}LoaderABernoulliBladderPressure{CVS_SPLIT_CHAR}" +
-                            $"LoaderABernoulliN2Pressure{CVS_SPLIT_CHAR}LoaderALSVacuum{CVS_SPLIT_CHAR}LoaderALSVacuumAnlg{CVS_SPLIT_CHAR}LoaderATranslatePressure{CVS_SPLIT_CHAR}LoaderAWSPressure" +
-                            $"{CVS_SPLIT_CHAR}LoaderBBernoulliBladderEnable{CVS_SPLIT_CHAR}LoaderBBernoulliExtended{CVS_SPLIT_CHAR}LoaderBBernoulliBladderPressure{CVS_SPLIT_CHAR}" +
-                            $"LoaderBBernoulliN2Pressure{CVS_SPLIT_CHAR}LoaderBLSVacuum{CVS_SPLIT_CHAR}LoaderBLSVacuumAnlg{CVS_SPLIT_CHAR}LoaderBTranslatePressure{CVS_SPLIT_CHAR}LoaderBWSPressure" +
-                            $"{CVS_SPLIT_CHAR}LoaderWSClamped{CVS_SPLIT_CHAR}";
-                        swUnload.WriteLine(str);
-                        //unload数据内容
-                        if (unloadDatas != null && unloadDatas.Count != 0)
-                        {
-                            for (int i = 0; i < unloadDatas.Count; i++)
-                            {
-                                LoaderLotTrackData data = unloadDatas[i];
-                                string tmp = $"{CVS_SPLIT_CHAR}{data.TimeStamp.ToString("HH:mm:ss")}{CVS_SPLIT_CHAR}{data.LoaderABernoulliBladderEnable}{CVS_SPLIT_CHAR}{data.LoaderABernoulliExtended}{CVS_SPLIT_CHAR}{data.LoaderABernoulliBladderPressure}{CVS_SPLIT_CHAR}" +
-                                $"{data.LoaderABernoulliN2Pressure}{CVS_SPLIT_CHAR}{data.LoaderACRSVacuum}{CVS_SPLIT_CHAR}{data.LoaderACRSVacuumAnlg}{CVS_SPLIT_CHAR}{data.LoaderATranslatePressure}{CVS_SPLIT_CHAR}{data.LoaderAWHPressure}" +
-                                $"{CVS_SPLIT_CHAR}{data.LoaderBBernoulliBladderEnable}{CVS_SPLIT_CHAR}{data.LoaderBBernoulliExtended}{CVS_SPLIT_CHAR}{data.LoaderBBernoulliBladderPressure}{CVS_SPLIT_CHAR}" +
-                                $"{data.LoaderBBernoulliN2Pressure}{CVS_SPLIT_CHAR}{data.LoaderBCRSVacuum}{CVS_SPLIT_CHAR}{data.LoaderBCRSVacuumAnlg}{CVS_SPLIT_CHAR}{data.LoaderBTranslatePressure}{CVS_SPLIT_CHAR}{data.LoaderBWHPressure}" +
-                                $"{CVS_SPLIT_CHAR}{data.LoaderWHClamped}{CVS_SPLIT_CHAR}";
-                                swUnload.WriteLine(tmp);
-                            }
-                        }
-                        if (unloadTimeList.Count >= 2)
-                        {
-                            swUnload.WriteLine($"FinishUnloadWaferShuttle:{unloadTimeList[1].ToString()}");
-                        }
-                    }
-                    else if (unloadDatasStatus == LotTrackDatasStatus.Half)
-                    {
-                        //unload数据内容
-                        if (unloadDatas != null && unloadDatas.Count != 0)
-                        {
-                            for (int i = 0; i < unloadDatas.Count; i++)
-                            {
-                                LoaderLotTrackData data = unloadDatas[i];
-                                string tmp = $"{CVS_SPLIT_CHAR}{data.TimeStamp.ToString("HH:mm:ss")}{CVS_SPLIT_CHAR}{data.LoaderABernoulliBladderEnable}{CVS_SPLIT_CHAR}{data.LoaderABernoulliExtended}{CVS_SPLIT_CHAR}{data.LoaderABernoulliBladderPressure}{CVS_SPLIT_CHAR}" +
-                                $"{data.LoaderABernoulliN2Pressure}{CVS_SPLIT_CHAR}{data.LoaderACRSVacuum}{CVS_SPLIT_CHAR}{data.LoaderACRSVacuumAnlg}{CVS_SPLIT_CHAR}{data.LoaderATranslatePressure}{CVS_SPLIT_CHAR}{data.LoaderAWHPressure}" +
-                                $"{CVS_SPLIT_CHAR}{data.LoaderBBernoulliBladderEnable}{CVS_SPLIT_CHAR}{data.LoaderBBernoulliExtended}{CVS_SPLIT_CHAR}{data.LoaderBBernoulliBladderPressure}{CVS_SPLIT_CHAR}" +
-                                $"{data.LoaderBBernoulliN2Pressure}{CVS_SPLIT_CHAR}{data.LoaderBCRSVacuum}{CVS_SPLIT_CHAR}{data.LoaderBCRSVacuumAnlg}{CVS_SPLIT_CHAR}{data.LoaderBTranslatePressure}{CVS_SPLIT_CHAR}{data.LoaderBWHPressure}" +
-                                $"{CVS_SPLIT_CHAR}{data.LoaderWHClamped}{CVS_SPLIT_CHAR}";
-                                swUnload.WriteLine(tmp);
-                            }
-                        }
-                        if (unloadTimeList.Count >= 2)
-                        {
-                            swUnload.WriteLine($"FinishUnloadWaferShuttle:{unloadTimeList[1].ToString()}");
-                        }
-                    }
-                    //Load Datas
-                    if (loadDatasStatus == LotTrackDatasStatus.None && unloadTimeList.Count >= 2 && loadTimeList.Count >= 1)
-                    {
-                        WaferHolderInfo whInfo = WaferHolderManager.Instance.GetWaferHolder(moduleName);
-                        swUnload.WriteLine($"WaferShuttle:{(whInfo != null ? whInfo.Id : "")}");
-                        swUnload.WriteLine($"LS-A:{(whInfo != null ? whInfo.CrsAId : "")}");
-                        swUnload.WriteLine($"LS-B:{(whInfo != null ? whInfo.CrsBId : "")}");
-                        swUnload.WriteLine($"StartLoadWaferShuttle:{(loadTimeList.Count >= 1 ? loadTimeList[0].ToString() : "")}");
-                        swUnload.WriteLine(moduleName);
-                        swUnload.Write(CVS_SPLIT_CHAR);
-
-                        string str = $"TimeStamp{CVS_SPLIT_CHAR}LoaderABernoulliBladderEnable{CVS_SPLIT_CHAR}LoaderABernoulliExtended{CVS_SPLIT_CHAR}LoaderABernoulliBladderPressure{CVS_SPLIT_CHAR}" +
-                            $"LoaderABernoulliN2Pressure{CVS_SPLIT_CHAR}LoaderALSVacuum{CVS_SPLIT_CHAR}LoaderALSVacuumAnlg{CVS_SPLIT_CHAR}LoaderATranslatePressure{CVS_SPLIT_CHAR}LoaderAWSPressure" +
-                            $"{CVS_SPLIT_CHAR}LoaderBBernoulliBladderEnable{CVS_SPLIT_CHAR}LoaderBBernoulliExtended{CVS_SPLIT_CHAR}LoaderBBernoulliBladderPressure{CVS_SPLIT_CHAR}" +
-                            $"LoaderBBernoulliN2Pressure{CVS_SPLIT_CHAR}LoaderBLSVacuum{CVS_SPLIT_CHAR}LoaderBLSVacuumAnlg{CVS_SPLIT_CHAR}LoaderBTranslatePressure{CVS_SPLIT_CHAR}LoaderBWSPressure" +
-                            $"{CVS_SPLIT_CHAR}LoaderWSClamped{CVS_SPLIT_CHAR}";
-                        swUnload.WriteLine(str);
-                        if (loadDatas != null && loadDatas.Count != 0)
-                        {
-                            for (int i = 0; i < loadDatas.Count; i++)
-                            {
-                                LoaderLotTrackData data = loadDatas[i];
-                                string tmp = $"{CVS_SPLIT_CHAR}{data.TimeStamp.ToString("HH:mm:ss")}{CVS_SPLIT_CHAR}{data.LoaderABernoulliBladderEnable}{CVS_SPLIT_CHAR}{data.LoaderABernoulliExtended}{CVS_SPLIT_CHAR}{data.LoaderABernoulliBladderPressure}{CVS_SPLIT_CHAR}" +
-                                $"{data.LoaderABernoulliN2Pressure}{CVS_SPLIT_CHAR}{data.LoaderACRSVacuum}{CVS_SPLIT_CHAR}{data.LoaderACRSVacuumAnlg}{CVS_SPLIT_CHAR}{data.LoaderATranslatePressure}{CVS_SPLIT_CHAR}{data.LoaderAWHPressure}" +
-                                $"{CVS_SPLIT_CHAR}{data.LoaderBBernoulliBladderEnable}{CVS_SPLIT_CHAR}{data.LoaderBBernoulliExtended}{CVS_SPLIT_CHAR}{data.LoaderBBernoulliBladderPressure}{CVS_SPLIT_CHAR}" +
-                                $"{data.LoaderBBernoulliN2Pressure}{CVS_SPLIT_CHAR}{data.LoaderBCRSVacuum}{CVS_SPLIT_CHAR}{data.LoaderBCRSVacuumAnlg}{CVS_SPLIT_CHAR}{data.LoaderBTranslatePressure}{CVS_SPLIT_CHAR}{data.LoaderBWHPressure}" +
-                                $"{CVS_SPLIT_CHAR}{data.LoaderWHClamped}{CVS_SPLIT_CHAR}";
-                                swUnload.WriteLine(tmp);
-                            }
-                        }
-                        if (loadTimeList.Count >= 2)
-                        {
-                            swUnload.WriteLine($"FinishLoadWaferShuttle:{loadTimeList[1].ToString()}");
-                        }
-                    }
-                    else if (loadDatasStatus == LotTrackDatasStatus.Half && unloadTimeList.Count >= 2 && loadTimeList.Count >= 1)
-                    {
-                        if (loadDatas != null && loadDatas.Count != 0)
-                        {
-                            for (int i = 0; i < loadDatas.Count; i++)
-                            {
-                                LoaderLotTrackData data = loadDatas[i];
-                                string tmp = $"{CVS_SPLIT_CHAR}{data.TimeStamp.ToString("HH:mm:ss")}{CVS_SPLIT_CHAR}{data.LoaderABernoulliBladderEnable}{CVS_SPLIT_CHAR}{data.LoaderABernoulliExtended}{CVS_SPLIT_CHAR}{data.LoaderABernoulliBladderPressure}{CVS_SPLIT_CHAR}" +
-                                $"{data.LoaderABernoulliN2Pressure}{CVS_SPLIT_CHAR}{data.LoaderACRSVacuum}{CVS_SPLIT_CHAR}{data.LoaderACRSVacuumAnlg}{CVS_SPLIT_CHAR}{data.LoaderATranslatePressure}{CVS_SPLIT_CHAR}{data.LoaderAWHPressure}" +
-                                $"{CVS_SPLIT_CHAR}{data.LoaderBBernoulliBladderEnable}{CVS_SPLIT_CHAR}{data.LoaderBBernoulliExtended}{CVS_SPLIT_CHAR}{data.LoaderBBernoulliBladderPressure}{CVS_SPLIT_CHAR}" +
-                                $"{data.LoaderBBernoulliN2Pressure}{CVS_SPLIT_CHAR}{data.LoaderBCRSVacuum}{CVS_SPLIT_CHAR}{data.LoaderBCRSVacuumAnlg}{CVS_SPLIT_CHAR}{data.LoaderBTranslatePressure}{CVS_SPLIT_CHAR}{data.LoaderBWHPressure}" +
-                                $"{CVS_SPLIT_CHAR}{data.LoaderWHClamped}{CVS_SPLIT_CHAR}";
-                                swUnload.WriteLine(tmp);
-                            }
-                        }
-                        if (loadTimeList.Count >= 2)
-                        {
-                            swUnload.WriteLine($"FinishLoadWaferShuttle:{loadTimeList[1].ToString()}");
-                        }
-                    }
-                    //Flow Datas
-                    if (flowTestDatasStatus == LotTrackDatasStatus.None && unloadTimeList.Count >= 2 && loadTimeList.Count >= 2)
-                    {
-                        if (flowDatas != null && flowDatas.Count != 0)
-                        {
-                            swUnload.WriteLine(moduleName);
-                            swUnload.Write(CVS_SPLIT_CHAR);
-
-                            string str = $"TimeStamp{CVS_SPLIT_CHAR}LoaderWSClamped{CVS_SPLIT_CHAR}LoaderALSVacuum{CVS_SPLIT_CHAR}" +
-                                $"LoaderALSVacuumAnlg{CVS_SPLIT_CHAR}LoaderBLSVacuum{CVS_SPLIT_CHAR}LoaderBLSVacuumAnlg{CVS_SPLIT_CHAR}" +
-                                $"EnableVacuum{CVS_SPLIT_CHAR}EnableFlowClamp{CVS_SPLIT_CHAR}Flow{CVS_SPLIT_CHAR}";
-                            swUnload.WriteLine(str);
-
-                            for (int i = 0; i < flowDatas.Count; i++)
-                            {
-                                LoaderFlowLotTrackData data = flowDatas[i];
-                                string tmp = $"{CVS_SPLIT_CHAR}{data.TimeStamp.ToString("HH:mm:ss")}{CVS_SPLIT_CHAR}{data.LoaderWHClamped}{CVS_SPLIT_CHAR}{data.LoaderACRSVacuum}{CVS_SPLIT_CHAR}" +
-                                $"{data.LoaderACRSVacuumAnlg}{CVS_SPLIT_CHAR}{data.LoaderBCRSVacuum}{CVS_SPLIT_CHAR}{data.LoaderBCRSVacuumAnlg}{CVS_SPLIT_CHAR}" +
-                                $"{data.EnableVacuum}{CVS_SPLIT_CHAR}{data.EnableFlowClamp}{CVS_SPLIT_CHAR}{data.FlowValue}{CVS_SPLIT_CHAR}";
-                                swUnload.WriteLine(tmp);
-                            }
-                            swUnload.WriteLine("");
-                        }
-
-                    }
-                    swUnload.Close();
-                    fsUnload.Close();
-
-                    //Load wafer file                   
-                    if (!isUnloadFailed)
-                    {
-                        FileInfo fiLoad;
-                        string strPathLoad = "";
-                        
-                        WaferInfo loadedWaferInfoA = WaferManager.Instance.GetWaferByWaferId(_loaderOperatingSlotsList["load"].Count >= 1 ? _loaderOperatingSlotsList["load"][0] : "");
-                        WaferInfo loadedWaferInfoB = WaferManager.Instance.GetWaferByWaferId(_loaderOperatingSlotsList["load"].Count >= 2 ? _loaderOperatingSlotsList["load"][1] : "");
-                        if ((loadedWaferInfoA != null && !string.IsNullOrEmpty(loadedWaferInfoA.LotId)) || (loadedWaferInfoB != null && !string.IsNullOrEmpty(loadedWaferInfoB.LotId)))
-                        {
-                            if (loadedWaferInfoA != null && !string.IsNullOrEmpty(loadedWaferInfoA.LotId))
-                            {
-                                if (!string.IsNullOrEmpty(loadedWaferInfoA.LotTrackPath))
-                                {
-                                    strPathLoad = loadedWaferInfoA.LotTrackPath;
-                                }
-                                else
-                                {
-                                    int cycleCount = CycleManager.Instance.GetLoadportCycleCount($"LP{loadedWaferInfoA.OriginStation}");
-                                    int cycleSetPoint = CycleManager.Instance.GetLoadportCycleSetPoint($"LP{loadedWaferInfoA.OriginStation}");
-                                    string cycleStr = cycleSetPoint > 1 ? $"-{cycleCount + 1}" : "";
-                                    if (loadedWaferInfoB != null && !string.IsNullOrEmpty(loadedWaferInfoB.LotId) && !loadedWaferInfoB.LotId.Equals(loadedWaferInfoA.LotId))
-                                    {
-                                        int cycleCountB = CycleManager.Instance.GetLoadportCycleCount($"LP{loadedWaferInfoB.OriginStation}");
-                                        int cycleSetPointB = CycleManager.Instance.GetLoadportCycleSetPoint($"LP{loadedWaferInfoB.OriginStation}");
-                                        string cycleStrB = cycleSetPointB > 1 ? $"-{cycleCountB + 1}" : "";
-                                        strPathLoad = $"Auto\\{unloadstartTime.Year}\\{unloadstartTime.Month}\\" + $"{loadedWaferInfoA.LotId}{cycleStr}-{loadedWaferInfoB.LotId}{cycleStrB}_LP{loadedWaferInfoA.OriginStation}-{loadedWaferInfoB.OriginStation}_Slots-{loadedWaferInfoA.OriginSlot + 1}-{(!string.IsNullOrEmpty(loadedWaferInfoB.LotId) ? loadedWaferInfoB.OriginSlot + 1 : 0)}" +
-                                    $"_M{unloadstartTime.ToString("MM")}_D{unloadstartTime.ToString("dd")}_H{unloadstartTime.ToString("HH")}_M{unloadstartTime.ToString("mm")}_S{unloadstartTime.ToString("ss")}.csv";
-                                    }
-                                    else
-                                    {
-                                        strPathLoad = $"Auto\\{unloadstartTime.Year}\\{unloadstartTime.Month}\\" + $"{loadedWaferInfoA.LotId}{cycleStr}_LP{loadedWaferInfoA.OriginStation}_Slots-{loadedWaferInfoA.OriginSlot + 1}-{(!string.IsNullOrEmpty(loadedWaferInfoB.LotId) ? loadedWaferInfoB.OriginSlot + 1 : 0)}" +
-                                    $"_M{unloadstartTime.ToString("MM")}_D{unloadstartTime.ToString("dd")}_H{unloadstartTime.ToString("HH")}_M{unloadstartTime.ToString("mm")}_S{unloadstartTime.ToString("ss")}.csv";
-                                    }
-                                    WaferManager.Instance.UpdateWaferLotTrackPath((ModuleName)loadedWaferInfoA.Station, loadedWaferInfoA.Slot, strPathLoad);
-                                }
-                            }
-                            if (loadedWaferInfoB != null && !string.IsNullOrEmpty(loadedWaferInfoB.LotId))
-                            {
-                                if (!string.IsNullOrEmpty(loadedWaferInfoB.LotTrackPath))
-                                {
-                                    strPathLoad = loadedWaferInfoB.LotTrackPath;
-                                }
-                                else
-                                {
-                                    int cycleCount = CycleManager.Instance.GetLoadportCycleCount($"LP{loadedWaferInfoB.OriginStation}");
-                                    int cycleSetPoint = CycleManager.Instance.GetLoadportCycleSetPoint($"LP{loadedWaferInfoB.OriginStation}");
-                                    string cycleStr = cycleSetPoint > 1 ? $"-{cycleCount + 1}" : "";
-                                    if (loadedWaferInfoA != null && !string.IsNullOrEmpty(loadedWaferInfoA.LotId) && !loadedWaferInfoA.LotId.Equals(loadedWaferInfoB.LotId))
-                                    {
-                                        int cycleCountA = CycleManager.Instance.GetLoadportCycleCount($"LP{loadedWaferInfoA.OriginStation}");
-                                        int cycleSetPointA = CycleManager.Instance.GetLoadportCycleSetPoint($"LP{loadedWaferInfoA.OriginStation}");
-                                        string cycleStrA = cycleSetPointA > 1 ? $"-{cycleCountA + 1}" : "";
-                                        strPathLoad = $"Auto\\{unloadstartTime.Year}\\{unloadstartTime.Month}\\" + $"{loadedWaferInfoA.LotId}{cycleStrA}-{loadedWaferInfoB.LotId}{cycleStr}_LP{loadedWaferInfoA.OriginStation}-{loadedWaferInfoB.OriginStation}_Slots-{loadedWaferInfoA.OriginSlot + 1}-{(!string.IsNullOrEmpty(loadedWaferInfoB.LotId) ? loadedWaferInfoB.OriginSlot + 1 : 0)}" +
-                                    $"_M{unloadstartTime.ToString("MM")}_D{unloadstartTime.ToString("dd")}_H{unloadstartTime.ToString("HH")}_M{unloadstartTime.ToString("mm")}_S{unloadstartTime.ToString("ss")}.csv";
-                                    }
-                                    else
-                                    {
-                                        strPathLoad = $"Auto\\{unloadstartTime.Year}\\{unloadstartTime.Month}\\" + $"{loadedWaferInfoB.LotId}{cycleStr}_LP{loadedWaferInfoB.OriginStation}_Slots-{(!string.IsNullOrEmpty(loadedWaferInfoA.LotId) ? loadedWaferInfoA.OriginSlot + 1 : 0)}-{loadedWaferInfoB.OriginSlot + 1}" +
-                                    $"_M{unloadstartTime.ToString("MM")}_D{unloadstartTime.ToString("dd")}_H{unloadstartTime.ToString("HH")}_M{unloadstartTime.ToString("mm")}_S{unloadstartTime.ToString("ss")}.csv";
-                                    }
-                                    WaferManager.Instance.UpdateWaferLotTrackPath((ModuleName)loadedWaferInfoB.Station, loadedWaferInfoB.Slot, strPathLoad);
-                                }
-                            }
-                            fiLoad = new FileInfo(PathManager.GetLotTrackFilePath() + strPathLoad);
-                        }
-                        else
-                        {
-                            strPathLoad = $"{moduleName}_M{unloadstartTime.ToString("MM")}_D{unloadstartTime.ToString("dd")}_H{unloadstartTime.ToString("HH")}_M{unloadstartTime.ToString("mm")}_S{unloadstartTime.ToString("ss")}.csv";
-                            fiLoad = new FileInfo(PathManager.GetLotTrackFilePath() + $"Manual\\{unloadstartTime.Year}\\{unloadstartTime.Month}\\" + strPathLoad);
-                        }
-                        _firstWriteFlagLoad = false;
-                        //目录不存在则创建
-                        if (!fiLoad.Directory.Exists)
-                        {
-                            fiLoad.Directory.Create();
-                        }
-                        if (!File.Exists(fiLoad.FullName))
-                        {
-                            _firstWriteFlagLoad = true;
-                        }
-                        FileStream fsLoad = new FileStream(fiLoad.FullName, System.IO.FileMode.Append, System.IO.FileAccess.Write);
-                        StreamWriter swLoad = new StreamWriter(fsLoad, System.Text.Encoding.UTF8);
-
-                        //Header Data load
-                        if (_firstWriteFlagLoad && headerData != null)
-                        {
-                            swLoad.WriteLine(fiLoad.FullName);
-                            swLoad.WriteLine($"Date:{DateTime.Now.ToShortDateString()}");
-                            swLoad.WriteLine($"Tool ID:{headerData.ToolID}");
-                            swLoad.WriteLine($"SW Version:{headerData.SoftWareVersion}");
-                            swLoad.WriteLine($"Sequence Recipe:{headerData.SequenceRecipe}");
-                        }
-                        //输入数据    
-                        //loadWafers
-                        //Unload Datas
-                        if (unloadDatasBufferStatus == LotTrackDatasStatus.None)
-                        {
-                            //unload数据头
-                            if (headerData.ProcessTransferList != null)
-                            {
-                                foreach (var item in headerData.ProcessTransferList)
-                                {
-                                    swLoad.WriteLine(item);
-                                }
-                            }
-                            swLoad.WriteLine($"StartUnloadWaferShuttle:{(unloadTimeList.Count >= 1 ? unloadTimeList[0].ToString() : "")}");
-                            swLoad.WriteLine(moduleName);
-                            swLoad.Write(CVS_SPLIT_CHAR);
-                            string str = $"TimeStamp{CVS_SPLIT_CHAR}LoaderABernoulliBladderEnable{CVS_SPLIT_CHAR}LoaderABernoulliExtended{CVS_SPLIT_CHAR}LoaderABernoulliBladderPressure{CVS_SPLIT_CHAR}" +
-                                $"LoaderABernoulliN2Pressure{CVS_SPLIT_CHAR}LoaderALSVacuum{CVS_SPLIT_CHAR}LoaderALSVacuumAnlg{CVS_SPLIT_CHAR}LoaderATranslatePressure{CVS_SPLIT_CHAR}LoaderAWSPressure" +
-                                $"{CVS_SPLIT_CHAR}LoaderBBernoulliBladderEnable{CVS_SPLIT_CHAR}LoaderBBernoulliExtended{CVS_SPLIT_CHAR}LoaderBBernoulliBladderPressure{CVS_SPLIT_CHAR}" +
-                                $"LoaderBBernoulliN2Pressure{CVS_SPLIT_CHAR}LoaderBLSVacuum{CVS_SPLIT_CHAR}LoaderBLSVacuumAnlg{CVS_SPLIT_CHAR}LoaderBTranslatePressure{CVS_SPLIT_CHAR}LoaderBWSPressure" +
-                                $"{CVS_SPLIT_CHAR}LoaderWSClamped{CVS_SPLIT_CHAR}";
-                            swLoad.WriteLine(str);
-                            //unload数据内容
-                            if (unloadDatasBuffer != null && unloadDatasBuffer.Count != 0)
-                            {
-                                for (int i = 0; i < unloadDatasBuffer.Count; i++)
-                                {
-                                    LoaderLotTrackData data = unloadDatasBuffer[i];
-                                    string tmp = $"{CVS_SPLIT_CHAR}{data.TimeStamp.ToString("HH:mm:ss")}{CVS_SPLIT_CHAR}{data.LoaderABernoulliBladderEnable}{CVS_SPLIT_CHAR}{data.LoaderABernoulliExtended}{CVS_SPLIT_CHAR}{data.LoaderABernoulliBladderPressure}{CVS_SPLIT_CHAR}" +
-                                    $"{data.LoaderABernoulliN2Pressure}{CVS_SPLIT_CHAR}{data.LoaderACRSVacuum}{CVS_SPLIT_CHAR}{data.LoaderACRSVacuumAnlg}{CVS_SPLIT_CHAR}{data.LoaderATranslatePressure}{CVS_SPLIT_CHAR}{data.LoaderAWHPressure}" +
-                                    $"{CVS_SPLIT_CHAR}{data.LoaderBBernoulliBladderEnable}{CVS_SPLIT_CHAR}{data.LoaderBBernoulliExtended}{CVS_SPLIT_CHAR}{data.LoaderBBernoulliBladderPressure}{CVS_SPLIT_CHAR}" +
-                                    $"{data.LoaderBBernoulliN2Pressure}{CVS_SPLIT_CHAR}{data.LoaderBCRSVacuum}{CVS_SPLIT_CHAR}{data.LoaderBCRSVacuumAnlg}{CVS_SPLIT_CHAR}{data.LoaderBTranslatePressure}{CVS_SPLIT_CHAR}{data.LoaderBWHPressure}" +
-                                    $"{CVS_SPLIT_CHAR}{data.LoaderWHClamped}{CVS_SPLIT_CHAR}";
-                                    swLoad.WriteLine(tmp);
-                                }
-                            }
-                            if (unloadTimeList.Count >= 2)
-                            {
-                                swLoad.WriteLine($"FinishUnloadWaferShuttle:{unloadTimeList[1].ToString()}");
-                            }
-                        }
-                        else if (unloadDatasBufferStatus == LotTrackDatasStatus.Half)
-                        {
-                            //unload数据内容
-                            if (unloadDatasBuffer != null && unloadDatasBuffer.Count != 0)
-                            {
-                                for (int i = 0; i < unloadDatasBuffer.Count; i++)
-                                {
-                                    LoaderLotTrackData data = unloadDatasBuffer[i];
-                                    string tmp = $"{CVS_SPLIT_CHAR}{data.TimeStamp.ToString("HH:mm:ss")}{CVS_SPLIT_CHAR}{data.LoaderABernoulliBladderEnable}{CVS_SPLIT_CHAR}{data.LoaderABernoulliExtended}{CVS_SPLIT_CHAR}{data.LoaderABernoulliBladderPressure}{CVS_SPLIT_CHAR}" +
-                                    $"{data.LoaderABernoulliN2Pressure}{CVS_SPLIT_CHAR}{data.LoaderACRSVacuum}{CVS_SPLIT_CHAR}{data.LoaderACRSVacuumAnlg}{CVS_SPLIT_CHAR}{data.LoaderATranslatePressure}{CVS_SPLIT_CHAR}{data.LoaderAWHPressure}" +
-                                    $"{CVS_SPLIT_CHAR}{data.LoaderBBernoulliBladderEnable}{CVS_SPLIT_CHAR}{data.LoaderBBernoulliExtended}{CVS_SPLIT_CHAR}{data.LoaderBBernoulliBladderPressure}{CVS_SPLIT_CHAR}" +
-                                    $"{data.LoaderBBernoulliN2Pressure}{CVS_SPLIT_CHAR}{data.LoaderBCRSVacuum}{CVS_SPLIT_CHAR}{data.LoaderBCRSVacuumAnlg}{CVS_SPLIT_CHAR}{data.LoaderBTranslatePressure}{CVS_SPLIT_CHAR}{data.LoaderBWHPressure}" +
-                                    $"{CVS_SPLIT_CHAR}{data.LoaderWHClamped}{CVS_SPLIT_CHAR}";
-                                    swLoad.WriteLine(tmp);
-                                }
-                            }
-                            if (unloadTimeList.Count >= 2)
-                            {
-                                swLoad.WriteLine($"FinishUnloadWaferShuttle:{unloadTimeList[1].ToString()}");
-                            }
-                        }
-                        //Load Datas
-                        if (loadDatasStatus == LotTrackDatasStatus.None && unloadTimeList.Count >= 2)
-                        {
-                            WaferHolderInfo whInfo = WaferHolderManager.Instance.GetWaferHolder(moduleName);
-                            swLoad.WriteLine($"WaferShuttle:{(whInfo != null ? whInfo.Id : "")}");
-                            swLoad.WriteLine($"LS-A:{(whInfo != null ? whInfo.CrsAId : "")}");
-                            swLoad.WriteLine($"LS-B:{(whInfo != null ? whInfo.CrsBId : "")}");
-                            swLoad.WriteLine($"StartLoadWaferShuttle:{(loadTimeList.Count >= 1 ? loadTimeList[0].ToString() : "")}");
-                            swLoad.WriteLine(moduleName);
-                            swLoad.Write(CVS_SPLIT_CHAR);
-                            string str = $"TimeStamp{CVS_SPLIT_CHAR}LoaderABernoulliBladderEnable{CVS_SPLIT_CHAR}LoaderABernoulliExtended{CVS_SPLIT_CHAR}LoaderABernoulliBladderPressure{CVS_SPLIT_CHAR}" +
-                                $"LoaderABernoulliN2Pressure{CVS_SPLIT_CHAR}LoaderALSVacuum{CVS_SPLIT_CHAR}LoaderALSVacuumAnlg{CVS_SPLIT_CHAR}LoaderATranslatePressure{CVS_SPLIT_CHAR}LoaderAWSPressure" +
-                                $"{CVS_SPLIT_CHAR}LoaderBBernoulliBladderEnable{CVS_SPLIT_CHAR}LoaderBBernoulliExtended{CVS_SPLIT_CHAR}LoaderBBernoulliBladderPressure{CVS_SPLIT_CHAR}" +
-                                $"LoaderBBernoulliN2Pressure{CVS_SPLIT_CHAR}LoaderBLSVacuum{CVS_SPLIT_CHAR}LoaderBLSVacuumAnlg{CVS_SPLIT_CHAR}LoaderBTranslatePressure{CVS_SPLIT_CHAR}LoaderBWSPressure" +
-                                $"{CVS_SPLIT_CHAR}LoaderWSClamped{CVS_SPLIT_CHAR}";
-                            swLoad.WriteLine(str);
-                            if (loadDatas != null && loadDatas.Count != 0)
-                            {
-                                for (int i = 0; i < loadDatas.Count; i++)
-                                {
-                                    LoaderLotTrackData data = loadDatas[i];
-                                    string tmp = $"{CVS_SPLIT_CHAR}{data.TimeStamp.ToString("HH:mm:ss")}{CVS_SPLIT_CHAR}{data.LoaderABernoulliBladderEnable}{CVS_SPLIT_CHAR}{data.LoaderABernoulliExtended}{CVS_SPLIT_CHAR}{data.LoaderABernoulliBladderPressure}{CVS_SPLIT_CHAR}" +
-                                    $"{data.LoaderABernoulliN2Pressure}{CVS_SPLIT_CHAR}{data.LoaderACRSVacuum}{CVS_SPLIT_CHAR}{data.LoaderACRSVacuumAnlg}{CVS_SPLIT_CHAR}{data.LoaderATranslatePressure}{CVS_SPLIT_CHAR}{data.LoaderAWHPressure}" +
-                                    $"{CVS_SPLIT_CHAR}{data.LoaderBBernoulliBladderEnable}{CVS_SPLIT_CHAR}{data.LoaderBBernoulliExtended}{CVS_SPLIT_CHAR}{data.LoaderBBernoulliBladderPressure}{CVS_SPLIT_CHAR}" +
-                                    $"{data.LoaderBBernoulliN2Pressure}{CVS_SPLIT_CHAR}{data.LoaderBCRSVacuum}{CVS_SPLIT_CHAR}{data.LoaderBCRSVacuumAnlg}{CVS_SPLIT_CHAR}{data.LoaderBTranslatePressure}{CVS_SPLIT_CHAR}{data.LoaderBWHPressure}" +
-                                    $"{CVS_SPLIT_CHAR}{data.LoaderWHClamped}{CVS_SPLIT_CHAR}";
-                                    swLoad.WriteLine(tmp);
-                                }
-                            }
-                            if (loadTimeList.Count >= 2)
-                            {
-                                swLoad.WriteLine($"FinishLoadWaferShuttle:{loadTimeList[1].ToString()}");
-                            }
-                        }
-                        else if (loadDatasStatus == LotTrackDatasStatus.Half && unloadTimeList.Count >= 2)
-                        {
-                            if (loadDatas != null && loadDatas.Count != 0)
-                            {
-                                for (int i = 0; i < loadDatas.Count; i++)
-                                {
-                                    LoaderLotTrackData data = loadDatas[i];
-                                    string tmp = $"{CVS_SPLIT_CHAR}{data.TimeStamp.ToString("HH:mm:ss")}{CVS_SPLIT_CHAR}{data.LoaderABernoulliBladderEnable}{CVS_SPLIT_CHAR}{data.LoaderABernoulliExtended}{CVS_SPLIT_CHAR}{data.LoaderABernoulliBladderPressure}{CVS_SPLIT_CHAR}" +
-                                    $"{data.LoaderABernoulliN2Pressure}{CVS_SPLIT_CHAR}{data.LoaderACRSVacuum}{CVS_SPLIT_CHAR}{data.LoaderACRSVacuumAnlg}{CVS_SPLIT_CHAR}{data.LoaderATranslatePressure}{CVS_SPLIT_CHAR}{data.LoaderAWHPressure}" +
-                                    $"{CVS_SPLIT_CHAR}{data.LoaderBBernoulliBladderEnable}{CVS_SPLIT_CHAR}{data.LoaderBBernoulliExtended}{CVS_SPLIT_CHAR}{data.LoaderBBernoulliBladderPressure}{CVS_SPLIT_CHAR}" +
-                                    $"{data.LoaderBBernoulliN2Pressure}{CVS_SPLIT_CHAR}{data.LoaderBCRSVacuum}{CVS_SPLIT_CHAR}{data.LoaderBCRSVacuumAnlg}{CVS_SPLIT_CHAR}{data.LoaderBTranslatePressure}{CVS_SPLIT_CHAR}{data.LoaderBWHPressure}" +
-                                    $"{CVS_SPLIT_CHAR}{data.LoaderWHClamped}{CVS_SPLIT_CHAR}";
-                                    swLoad.WriteLine(tmp);
-                                }
-                            }
-                            if (loadTimeList.Count >= 2)
-                            {
-                                swLoad.WriteLine($"FinishLoadWaferShuttle:{loadTimeList[1].ToString()}");
-                            }
-                        }
-                        //Flow Datas
-                        if (flowTestDatasStatus == LotTrackDatasStatus.None && unloadTimeList.Count >= 2 && loadTimeList.Count >= 2)
-                        {
-                            if (flowDatas != null && flowDatas.Count != 0)
-                            {
-                                swLoad.WriteLine(moduleName);
-                                swLoad.Write(CVS_SPLIT_CHAR);
-
-                                string str = $"TimeStamp{CVS_SPLIT_CHAR}LoaderWSClamped{CVS_SPLIT_CHAR}LoaderALSVacuum{CVS_SPLIT_CHAR}" +
-                                    $"LoaderALSVacuumAnlg{CVS_SPLIT_CHAR}LoaderBLSVacuum{CVS_SPLIT_CHAR}LoaderBLSVacuumAnlg{CVS_SPLIT_CHAR}" +
-                                    $"EnableVacuum{CVS_SPLIT_CHAR}EnableFlowClamp{CVS_SPLIT_CHAR}Flow{CVS_SPLIT_CHAR}";
-                                swLoad.WriteLine(str);
-
-                                for (int i = 0; i < flowDatas.Count; i++)
-                                {
-                                    LoaderFlowLotTrackData data = flowDatas[i];
-                                    string tmp = $"{CVS_SPLIT_CHAR}{data.TimeStamp.ToString("HH:mm:ss")}{CVS_SPLIT_CHAR}{data.LoaderWHClamped}{CVS_SPLIT_CHAR}{data.LoaderACRSVacuum}{CVS_SPLIT_CHAR}" +
-                                    $"{data.LoaderACRSVacuumAnlg}{CVS_SPLIT_CHAR}{data.LoaderBCRSVacuum}{CVS_SPLIT_CHAR}{data.LoaderBCRSVacuumAnlg}{CVS_SPLIT_CHAR}" +
-                                    $"{data.EnableVacuum}{CVS_SPLIT_CHAR}{data.EnableFlowClamp}{CVS_SPLIT_CHAR}{data.FlowValue}{CVS_SPLIT_CHAR}";
-                                    swLoad.WriteLine(tmp);
-                                }
-                                swLoad.WriteLine("");
-                            }
-
-                        }
-                        swLoad.Close();
-                        fsLoad.Close();
-                    }                              
-                }
-                catch
-                {
-                    LOG.WriteLog(eEvent.ERR_LOADER, moduleName, $"{moduleName} LotTrack file writing is failed!");
-                }
-            });
-            
-        }
-
-    }
-}

CyberX8_RT/Modules/Loader/LoaderEntity.cs

@@ -28,6 +28,7 @@ using MECF.Framework.Common.CommonData.Loader;
 using Aitex.Core.Common;
 using MECF.Framework.RT.Core.Equipments;
 using CyberX8_RT.Modules.Dryer;
+using System.Runtime.CompilerServices;
 
 namespace CyberX8_RT.Modules.Loader
 {
@@ -191,50 +192,34 @@ namespace CyberX8_RT.Modules.Loader
         /// <summary>
         /// Load LotTrackData
         /// </summary>
-        private List<LoaderLotTrackData> _loadLotTrackDatas = new List<LoaderLotTrackData>();
+        private List<LoaderLotTrackData> _loaderLotTrackDatas = new List<LoaderLotTrackData>();     
         /// <summary>
-        /// UnLoad LotTrackData
+        /// Flow Test LotTrackData
         /// </summary>
-        private List<LoaderLotTrackData> _unloadLotTrackDatas = new List<LoaderLotTrackData>();
+        private List<LoaderFlowLotTrackData> _flowLotTrackDatas = new List<LoaderFlowLotTrackData>();
         /// <summary>
-        /// UnLoad LotTrackDataBuffer
+        /// Load / Unload Time
         /// </summary>
-        private List<LoaderLotTrackData> _unloadLotTrackDatasBuffer = new List<LoaderLotTrackData>();
+        private List<DateTime> _timeList = new List<DateTime>();
         /// <summary>
-        /// LeakTest LotTrackData
+        /// Load Start Time(file name)
         /// </summary>
-        private List<LoaderFlowLotTrackData> _flowLotTrackdatas = new List<LoaderFlowLotTrackData>();
-        /// <summary>
-        /// LoadTime
-        /// </summary>
-        private List<DateTime> _loadTimeList = new List<DateTime>();
-        /// <summary>
-        /// LoadTime
-        /// </summary>
-        private List<DateTime> _unloadTimeList = new List<DateTime>();
-        /// <summary>
-        /// Unload Start Time
-        /// </summary>
-        private DateTime _unloadStartTime;
+        private DateTime _startTime;
         /// <summary>
         /// LotTrackHead
         /// </summary>
         private LotTrackFileHeaderCommonData _headerdata;
         /// <summary>
         /// Load Datas Status
-        private LotTrackDatasStatus _loadDatasStatus = LotTrackDatasStatus.None;
-        /// <summary>
-        /// Unload Datas Status
-        /// </summary>
-        private LotTrackDatasStatus _unloadDatasStatus = LotTrackDatasStatus.None;
+        private LotTrackDatasStatus _datasStatus = LotTrackDatasStatus.None;
         /// <summary>
-        /// Unload Datas Buffer Status
+        /// Flow Test Datas status
         /// </summary>
-        private LotTrackDatasStatus _unloadDatasBufferStatus = LotTrackDatasStatus.None;
+        private LotTrackDatasStatus _flowDatasStatus = LotTrackDatasStatus.None;
         /// <summary>
-        /// Flow Test Datas status
+        /// WaferGroup str
         /// </summary>
-        private LotTrackDatasStatus _flowTestDatasStatus = LotTrackDatasStatus.None;
+        private string _preWaferGroup = "";
         #endregion
         #endregion
 
@@ -417,8 +402,9 @@ namespace CyberX8_RT.Modules.Loader
                 WaferHolderInfo info = WaferHolderManager.Instance.GetWaferHolder(Module.ToString());
                 _headerdata.SequenceRecipe = (info != null ? $"{info.SequenceRecipe.SequenceType}\\" + $"{info.SequenceRecipe.Ppid}.seq.rcp" : null);
                 _headerdata.ProcessTransferList = (info != null ? info.SchedulerModules : null);
-                LoaderLotTrackUtil.ExportLoaderLotTrack(Module.ToString(), _unloadLotTrackDatas, _loadLotTrackDatas, _flowLotTrackdatas, _headerdata, _loaderOperatingWaferInfosList, 
-                    _loadTimeList, _unloadTimeList, _unloadStartTime, LotTrackDatasStatus.None, LotTrackDatasStatus.None, LotTrackDatasStatus.None, _unloadLotTrackDatasBuffer, LotTrackDatasStatus.None);
+                WaferInfo waferInfo = WaferManager.Instance.GetWafer(Module, _unloadSideRoutine.IsSideA ? 0 : 1);
+                LoaderLotTrackUtil.ExportLoaderLotTrack(Module.ToString(), _headerdata, _loaderLotTrackDatas, _datasStatus, _timeList, waferInfo,
+                    "SeqGroup", false, _startTime, _flowLotTrackDatas, _flowDatasStatus);
             }            
 
             return true;
@@ -571,23 +557,10 @@ namespace CyberX8_RT.Modules.Loader
         {
             bool result= _unloadSideRoutine.Start(param) == RState.Running;
             if(result)
-            {
-                LotTrackDataClear();
-                _currentRoutine = _unloadSideRoutine;                
-                _unloadLotTrackDatas.Clear();
-                _unloadLotTrackDatasBuffer.Clear();
-                _unloadTimeList.Clear();
-                _unloadTimeList.Add(DateTime.Now);
-                _unloadStartTime = DateTime.Now;
-                _loaderOperatingWaferInfosList["unload"] = GetWaferInfo();
-                //Header信息
-                _headerdata = new LotTrackFileHeaderCommonData();
-                _headerdata.SoftWareVersion = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString();               
-                if (SC.ContainsItem("System.ToolID")) _headerdata.ToolID = SC.GetStringValue("System.ToolID");
-                _loadDatasStatus = LotTrackDatasStatus.None;
-                _unloadDatasStatus = LotTrackDatasStatus.None;
-                _flowTestDatasStatus = LotTrackDatasStatus.None;
-                _headerdata.ProcessTransferList = new List<string>();
+            {       
+                _currentRoutine = _unloadSideRoutine;
+                InitLotTrackDatas();
+                _timeList.Add(DateTime.Now);
             }
             return result;
         }
@@ -602,8 +575,8 @@ namespace CyberX8_RT.Modules.Loader
             bool result = _unloadSideRoutine.Retry(stepIndex)==RState.Running;
             if (result)
             {
-                _unloadDatasStatus = LotTrackDatasStatus.Half;
-                _unloadLotTrackDatas.Clear();
+                _datasStatus = LotTrackDatasStatus.Half;
+                _loaderLotTrackDatas.Clear();
                 _currentRoutine = _unloadSideRoutine;
             }
             return result;
@@ -619,17 +592,19 @@ namespace CyberX8_RT.Modules.Loader
             if (ret == RState.End)
             {
                 AlarmListManager.Instance.CheckModuleAlamAndRemove(Module.ToString(), LOADERSTATE.Unloading.ToString());
-                _unloadLotTrackDatas = _unloadSideRoutine.UnloadLotTrackDatas;
-                _unloadLotTrackDatasBuffer.AddRange(_unloadSideRoutine.UnloadLotTrackDatas);
-                _unloadTimeList.Add(DateTime.Now);
 
+                _loaderLotTrackDatas.AddRange(_unloadSideRoutine.UnloadLotTrackDatas);
+                _timeList.Add(DateTime.Now);
                 //Header信息
                 WaferHolderInfo info = WaferHolderManager.Instance.GetWaferHolder(Module.ToString());
-                _headerdata.SequenceRecipe = ((info != null && info.SequenceRecipe != null) ? $"{info.SequenceRecipe.SequenceType}\\" + $"{info.SequenceRecipe.Ppid}.seq.rcp" : "");           
-                if (info != null) _headerdata.ProcessTransferList.AddRange(info.SchedulerModules);
-                info.SchedulerModules.Clear();
-                LoaderLotTrackUtil.ExportLoaderLotTrack(Module.ToString(), _unloadLotTrackDatas, _loadLotTrackDatas, _flowLotTrackdatas, _headerdata, _loaderOperatingWaferInfosList,
-                    _loadTimeList, _unloadTimeList, _unloadStartTime, _unloadDatasStatus, _loadDatasStatus, _flowTestDatasStatus, _unloadLotTrackDatasBuffer, _unloadDatasStatus, true);
+                _headerdata.SequenceRecipe = ((info != null && info.SequenceRecipe != null) ? $"{info.SequenceRecipe.SequenceType}\\" + $"{info.SequenceRecipe.Ppid}.seq.rcp" : "");
+                if (info != null)
+                {
+                    _headerdata.ProcessTransferList.AddRange(info.SchedulerModules);
+                    info.SchedulerModules.Clear();
+                }
+                WaferInfo waferInfo = WaferManager.Instance.GetWafer(Module, _unloadSideRoutine.IsSideA ? 0 : 1);
+                LoaderLotTrackUtil.ExportLoaderLotTrack(Module.ToString(), _headerdata, _loaderLotTrackDatas, _datasStatus, _timeList, waferInfo, _unloadSideRoutine.WaferGroup, false, _startTime);
                 return true;
             }
             if (ret == RState.Failed || ret == RState.Timeout)
@@ -641,15 +616,17 @@ namespace CyberX8_RT.Modules.Loader
                     AlarmListManager.Instance.AddAlarm(alarmList);
                 }
                 PostMsg(LoaderMSG.Error);
-                _unloadLotTrackDatas = _unloadSideRoutine.UnloadLotTrackDatas;
-                _unloadLotTrackDatasBuffer.AddRange(_unloadSideRoutine.UnloadLotTrackDatas);
+                _loaderLotTrackDatas.AddRange(_unloadSideRoutine.UnloadLotTrackDatas);
                 ////Header信息
                 WaferHolderInfo info = WaferHolderManager.Instance.GetWaferHolder(Module.ToString());
                 _headerdata.SequenceRecipe = ((info != null && info.SequenceRecipe != null) ? $"{info.SequenceRecipe.SequenceType}\\" + $"{info.SequenceRecipe.Ppid}.seq.rcp" : "");
-                if (info != null) _headerdata.ProcessTransferList.AddRange(info.SchedulerModules);
-                info.SchedulerModules.Clear();
-                LoaderLotTrackUtil.ExportLoaderLotTrack(Module.ToString(), _unloadLotTrackDatas, _loadLotTrackDatas, _flowLotTrackdatas, _headerdata, _loaderOperatingWaferInfosList, 
-                    _loadTimeList, _unloadTimeList, _unloadStartTime, _unloadDatasStatus, _loadDatasStatus, _flowTestDatasStatus, _unloadLotTrackDatasBuffer, _unloadDatasStatus, true);
+                if (info != null)
+                {
+                    _headerdata.ProcessTransferList.AddRange(info.SchedulerModules);
+                    info.SchedulerModules.Clear();
+                }
+                WaferInfo waferInfo = WaferManager.Instance.GetWafer(Module, _unloadSideRoutine.IsSideA ? 0 : 1);
+                LoaderLotTrackUtil.ExportLoaderLotTrack(Module.ToString(), _headerdata, _loaderLotTrackDatas, _datasStatus, _timeList, waferInfo, _unloadSideRoutine.WaferGroup, false, _startTime);
             }
             return false;
         }
@@ -684,7 +661,6 @@ namespace CyberX8_RT.Modules.Loader
 
         #endregion
 
-
         #region Load Side
         /// <summary>
         /// Load Side
@@ -697,13 +673,7 @@ namespace CyberX8_RT.Modules.Loader
             if(result)
             {
                 _currentRoutine = _loadSideRoutine;
-                //_loadTimeList.Clear();
-                _flowLotTrackdatas.Clear();
-                _loadLotTrackDatas.Clear();
-                _loadDatasStatus = LotTrackDatasStatus.None;
-                _flowTestDatasStatus = LotTrackDatasStatus.None;
-                _unloadDatasStatus = LotTrackDatasStatus.Complete;
-                _unloadDatasBufferStatus = LotTrackDatasStatus.None;
+                InitLotTrackDatas();
             }
             return result;
         }
@@ -719,8 +689,6 @@ namespace CyberX8_RT.Modules.Loader
             bool result = _loadSideRoutine.Retry(stepIndex) == RState.Running;
             if (result)
             {
-                _unloadDatasStatus = LotTrackDatasStatus.Complete;
-                _unloadDatasBufferStatus = LotTrackDatasStatus.Complete;
                 SetLotTrackDatasStatus(stepIndex);               
                 _currentRoutine = _loadSideRoutine;
             }
@@ -739,18 +707,21 @@ namespace CyberX8_RT.Modules.Loader
             {
                 AlarmListManager.Instance.CheckModuleAlamAndRemove(Module.ToString(), LOADERSTATE.Loading.ToString());
 
-                _loadLotTrackDatas = _loadSideRoutine.LoadLotTrackDatas;
-                _loadTimeList = _loadSideRoutine.LoadTimeList;
-                _flowLotTrackdatas = _loadSideRoutine.FlowLotTrackDatas;
-                bool clearFlag = _loadDatasStatus == LotTrackDatasStatus.None && _flowTestDatasStatus == LotTrackDatasStatus.None;
-                _loaderOperatingWaferInfosList["load"] = GetWaferInfo(clearFlag);
+                _loaderLotTrackDatas.AddRange(_loadSideRoutine.LoadLotTrackDatas);
+                _timeList.AddRange(_loadSideRoutine.LoadTimeList);
+                _flowLotTrackDatas.AddRange(_loadSideRoutine.FlowLotTrackDatas);
                 //Header信息
                 WaferHolderInfo info = WaferHolderManager.Instance.GetWaferHolder(Module.ToString());
                 _headerdata.SequenceRecipe = ((info != null && info.SequenceRecipe != null) ? $"{info.SequenceRecipe.SequenceType}\\" + $"{info.SequenceRecipe.Ppid}.seq.rcp" : "");
-                if(info != null) _headerdata.ProcessTransferList.AddRange(info.SchedulerModules);
-                info.SchedulerModules.Clear();
-                LoaderLotTrackUtil.ExportLoaderLotTrack(Module.ToString(), _unloadLotTrackDatas, _loadLotTrackDatas, _flowLotTrackdatas, _headerdata, _loaderOperatingWaferInfosList, 
-                    _loadTimeList, _unloadTimeList,_unloadStartTime, _unloadDatasStatus, _loadDatasStatus, _flowTestDatasStatus, _unloadLotTrackDatasBuffer, _unloadDatasBufferStatus);
+                if (info != null)
+                {
+                    _headerdata.ProcessTransferList.AddRange(info.SchedulerModules);
+                    info.SchedulerModules.Clear();
+                }                   
+                WaferInfo waferInfo = WaferManager.Instance.GetWafer(Module, _loadSideRoutine.IsSideA ? 0 : 1);
+                CheckStartTime(_loadSideRoutine.WaferGroup);
+                LoaderLotTrackUtil.ExportLoaderLotTrack(Module.ToString(), _headerdata, _loaderLotTrackDatas, _datasStatus, _timeList, 
+                    waferInfo, _loadSideRoutine.WaferGroup, true, _startTime, _flowLotTrackDatas, _flowDatasStatus);
 
                 return true;
             }
@@ -763,18 +734,20 @@ namespace CyberX8_RT.Modules.Loader
                     AlarmListManager.Instance.AddAlarm(alarmList);
                 }
                 PostMsg(LoaderMSG.Error);
-                _loadLotTrackDatas = _loadSideRoutine.LoadLotTrackDatas;
-                _loadTimeList = _loadSideRoutine.LoadTimeList;
-                _flowLotTrackdatas = _loadSideRoutine.FlowLotTrackDatas;
-                bool clearFlag = _loadDatasStatus == LotTrackDatasStatus.None && _flowTestDatasStatus == LotTrackDatasStatus.None;
-                _loaderOperatingWaferInfosList["load"] = GetWaferInfo(clearFlag);
+                _loaderLotTrackDatas.AddRange(_loadSideRoutine.LoadLotTrackDatas);
+                _timeList.AddRange(_loadSideRoutine.LoadTimeList);
+                _flowLotTrackDatas.AddRange(_loadSideRoutine.FlowLotTrackDatas);
                 //Header信息
                 WaferHolderInfo info = WaferHolderManager.Instance.GetWaferHolder(Module.ToString());
                 _headerdata.SequenceRecipe = ((info != null && info.SequenceRecipe != null) ? $"{info.SequenceRecipe.SequenceType}\\" + $"{info.SequenceRecipe.Ppid}.seq.rcp" : "");
-                if (info != null) _headerdata.ProcessTransferList.AddRange(info.SchedulerModules);
-                info.SchedulerModules.Clear();
-                LoaderLotTrackUtil.ExportLoaderLotTrack(Module.ToString(), _unloadLotTrackDatas, _loadLotTrackDatas, _flowLotTrackdatas, _headerdata, _loaderOperatingWaferInfosList, 
-                    _loadTimeList, _unloadTimeList, _unloadStartTime, _unloadDatasStatus, _loadDatasStatus, _flowTestDatasStatus, _unloadLotTrackDatasBuffer, _unloadDatasBufferStatus);
+                if (info != null) 
+                {
+                    _headerdata.ProcessTransferList.AddRange(info.SchedulerModules);
+                    info.SchedulerModules.Clear();
+                }
+                WaferInfo waferInfo = WaferManager.Instance.GetWafer(Module, _loadSideRoutine.IsSideA ? 0 : 1);
+                LoaderLotTrackUtil.ExportLoaderLotTrack(Module.ToString(), _headerdata, _loaderLotTrackDatas, _datasStatus, _timeList,
+                    waferInfo, _loadSideRoutine.WaferGroup, true, _startTime, _flowLotTrackDatas, _flowDatasStatus);
             }
             return false;
         }
@@ -808,58 +781,62 @@ namespace CyberX8_RT.Modules.Loader
         }
         #endregion
 
-        #region LotTrack      
+        #region LotTrack
         /// <summary>
-        /// 获取Wafer信息
+        /// Init LotTrackDatas
         /// </summary>
-        private List<string> GetWaferInfo(bool clearPath = false)
+        private void InitLotTrackDatas()
         {
-            List<string> waferIDs = new List<string>(new string[2]);
-            WaferHolderInfo whInfo = WaferHolderManager.Instance.GetWaferHolder(Module.ToString());
-            if (whInfo == null) return null;
-            waferIDs[0] = string.IsNullOrEmpty(whInfo.WaferAId) ? "" : whInfo.WaferAId;
-            waferIDs[1] = string.IsNullOrEmpty(whInfo.WaferBId) ? "" : whInfo.WaferBId;
-            if (clearPath && !string.IsNullOrEmpty(waferIDs[0])) WaferManager.Instance.ClearWaferLotTrackPath(ModuleName.Loader1, 0);
-            if (clearPath && !string.IsNullOrEmpty(waferIDs[1])) WaferManager.Instance.ClearWaferLotTrackPath(ModuleName.Loader1, 1);
-            return waferIDs;
-        }
-        /// <summary>
-        /// 清除信息
-        /// </summary>
-        private void LotTrackDataClear()
-        {
-            _headerdata = null;
-            _loadLotTrackDatas.Clear();
-            _unloadLotTrackDatas.Clear();
-            _flowLotTrackdatas.Clear();
-            _loadTimeList.Clear();
-            _unloadTimeList.Clear();
-            _loaderOperatingWaferInfosList["load"].Clear();
-            _loaderOperatingWaferInfosList["unload"].Clear();
+            _loaderLotTrackDatas.Clear();
+            _flowLotTrackDatas.Clear();
+            _timeList.Clear();
+            
+            //Header信息
+            _headerdata = new LotTrackFileHeaderCommonData();
+            _headerdata.SoftWareVersion = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString();
+            if (SC.ContainsItem("System.ToolID")) _headerdata.ToolID = SC.GetStringValue("System.ToolID");
+            _headerdata.ProcessTransferList = new List<string>();
+           
+            _datasStatus = LotTrackDatasStatus.None;
+            _flowDatasStatus = LotTrackDatasStatus.None;
         }
         /// <summary>
-        /// 设置Load LotTrackDatas记录状态
+        /// Set LotTrack Datas Status
         /// </summary>
         /// <param name="stepIndex"></param>
         private void SetLotTrackDatasStatus(int stepIndex)
         {
             if (stepIndex == 0 || stepIndex == -1)
             {
-                _loadDatasStatus = LotTrackDatasStatus.Half;
-                _flowTestDatasStatus = LotTrackDatasStatus.None;
+                _datasStatus = LotTrackDatasStatus.Half;
+                _flowDatasStatus = LotTrackDatasStatus.None;
             }
             else if (stepIndex == 1)
             {
-                _loadDatasStatus = LotTrackDatasStatus.Complete;
-                _flowTestDatasStatus = LotTrackDatasStatus.None;
+                _datasStatus = LotTrackDatasStatus.Complete;
+                _flowDatasStatus = LotTrackDatasStatus.None;
             }
             else
             {
-                _loadDatasStatus = LotTrackDatasStatus.Complete;
-                _flowTestDatasStatus = LotTrackDatasStatus.Complete;
+                _datasStatus = LotTrackDatasStatus.Complete;
+                _flowDatasStatus = LotTrackDatasStatus.Complete;
             }
-
-        }       
+            _loaderLotTrackDatas.Clear();
+            _flowLotTrackDatas.Clear();
+        }
+        /// <summary>
+        /// Check WaferGroup change
+        /// </summary>
+        /// <param name="currentGroupWafer"></param>
+        /// <returns></returns>
+        private void CheckStartTime(string currentWaferGroup)
+        {
+            if (!currentWaferGroup.Equals(_preWaferGroup))
+            {
+                _preWaferGroup = currentWaferGroup;
+                _startTime = _timeList[0];
+            }          
+        }
         #endregion
 
         #region LoaderRetry

CyberX8_RT/Modules/Loader/LoaderLoadSideRoutine.cs

@@ -7,16 +7,9 @@ using CyberX8_RT.Devices.AXIS;
 using CyberX8_RT.Devices.Loader;
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using MECF.Framework.Common.Utilities;
 using Aitex.Core.RT.Log;
 using MECF.Framework.Common.CommonData.Loader;
-using CyberX8_RT.Modules.Dryer;
-using MECF.Framework.Common.Persistent.Temperature;
 using MECF.Framework.Common.WaferHolder;
-using Aitex.Core.Common;
 using Aitex.Core.RT.SCCore;
 using Aitex.Core.Util;
 
@@ -110,6 +103,10 @@ namespace CyberX8_RT.Modules.Loader
         /// Wafer组
         /// </summary>
         public string WaferGroup { get { return _waferGroup; } }
+        /// <summary>
+        /// is SideA
+        /// </summary>
+        public bool IsSideA { get { return _side == "A" ? true : false; } }
         #endregion
 
         /// <summary>
@@ -477,14 +474,24 @@ namespace CyberX8_RT.Modules.Loader
                 LoaderLotTrackData data = new LoaderLotTrackData();
                 data.TimeStamp = DateTime.Now;
 
-                data.LoaderABernoulliBladderEnable = _loaderSide.SideData.BernoulliBladder;
-                data.LoaderABernoulliExtended = _loaderSide.SideData.BernoulliExtended;
-                data.LoaderABernoulliBladderPressure = _loaderSide.SideData.BernoulliBladderPressure;
-                data.LoaderABernoulliN2Pressure = _loaderSide.SideData.BernoulliPressure;                
-                data.LoaderACRSVacuum = _loaderSide.SideData.CRSVacuum;
-                data.LoaderACRSVacuumAnlg = _loaderSide.SideData.CRSVacuumValue;
-                data.LoaderAWHPressure = _loaderSide.SideData.WHBladderPressure;
-                data.LoaderATranslatePressure = _loaderSide.SideData.TransPressure;
+                if (_side == SIDE_A)
+                {
+                    data.LoaderABernoulliBladderEnable = _loaderSide.SideData.BernoulliBladder;
+                    data.LoaderABernoulliBladderPressure = _loaderSide.SideData.BernoulliBladderPressure;
+                    data.LoaderABernoulliN2Pressure = _loaderSide.SideData.BernoulliPressure;
+                    data.LoaderACRSVacuum = _loaderSide.SideData.CRSVacuum;
+                    data.LoaderACRSVacuumAnlg = _loaderSide.SideData.CRSVacuumValue;
+                    data.LoaderAWHPressure = _loaderSide.SideData.WHBladderPressure;
+                }
+                else
+                {
+                    data.LoaderBBernoulliBladderEnable = _loaderSide.SideData.BernoulliBladder;
+                    data.LoaderBBernoulliBladderPressure = _loaderSide.SideData.BernoulliBladderPressure;
+                    data.LoaderBBernoulliN2Pressure = _loaderSide.SideData.BernoulliPressure;
+                    data.LoaderBCRSVacuum = _loaderSide.SideData.CRSVacuum;
+                    data.LoaderBCRSVacuumAnlg = _loaderSide.SideData.CRSVacuumValue;
+                    data.LoaderBWHPressure = _loaderSide.SideData.WHBladderPressure;
+                }
 
                 data.LoaderWHClamped = _loaderCommon.CommonData.WaferHolderClamp;
 

CyberX8_RT/Modules/Loader/LoaderLotTrackUtil.cs

@@ -0,0 +1,168 @@
+using MECF.Framework.Common.CommonData;
+using System;
+using System.Collections.Generic;
+using Aitex.Core.Common;
+using System.Threading.Tasks;
+using MECF.Framework.Common.CommonData.Loader;
+using static CyberX8_RT.Modules.Loader.LoaderEntity;
+using System.IO;
+using Aitex.Common.Util;
+using CyberX8_RT.Dispatch;
+using MECF.Framework.Common.WaferHolder;
+using Aitex.Core.RT.Log;
+using MECF.Framework.Common.Equipment;
+using MECF.Framework.Common.SubstrateTrackings;
+
+namespace CyberX8_RT.Modules.Loader
+{
+    public class LoaderLotTrackUtil
+    {
+        /// <summary>
+        /// CSV文件分隔符
+        /// </summary>
+        private const char CVS_SPLIT_CHAR = ',';
+        /// <summary>
+        /// 首次写入
+        /// </summary>
+        private static bool _firstWriteFlag;
+        /// <summary>
+        /// 导出至csv
+        /// </summary>
+        /// <param name="moduleName"></param>
+        /// <param name="datas"></param>
+        public static async void ExportLoaderLotTrack(string moduleName, LotTrackFileHeaderCommonData headerData, List<LoaderLotTrackData> loaderDatas,
+            LotTrackDatasStatus datasStatus, List<DateTime> timeList, WaferInfo waferInfo, string waferGroup, bool isLoad, DateTime startTime,
+            List<LoaderFlowLotTrackData> flowDatas = null, LotTrackDatasStatus flowDatasStatus = LotTrackDatasStatus.Complete)
+        {
+            await Task.Run(() =>
+            {
+                try{
+                    //文件流处理
+                    string strPath = "";
+                    FileInfo fi;
+
+                    if (waferInfo != null && waferInfo.WaferType == WaferType.Production && !string.IsNullOrEmpty(waferInfo.LotId))
+                    {
+                        if (!string.IsNullOrEmpty(waferInfo.LotTrackPath))
+                        {
+                            strPath = waferInfo.LotTrackPath;
+                        }
+                        else 
+                        {
+                            strPath = $"Auto\\{startTime.Year}\\{startTime.Month}\\{waferGroup}" +
+                            $"_M{startTime.ToString("MM")}_D{startTime.ToString("dd")}_H{startTime.ToString("HH")}_M{startTime.ToString("mm")}_S{startTime.ToString("ss")}.csv"; ;
+                            WaferManager.Instance.UpdateWaferLotTrackPath((ModuleName)waferInfo.Station, waferInfo.Slot, strPath);
+                        }          
+                        fi = new FileInfo(PathManager.GetLotTrackFilePath() + strPath);                        
+                    }
+                    else
+                    {
+                        strPath = $"{moduleName}_M{timeList[0].ToString("MM")}_D{timeList[0].ToString("dd")}_H{timeList[0].ToString("HH")}_M{timeList[0].ToString("mm")}_S{timeList[0].ToString("ss")}.csv";
+                        fi = new FileInfo(PathManager.GetLotTrackFilePath() + $"Manual\\{timeList[0].Year}\\{timeList[0].Month}\\" + strPath);
+                    }
+                    _firstWriteFlag = false;
+                    //目录不存在则创建
+                    if (!fi.Directory.Exists)
+                    {
+                        fi.Directory.Create();
+                    }
+                    if (!File.Exists(fi.FullName))
+                    {
+                        _firstWriteFlag = true;
+                    }
+                    FileStream fs = new FileStream(fi.FullName, System.IO.FileMode.Append, System.IO.FileAccess.Write);
+                    StreamWriter sw = new StreamWriter(fs, System.Text.Encoding.UTF8);
+                    //Header Data
+                    if (_firstWriteFlag && headerData != null)
+                    {
+                        sw.WriteLine(fi.FullName);
+                        sw.WriteLine($"Date:{DateTime.Now.ToShortDateString()}");
+                        sw.WriteLine($"Tool ID:{headerData.ToolID}");
+                        sw.WriteLine($"SW Version:{headerData.SoftWareVersion}");
+                        sw.WriteLine($"Sequence Recipe:{headerData.SequenceRecipe}");
+                        WaferHolderInfo whInfo = WaferHolderManager.Instance.GetWaferHolder(moduleName);
+                        sw.WriteLine($"WaferShuttle ID:{(whInfo != null ? whInfo.Id : "")}");
+                        sw.WriteLine($"LS-A ID:{(whInfo != null ? whInfo.CrsAId : "")}");
+                        sw.WriteLine($"LS-B ID:{(whInfo != null ? whInfo.CrsBId : "")}");
+                        sw.WriteLine("");
+                    }
+                    //Loader Datas
+                    if (loaderDatas != null && loaderDatas.Count != 0 && datasStatus != LotTrackDatasStatus.Complete)
+                    {
+                        //数据头 
+                        if (datasStatus == LotTrackDatasStatus.None)
+                        {
+                            sw.WriteLine($"Wafer ID:{waferInfo.WaferID}");
+                            if (headerData.ProcessTransferList != null)
+                            {
+                                foreach (var item in headerData.ProcessTransferList)
+                                {
+                                    sw.WriteLine(item);
+                                }
+                            }
+                            sw.WriteLine("Start" + (isLoad ? "Load" : "Unload") + $"WaferShuttle:{(timeList.Count >= 1 ? timeList[0].ToString() : "")}");
+                            sw.WriteLine(moduleName);
+                            sw.Write(CVS_SPLIT_CHAR);
+                            string str = $"TimeStamp{CVS_SPLIT_CHAR}LoaderABernoulliBladderEnable{CVS_SPLIT_CHAR}LoaderABernoulliBladderPressure{CVS_SPLIT_CHAR}" +
+                                $"LoaderABernoulliN2Pressure{CVS_SPLIT_CHAR}LoaderALSVacuum{CVS_SPLIT_CHAR}LoaderALSVacuumAnlg{CVS_SPLIT_CHAR}LoaderAWSPressure" +
+                                $"{CVS_SPLIT_CHAR}LoaderBBernoulliBladderEnable{CVS_SPLIT_CHAR}LoaderBBernoulliBladderPressure{CVS_SPLIT_CHAR}" +
+                                $"LoaderBBernoulliN2Pressure{CVS_SPLIT_CHAR}LoaderBLSVacuum{CVS_SPLIT_CHAR}LoaderBLSVacuumAnlg{CVS_SPLIT_CHAR}LoaderBWSPressure" +
+                                $"{CVS_SPLIT_CHAR}LoaderWSClamped{CVS_SPLIT_CHAR}";
+                            sw.WriteLine(str);
+                        }
+                        //数据内容
+                        if (loaderDatas != null && loaderDatas.Count != 0)
+                        {
+                            for (int i = 0; i < loaderDatas.Count; i++)
+                            {
+                                LoaderLotTrackData data = loaderDatas[i];
+                                string tmp = $"{CVS_SPLIT_CHAR}{data.TimeStamp.ToString("HH:mm:ss")}{CVS_SPLIT_CHAR}{data.LoaderABernoulliBladderEnable}{CVS_SPLIT_CHAR}{data.LoaderABernoulliBladderPressure}{CVS_SPLIT_CHAR}" +
+                                $"{data.LoaderABernoulliN2Pressure}{CVS_SPLIT_CHAR}{data.LoaderACRSVacuum}{CVS_SPLIT_CHAR}{data.LoaderACRSVacuumAnlg}{CVS_SPLIT_CHAR}{data.LoaderAWHPressure}" +
+                                $"{CVS_SPLIT_CHAR}{data.LoaderBBernoulliBladderEnable}{CVS_SPLIT_CHAR}{data.LoaderBBernoulliBladderPressure}{CVS_SPLIT_CHAR}" +
+                                $"{data.LoaderBBernoulliN2Pressure}{CVS_SPLIT_CHAR}{data.LoaderBCRSVacuum}{CVS_SPLIT_CHAR}{data.LoaderBCRSVacuumAnlg}{CVS_SPLIT_CHAR}{data.LoaderBWHPressure}" +
+                                $"{CVS_SPLIT_CHAR}{data.LoaderWHClamped}{CVS_SPLIT_CHAR}";
+                                sw.WriteLine(tmp);
+                            }
+                        }
+                        if (timeList.Count >= 2)
+                        {
+                            sw.WriteLine("Finish" + (isLoad ? "Load" : "Unload") + $"WaferShuttle:{timeList[1].ToString()}");
+                            if (!isLoad) sw.WriteLine("");
+                        }
+                    }                               
+                    //Flow Datas           
+                    if (flowDatas != null && flowDatas.Count != 0 && flowDatasStatus != LotTrackDatasStatus.Complete)
+                    {
+                        if(flowDatasStatus == LotTrackDatasStatus.None && timeList.Count >= 2)
+                        {
+                            sw.WriteLine(moduleName);
+                            sw.Write(CVS_SPLIT_CHAR);
+
+                            string str = $"TimeStamp{CVS_SPLIT_CHAR}LoaderWSClamped{CVS_SPLIT_CHAR}LoaderALSVacuum{CVS_SPLIT_CHAR}" +
+                                $"LoaderALSVacuumAnlg{CVS_SPLIT_CHAR}LoaderBLSVacuum{CVS_SPLIT_CHAR}LoaderBLSVacuumAnlg{CVS_SPLIT_CHAR}" +
+                                $"EnableVacuum{CVS_SPLIT_CHAR}EnableFlowClamp{CVS_SPLIT_CHAR}Flow{CVS_SPLIT_CHAR}";
+                            sw.WriteLine(str);
+                        }                         
+
+                        for (int i = 0; i < flowDatas.Count; i++)
+                        {
+                            LoaderFlowLotTrackData data = flowDatas[i];
+                            string tmp = $"{CVS_SPLIT_CHAR}{data.TimeStamp.ToString("HH:mm:ss")}{CVS_SPLIT_CHAR}{data.LoaderWHClamped}{CVS_SPLIT_CHAR}{data.LoaderACRSVacuum}{CVS_SPLIT_CHAR}" +
+                            $"{data.LoaderACRSVacuumAnlg}{CVS_SPLIT_CHAR}{data.LoaderBCRSVacuum}{CVS_SPLIT_CHAR}{data.LoaderBCRSVacuumAnlg}{CVS_SPLIT_CHAR}" +
+                            $"{data.EnableVacuum}{CVS_SPLIT_CHAR}{data.EnableFlowClamp}{CVS_SPLIT_CHAR}{data.FlowValue}{CVS_SPLIT_CHAR}";
+                            sw.WriteLine(tmp);
+                        }
+                        sw.WriteLine("");
+                    }                   
+                    
+                    sw.Close();
+                    fs.Close();
+                }
+                catch
+                {
+                    LOG.WriteLog(eEvent.ERR_LOADER, moduleName, $"{moduleName} LotTrack file writing is failed!");
+                };
+            });
+        }
+    }
+}

CyberX8_RT/Modules/Loader/LoaderUnloadSideRoutine.cs

@@ -8,10 +8,7 @@ using CyberX8_RT.Devices.Loader;
 using System;
 using System.Collections.Generic;
 using Aitex.Core.RT.Log;
-using MECF.Framework.Common.Utilities;
 using MECF.Framework.Common.CommonData.Loader;
-using MECF.Framework.Common.CommonData;
-using Aitex.Core.RT.DataCenter;
 using Aitex.Core.RT.SCCore;
 using Aitex.Core.Util;
 
@@ -74,7 +71,11 @@ namespace CyberX8_RT.Modules.Loader
         /// <summary>
         /// Wafer组
         /// </summary>
-        public string waferGroup { get { return _waferGroup; } }
+        public string WaferGroup { get { return _waferGroup; } }
+        /// <summary>
+        /// is SideA
+        /// </summary>
+        public bool IsSideA { get { return _side == "A" ? true : false; } }
         #endregion
         /// <summary>
         /// 构造函数
@@ -237,6 +238,9 @@ namespace CyberX8_RT.Modules.Loader
             InitializeParameters();
             _loaderCommon = DEVICE.GetDevice<LoaderCommonDevice>($"{Module}.Common");
             _loaderSide = DEVICE.GetDevice<LoaderSideDevice>($"{Module}.{_side}");
+            //清除lotTrack数据
+            _datas.Clear();
+
             return Runner.Start(Module, "Start Unload side");
         }
         /// <summary>
@@ -333,15 +337,24 @@ namespace CyberX8_RT.Modules.Loader
         {
             LoaderLotTrackData data = new LoaderLotTrackData();
             data.TimeStamp = DateTime.Now;
-
-            data.LoaderABernoulliBladderEnable = _loaderSide.SideData.BernoulliBladder;
-            data.LoaderABernoulliExtended = _loaderSide.SideData.BernoulliExtended;
-            data.LoaderABernoulliBladderPressure = _loaderSide.SideData.BernoulliBladderPressure;
-            data.LoaderABernoulliN2Pressure = _loaderSide.SideData.BernoulliPressure;
-            data.LoaderACRSVacuum = _loaderSide.SideData.CRSVacuum;
-            data.LoaderACRSVacuumAnlg = _loaderSide.SideData.CRSVacuumValue;
-            data.LoaderAWHPressure = _loaderSide.SideData.WHBladderPressure;
-            data.LoaderATranslatePressure = _loaderSide.SideData.TransPressure;
+            if(_side == SIDE_A)
+            {
+                data.LoaderABernoulliBladderEnable = _loaderSide.SideData.BernoulliBladder;
+                data.LoaderABernoulliBladderPressure = _loaderSide.SideData.BernoulliBladderPressure;
+                data.LoaderABernoulliN2Pressure = _loaderSide.SideData.BernoulliPressure;
+                data.LoaderACRSVacuum = _loaderSide.SideData.CRSVacuum;
+                data.LoaderACRSVacuumAnlg = _loaderSide.SideData.CRSVacuumValue;
+                data.LoaderAWHPressure = _loaderSide.SideData.WHBladderPressure;
+            }
+            else
+            {
+                data.LoaderBBernoulliBladderEnable = _loaderSide.SideData.BernoulliBladder;
+                data.LoaderBBernoulliBladderPressure = _loaderSide.SideData.BernoulliBladderPressure;
+                data.LoaderBBernoulliN2Pressure = _loaderSide.SideData.BernoulliPressure;
+                data.LoaderBCRSVacuum = _loaderSide.SideData.CRSVacuum;
+                data.LoaderBCRSVacuumAnlg = _loaderSide.SideData.CRSVacuumValue;
+                data.LoaderBWHPressure = _loaderSide.SideData.WHBladderPressure;
+            }          
             data.LoaderWHClamped = _loaderCommon.CommonData.WaferHolderClamp;
 
             _datas.Add(data);

CyberX8_RT/Schedulers/Loader/SchedulerLoader.cs

@@ -195,9 +195,16 @@ namespace CyberX8_RT.Schedulers.Loader
         private string AnalyseWaferGroup(WaferInfo waferInfo)
         {
             string matchWaferId = WaferTaskManager.Instance.GetMatchWaferIdByWaferId(waferInfo.WaferID);
+            string cycleStr = "";
+            if (waferInfo.WaferType == WaferType.Production)
+            {
+                int cycleCount = CycleManager.Instance.GetLoadportCycleCount($"LP{waferInfo.OriginStation}");
+                int cycleSetPoint = CycleManager.Instance.GetLoadportCycleSetPoint($"LP{waferInfo.OriginStation}");
+                cycleStr = cycleSetPoint > 1 ? $"_Cycle-{cycleCount + 1}" : "";
+            }           
             if (string.IsNullOrEmpty(matchWaferId))
             {
-                return $"{waferInfo.OriginStation}_{waferInfo.OriginSlot}_0";
+                return $"{waferInfo.LotId}_LP{waferInfo.OriginStation}-{waferInfo.OriginSlot}-0{cycleStr}";
             }
             else
             {
@@ -206,16 +213,28 @@ namespace CyberX8_RT.Schedulers.Loader
                 {
                     if (matchedWafer.WaferType == WaferType.Assit)
                     {
-                        return $"LP{waferInfo.OriginStation}_{waferInfo.OriginSlot+1}_0";
+                        return $"{waferInfo.LotId}_LP{waferInfo.OriginStation}-{waferInfo.OriginSlot+1}{cycleStr}";
                     }
                     else
                     {
-                        return $"LP{waferInfo.OriginStation}_{waferInfo.OriginSlot+1}_LP{matchedWafer.OriginStation}_{matchedWafer.OriginSlot+1}";
+                        int cycleCountM = CycleManager.Instance.GetLoadportCycleCount($"LP{matchedWafer.OriginStation}");
+                        int cycleSetPointM = CycleManager.Instance.GetLoadportCycleSetPoint($"LP{matchedWafer.OriginStation}");
+                        string cycleStrM = cycleSetPointM > 1 ? $"_Cycle-{cycleCountM + 1}" : "";
+                        if ((waferInfo.OriginStation > matchedWafer.OriginStation) || (waferInfo.OriginStation == matchedWafer.OriginStation && waferInfo.OriginSlot > matchedWafer.OriginSlot))
+                        {
+                            string lotStr = waferInfo.LotId == matchedWafer.LotId ? "" : $"_{waferInfo.LotId}";
+                            return $"{matchedWafer.LotId}_LP{matchedWafer.OriginStation}-{matchedWafer.OriginSlot + 1}{cycleStrM}{lotStr}_LP{waferInfo.OriginStation}-{waferInfo.OriginSlot + 1}{cycleStr}";
+                        }                        
+                        else
+                        {
+                            string lotStr = waferInfo.LotId == matchedWafer.LotId ? "" : $"_{matchedWafer.LotId}";
+                            return $"{waferInfo.LotId}_LP{waferInfo.OriginStation}-{waferInfo.OriginSlot + 1}{cycleStr}{lotStr}_LP{matchedWafer.OriginStation}-{matchedWafer.OriginSlot + 1}{cycleStrM}";
+                        }                       
                     }
                 }
                 else
                 {
-                    return $"LP{waferInfo.SourceStation}_{waferInfo.OriginSlot+1}_0";
+                    return $"{waferInfo.LotId}_LP{waferInfo.SourceStation}-{waferInfo.OriginSlot+1}{cycleStr}";
                 }
             }
         }

CyberX8_Simulator/Config/UILayout.xml

@@ -52,7 +52,8 @@
 		<SubView Id="TemperatureController2" Name="TC2" ViewClass="CyberX8_Simulator.Views.SimuTemperatureControllerView" Assembly="CyberX8_Simulator" Port="Com14"/>
 	</Navigation>
 	<Navigation Id="Thornton" Name="Thornton" >
-		<SubView Id="Thornton" Name="Thornton View" ViewClass="CyberX8_Simulator.Views.ThorntonView" Assembly="CyberX8_Simulator"/>
+		<SubView Id="Thornton1" Name="Thornton View1" ViewClass="CyberX8_Simulator.Views.ThorntonView" Assembly="CyberX8_Simulator" Port="Com17"/>
+		<SubView Id="Thornton2" Name="Thornton View2" ViewClass="CyberX8_Simulator.Views.ThorntonView" Assembly="CyberX8_Simulator" Port="Com19"/>
 	</Navigation>
 
 	<Navigation Id="Linmot" Name="Linmot" >

CyberX8_Simulator/Devices/WagoSocketSimulator.cs

@@ -171,7 +171,10 @@ namespace CyberX8_Simulator.Devices
             //DI Data
             UpdataDIBytes(name, value ? 1 : 0);
             //Festo Data
-            if (name == "FlowTestClamp") _festoDataBuffer[name] = value;
+            if (name == "FlowTestClamp") 
+            {
+                _festoDataBuffer[name] = value;
+            };       
         }
         /// <summary>
         /// 触发Wago对应数据更新
@@ -470,6 +473,7 @@ namespace CyberX8_Simulator.Devices
             if (AINameIndexDic.ContainsKey("r_RES3_LEVEL_raw")) AIShorts[AINameIndexDic["r_RES3_LEVEL_raw"]] = 10000;
             if (AINameIndexDic.ContainsKey("r_RES4_LEVEL_raw")) AIShorts[AINameIndexDic["r_RES4_LEVEL_raw"]] = 10000;
 
+            _festoDataBuffer["FlowTestClamp"] = false;
         }
         #region 公共方法
         public void UpdataDOBytes(string name,int value)
@@ -808,22 +812,30 @@ namespace CyberX8_Simulator.Devices
         /// </summary>
         private void LeakTestSimulator()
         {
-            if (DOBytes[DONameIndexDic["c_VACUUM_TEST"]] == 1 && _festoDataBuffer["FlowTestClamp"] && AIShorts[AINameIndexDic["r_LOADER_GasFlowSensor_FLOW"]] == 0)
-            {
-                AIShorts[AINameIndexDic["r_LOADER_GasFlowSensor_FLOW"]] = 15000;
-            }
-            else if (DOBytes[DONameIndexDic["c_VACUUM_TEST"]] == 0 && !_festoDataBuffer["FlowTestClamp"])
-            {
-                AIShorts[AINameIndexDic["r_LOADER_GasFlowSensor_FLOW"]] = 0;
-            }
-            if (DOBytes[DONameIndexDic["c_VACUUM_TEST"]] == 1 && _festoDataBuffer["FlowTestClamp"] && AIShorts[AINameIndexDic["r_LOADER_GasFlowSensor_FLOW"]] > 3500)
+            try
             {
-                AIShorts[AINameIndexDic["r_LOADER_GasFlowSensor_FLOW"]] -= 40;
-                if (AIShorts[AINameIndexDic["r_LOADER_GasFlowSensor_FLOW"]] < 14000)
+                if (DOBytes[DONameIndexDic["c_VACUUM_TEST"]] == 1 && _festoDataBuffer["FlowTestClamp"] && AIShorts[AINameIndexDic["r_LOADER_GasFlowSensor_FLOW"]] == 0)
+                {
+                    AIShorts[AINameIndexDic["r_LOADER_GasFlowSensor_FLOW"]] = 15000;
+                }
+                else if (DOBytes[DONameIndexDic["c_VACUUM_TEST"]] == 0 && !_festoDataBuffer["FlowTestClamp"])
                 {
-                    AIShorts[AINameIndexDic["r_LOADER_GasFlowSensor_FLOW"]] -= 140;
+                    AIShorts[AINameIndexDic["r_LOADER_GasFlowSensor_FLOW"]] = 0;
                 }
+                if (DOBytes[DONameIndexDic["c_VACUUM_TEST"]] == 1 && _festoDataBuffer["FlowTestClamp"] && AIShorts[AINameIndexDic["r_LOADER_GasFlowSensor_FLOW"]] > 3500)
+                {
+                    AIShorts[AINameIndexDic["r_LOADER_GasFlowSensor_FLOW"]] -= 40;
+                    if (AIShorts[AINameIndexDic["r_LOADER_GasFlowSensor_FLOW"]] < 14000)
+                    {
+                        AIShorts[AINameIndexDic["r_LOADER_GasFlowSensor_FLOW"]] -= 140;
+                    }
+                }
+            }
+            catch
+            {
+
             }
+            
         }
 
         /// <summary>

CyberX8_Simulator/Views/ThorntonView.xaml

@@ -30,7 +30,7 @@
                       ScrollViewer.CanContentScroll="True"
                       ScrollViewer.VerticalScrollBarVisibility="Auto"
                       ScrollViewer.HorizontalScrollBarVisibility="Auto"
-                      Width="1200" Height="Auto" VerticalAlignment="Top">
+                      Width="1200" VerticalAlignment="Top" MaxHeight="780">
             <DataGrid.Columns>
                 <DataGridTextColumn Header="Time" Width="200" IsReadOnly="True" Binding="{Binding OccurTime, UpdateSourceTrigger=PropertyChanged}" />
                 <DataGridTextColumn Header="Incoming" Width="500" IsReadOnly="True"  Binding="{Binding Incoming, UpdateSourceTrigger=PropertyChanged}">

CyberX8_Simulator/Views/ThorntonView.xaml.cs

@@ -12,7 +12,7 @@ namespace CyberX8_Simulator.Views
         public ThorntonView()
         {
             InitializeComponent();
-            this.DataContext = new ThorntonViewModel();
+            //this.DataContext = new ThorntonViewModel();
         }
     }
 
@@ -23,9 +23,9 @@ namespace CyberX8_Simulator.Views
             get { return "Thornton controller simulator"; }
         }
 
-        public ThorntonViewModel() : base("ThorntonSimulator")
+        public ThorntonViewModel(string port) : base("ThorntonSimulator")
         {
-            Init(new ThorntonSerialPortDevice());
+            Init(new ThorntonSerialPortDevice(port));
         }
     }
 }

Framework/SimulatorCore/Commons/ThorntonSerialPortDevice.cs

@@ -17,7 +17,7 @@ namespace MECF.Framework.Simulator.Core.Commons
         #region 内部变量
         private string[] resistivityAry = new string[4] {"5.566","1.454","8.6711111","0.235"};
         #endregion
-        public ThorntonSerialPortDevice() : base(PORT_NAME, SerialType.ASCII)
+        public ThorntonSerialPortDevice(string port) : base(port, SerialType.ASCII)
         {
         }
 

Framework/UICore/E95Template/BottomView.xaml

@@ -102,7 +102,7 @@
     </UserControl.Resources>
     <Grid x:Name="gridContent" Background="#33a7e4">
         <!--<Button x:Name="btnBackward" Visibility="Hidden" Tag="Backward" VerticalAlignment="Center" Style="{StaticResource NavUpButton}" Click="btn_Click"  Margin="82,0,0,0" />-->
-        <Button x:Name="btnExit"  Tag="Exit" Content="{DynamicResource GlobalLableButtonExit}" VerticalAlignment="Center"   Style="{StaticResource exitButton}" Click="btn_Click" Margin="0,0,66,10" />
+        <Button x:Name="btnExit"  Tag="Exit" Content="{DynamicResource GlobalLableButtonExit}" VerticalAlignment="Center"   Style="{StaticResource exitButton}" Click="btn_Click" Margin="0,0,40,10" />
         <!--<Image Width="34" Height="37" HorizontalAlignment="Left"  Source="/MECF.Framework.Common;component/Resources/Main/下一个.png" Margin="82,0,0,10" />-->
         <!--<Image Width="34" Height="37"  HorizontalAlignment="Right" Source="/MECF.Framework.Common;component/Resources/Main/下一个.png" Margin="0,0,82,10" />-->
         <!--<Button x:Name="btnForward" Visibility="Hidden" Tag="Forward" VerticalAlignment="Center"  Style="{StaticResource NavBackButton}" Click="btn_Click" Margin="0,0,82,0"/>-->