CyberX8/CyberX8_RT/Devices/Loader/LoaderLotTrackUtil.cs

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!");
                }
            });
            
        }

    }
}