ScheduleMaintenance-Carrier/Wafer SD/ED模块功能取代WaferCycleTime配置项功能

git-svn-id: http://10.4.3.168:50001/svn/Furnace@102 dbcde07d-dcf5-c148-8a84-ac3097b7778e

FrameworkLocal/Common/Common.csproj

@@ -227,6 +227,7 @@
     <Compile Include="CommonData\DeviceData\AITWaterMappingData.cs" />
     <Compile Include="CommonData\DeviceData\AITWaterFlowSensorData.cs" />
     <Compile Include="CommonData\DeviceData\IDeviceData.cs" />
+    <Compile Include="CommonData\EnumData\MaintenanceProcessingCommandEnum.cs" />
     <Compile Include="CommonData\FdcDataItem.cs" />
     <Compile Include="CommonData\FileNodeItem.cs" />
     <Compile Include="CommonData\HistoryDataItem.cs" />
@@ -555,6 +556,7 @@
     <Compile Include="Utilities\Crc16.cs" />
     <Compile Include="Utilities\CultureSupported.cs" />
     <Compile Include="Utilities\CustomXmlSerializer.cs" />
+    <Compile Include="Utilities\DateTimeUtil.cs" />
     <Compile Include="Utilities\DeviceTimer.cs" />
     <Compile Include="Utilities\DictionaryExpand.cs" />
     <Compile Include="Utilities\EnumExtensions.cs" />

FrameworkLocal/Common/CommonData/EnumData/MaintenanceProcessingCommandEnum.cs

@@ -0,0 +1,79 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.ComponentModel.DataAnnotations;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace MECF.Framework.Common.CommonData.EnumData
+{
+    public enum MaintenanceProcessingCommandEnum
+    {
+        None = 0,
+
+        AlarmReport = 5,
+
+        JobProhibition = 10,
+
+        JobManualStart = 15,
+
+
+        JobAutoStart = 20,
+    }
+    public enum MaintenanceItemEnum
+    {
+        SDCarrierUseFreq,
+        SDWaferThickness,
+        SDWaferUserTime,
+        SDUsableDummyWafer,
+        SDBufferRackStayTime,
+
+        FDCarrierUseFreq,
+        FDWaferThickness,
+        FDWaferUserTime,
+        FDUsableDummyWafer,
+        FDBufferRackStayTime,
+
+
+
+        OnBoatDummyWaferUse,
+        OnBoatDummyWaferThick,
+        BoatRecipeThickness1,
+        BoatRecipeThickness2,
+        BoatRecipeThickness3,
+
+        NonOperationTime1,
+        NonOperationTime2,
+  
+        RecipeExecuteFreq,
+        RecipeThickness,
+
+        RecipeStepExecuteFreq1,
+        RecipeStepExecuteFreq2,
+        RecipeStepExecuteFreq3,
+
+        RecipeStepExecuteTime1,
+        RecipeStepExecuteTime2,
+        RecipeStepExecuteTime3,
+        RecipeStepExecuteTime4,
+        RecipeStepExecuteTime5,
+        RecipeStepExecuteTime6,
+        RecipeStepExecuteTime7,
+        RecipeStepExecuteTime8,
+
+        RecipeThickness1_Step,
+        RecipeThickness2_Step,
+        RecipeThickness3_Step,
+        RecipeThickness4_Step,
+        RecipeThickness5_Step,
+        RecipeThickness6_Step,
+        RecipeThickness7_Step,
+        RecipeThickness8_Step,
+
+
+
+    }
+
+}

FrameworkLocal/Common/DBCore/DatabaseTable.cs

@@ -150,6 +150,11 @@ namespace MECF.Framework.Common.DBCore
                 {"wafer_data", typeof(string) },
                 {"start_time", typeof(DateTime) },
             });
+
+            DB.CreateTableColumn("schedule_maintenance", new Dictionary<string, Type>()
+            {
+                  {"association_process_recipeName", typeof(string) },
+            });
         }
     }
 }

FrameworkLocal/Common/DataCenter/ScheduleMaintenanceDataManager.cs

@@ -1,12 +1,18 @@
 using System;
 using System.Collections.Generic;
 using System.Data;
+using System.Linq;
+using Aitex.Core.Common;
 using Aitex.Core.RT.DBCore;
 using Aitex.Core.RT.Event;
 using Aitex.Core.RT.Log;
 using Aitex.Core.RT.OperationCenter;
 using Aitex.Core.Util;
+using MECF.Framework.Common.CommonData.EnumData;
 using MECF.Framework.Common.DBCore;
+using MECF.Framework.Common.Equipment;
+using MECF.Framework.Common.SubstrateTrackings;
+using MECF.Framework.Common.Utilities;
 
 namespace MECF.Framework.Common.DataCenter
 {
@@ -14,9 +20,9 @@ namespace MECF.Framework.Common.DataCenter
     {
         public ScheduleMaintenanceDataItem DataItem { get; private set; }
 
-        public ScheduleMaintenanceData(string item, string display, string unit, float startValue, float limitValue, string maintenanceProcessing, string path, string additionInformationName = "", string additionInformationDisplay = "")
+        public ScheduleMaintenanceData(string item, string display, string unit, float startValue, float limitValue, string maintenanceProcessing, string path, string additionInformationName = "", string additionInformationDisplay = "", string associationProcessRecipeName = "")
         {
-            ScheduleMaintenanceDataManager.Instance.Subscribe(item, display, unit, startValue, limitValue, maintenanceProcessing, path, additionInformationName, additionInformationDisplay);
+            ScheduleMaintenanceDataManager.Instance.Subscribe(item, display, unit, startValue, limitValue, maintenanceProcessing, path, additionInformationName, additionInformationDisplay, associationProcessRecipeName);
 
             DataItem = ScheduleMaintenanceDataManager.Instance.GetItem(item);
         }
@@ -33,6 +39,10 @@ namespace MECF.Framework.Common.DataCenter
             ScheduleMaintenanceDataManager.Instance.SetValue(DataItem.Item, value);
         }
 
+        public void SetStartValue(float value)
+        {
+            ScheduleMaintenanceDataManager.Instance.SetStartValue(DataItem.Item, value);
+        }
         public float GetValue()
         {
             return ScheduleMaintenanceDataManager.Instance.GetValue(DataItem.Item);
@@ -52,6 +62,7 @@ namespace MECF.Framework.Common.DataCenter
         public float StartValue { get; set; }
         public float LimitValue { get; set; }
         public string MaintenanceProcessing { get; set; }
+        public string AssociationProcessRecipeName { get; set; }
         public string Display { get; set; }
         public string Path { get; set; }
         public string AdditionInformationName { get; set; }
@@ -92,6 +103,11 @@ namespace MECF.Framework.Common.DataCenter
                     SetMaintenanceProcessing((string)args[0], args[1].ToString());
                     return true;
                 });
+                OP.Subscribe("System.ScheduleMaintenance.SetAssociationProcessRecipeName", (method, args) =>
+                {
+                    SetAssociationProcessRecipeName((string)args[0], args[1].ToString());
+                    return true;
+                });
 
                 OP.Subscribe("System.ScheduleMaintenance.SetLimitValue", (method, args) =>
                 {
@@ -114,7 +130,6 @@ namespace MECF.Framework.Common.DataCenter
                     return true;
                 });
 
-
                 DataTable dt = DataQuery.Query("select * from \"schedule_maintenance\"");
 
                 for (int i = 0; i < dt.Rows.Count; i++)
@@ -127,6 +142,7 @@ namespace MECF.Framework.Common.DataCenter
                     item.Path = dt.Rows[i]["path"].ToString();
                     item.AdditionInformationName = dt.Rows[i]["addition_information_name"].ToString();
                     item.AdditionInformationDisplay = dt.Rows[i]["addition_information_display"].ToString();
+                    item.AssociationProcessRecipeName = dt.Rows[i]["association_process_recipeName"].ToString();
                     if (float.TryParse(dt.Rows[i]["current_value"].ToString(), out float value))
                         item.CurrentValue = value;
                     if (float.TryParse(dt.Rows[i]["scheduling_start_value"].ToString(), out value))
@@ -136,6 +152,9 @@ namespace MECF.Framework.Common.DataCenter
 
                     _items[item.Item] = item;
                 }
+
+                InitScheduleMaintenance();
+                UpdateSEDWafer();
             }
             catch (Exception ex)
             {
@@ -156,7 +175,7 @@ namespace MECF.Framework.Common.DataCenter
                 _items[name].Display = display;
 
                 string sql = string.Format(
-                    "UPDATE \"schedule_maintenance\" SET \"maintenance_processing\"='{0}'WHERE \"maintenance_item\"='{1}';", display,
+                    "UPDATE \"schedule_maintenance\" SET \"maintenance_display\"='{0}'WHERE \"maintenance_item\"='{1}';", display,
                     name);
                 DB.Insert(sql);
 
@@ -189,9 +208,30 @@ namespace MECF.Framework.Common.DataCenter
             }
         }
 
+        public string SetAssociationProcessRecipeName(string name, string associationProcessRecipeName)
+        {
 
-        
+            lock (_locker)
+            {
+                if (!_items.ContainsKey(name))
+                {
+                    LOG.Error($"Can not set {name} associationProcessRecipeName value, not defined item");
+                    return "";
+                }
+
+                string preValue = _items[name].AssociationProcessRecipeName;
+                _items[name].AssociationProcessRecipeName = associationProcessRecipeName;
+
+                string sql = string.Format(
+                    "UPDATE \"schedule_maintenance\" SET \"association_process_recipeName\"='{0}'WHERE \"maintenance_item\"='{1}';", associationProcessRecipeName,
+                    name);
+                DB.Insert(sql);
 
+                EV.PostInfoLog("System", $"{name} schedule maintenance associationProcessRecipeName value changed from {preValue} to {associationProcessRecipeName}");
+
+                return associationProcessRecipeName;
+            }
+        }
         public string SetMaintenanceProcessing(string name, string maintenanceProcessing)
         {
             lock (_locker)
@@ -243,7 +283,7 @@ namespace MECF.Framework.Common.DataCenter
         {
 
         }
-        public void Subscribe(string item, string display, string unit, float startValue, float limitValue, string maintenanceProcessing, string path, string additionInformationName, string additionInformationDisplay)
+        public void Subscribe(string item, string display, string unit, float startValue, float limitValue, string maintenanceProcessing, string path, string additionInformationName, string additionInformationDisplay, string associationProcessRecipeName)
         {
             lock (_locker)
             {
@@ -261,8 +301,9 @@ namespace MECF.Framework.Common.DataCenter
                                                     ""path"",
                                                     ""addition_information_name"",
                                                     ""addition_information_display""
-                                                    ) values('{0}','{1}','{2}','{3}','{4}','{5}','{6}','{7}','{8}')",
-                        item, display, startValue, limitValue, maintenanceProcessing, unit, path, additionInformationName, additionInformationDisplay);
+                                                    ""association_process_recipeName""
+                                                    ) values('{0}','{1}','{2}','{3}','{4}','{5}','{6}','{7}','{8}','{9}')",
+                        item, display, startValue, limitValue, maintenanceProcessing, unit, path, additionInformationName, additionInformationDisplay, associationProcessRecipeName);
                     DB.Insert(executeInsert);
                 }
             }
@@ -287,7 +328,6 @@ namespace MECF.Framework.Common.DataCenter
                 DB.Insert(sql);
             }
         }
-
         public void SetStartValue(string name, float value)
         {
             lock (_locker)
@@ -366,6 +406,170 @@ namespace MECF.Framework.Common.DataCenter
                 return _items[name].CurrentValue;
             }
         }
+
+        #region 
+
+        private Dictionary<string, string> _stepThickness;
+
+        private Dictionary<MaintenanceItemEnum, ScheduleMaintenanceData> _scheduleMaintenanceDataDictionary;
+
+        private void InitScheduleMaintenance()
+        {
+
+            _scheduleMaintenanceDataDictionary = new Dictionary<MaintenanceItemEnum, ScheduleMaintenanceData>
+                  {
+                  { MaintenanceItemEnum.SDCarrierUseFreq, new ScheduleMaintenanceData(MaintenanceItemEnum.SDCarrierUseFreq.ToString(),"SDCarrierUseFreq", "Times", 0, 0, "None", "CarrierWafer.SieDummy", "Carrier Kind", "Side Dummy") },
+                  { MaintenanceItemEnum.SDWaferThickness, new ScheduleMaintenanceData(MaintenanceItemEnum.SDWaferThickness.ToString(), "SDWaferThickness", "Å", 0, 0, "None", "CarrierWafer.SieDummy", "Carrier Kind", "Side Dummy") },
+                  { MaintenanceItemEnum.SDUsableDummyWafer, new ScheduleMaintenanceData(MaintenanceItemEnum.SDUsableDummyWafer.ToString(), "SDWaferRemain", "Sheets", 0, 0, "None", "CarrierWafer.SieDummy", "Carrier Kind", "Side Dummy") },
+                  { MaintenanceItemEnum.SDBufferRackStayTime, new ScheduleMaintenanceData(MaintenanceItemEnum.SDBufferRackStayTime.ToString(), "SDCarrierStay", "h:m", 0, 0, "None", "CarrierWafer.SieDummy", "Carrier Kind", "Side Dummy") },
+                  { MaintenanceItemEnum.SDWaferUserTime, new ScheduleMaintenanceData(MaintenanceItemEnum.SDWaferUserTime.ToString(),  "SDWaferUserTime", "h:m", 0, 0, "None", "CarrierWafer.SieDummy", "Carrier Kind", "Side Dummy") },
+
+
+                  { MaintenanceItemEnum.FDCarrierUseFreq, new ScheduleMaintenanceData(MaintenanceItemEnum.FDCarrierUseFreq.ToString(),"FDCarrierUseFreq", "Times", 0, 0, "None", "CarrierWafer.FillDummy", "Carrier Kind", "Fill Dummy") },
+                  { MaintenanceItemEnum.FDWaferThickness, new ScheduleMaintenanceData(MaintenanceItemEnum.FDWaferThickness.ToString(),"FDWaferThickness", "Å", 0, 0, "None", "CarrierWafer.FillDummy", "Carrier Kind", "Fill Dummy") },
+                  { MaintenanceItemEnum.FDUsableDummyWafer, new ScheduleMaintenanceData(MaintenanceItemEnum.FDUsableDummyWafer.ToString(),"FDWaferRemain", "Sheets", 0, 0, "None", "CarrierWafer.FillDummy", "Carrier Kind", "Fill Dummy") },
+                  { MaintenanceItemEnum.FDBufferRackStayTime, new ScheduleMaintenanceData(MaintenanceItemEnum.FDBufferRackStayTime.ToString(), "FDCarrierStay", "h:m", 0, 0, "None", "CarrierWafer.FillDummy", "Carrier Kind", "Fill Dummy") },
+                  { MaintenanceItemEnum.FDWaferUserTime, new ScheduleMaintenanceData(MaintenanceItemEnum.FDWaferUserTime.ToString(), "FDWaferUserTime", "h:m", 0, 0, "None", "CarrierWafer.FillDummy", "Carrier Kind", "Fill Dummy") },
+
+
+                  { MaintenanceItemEnum.OnBoatDummyWaferUse, new ScheduleMaintenanceData(MaintenanceItemEnum.OnBoatDummyWaferUse.ToString(),"OnBoatDummyWaferUse", "Times", 0, 0, "None", "Boat", "", "") },
+                  { MaintenanceItemEnum.OnBoatDummyWaferThick, new ScheduleMaintenanceData(MaintenanceItemEnum.OnBoatDummyWaferThick.ToString(), "OnBoatDummyWaferThick", "Å", 0, 0, "None", "Boat", "", "") },
+                  { MaintenanceItemEnum.BoatRecipeThickness1, new ScheduleMaintenanceData(MaintenanceItemEnum.BoatRecipeThickness1.ToString(),  "BoatRecipeThickness1", "Å", 0, 0, "None", "Boat", "", "") },
+                  { MaintenanceItemEnum.BoatRecipeThickness2, new ScheduleMaintenanceData(MaintenanceItemEnum.BoatRecipeThickness2.ToString(),  "BoatRecipeThickness2", "Å", 0, 0, "None", "Boat", "", "") },
+                  { MaintenanceItemEnum.BoatRecipeThickness3, new ScheduleMaintenanceData(MaintenanceItemEnum.BoatRecipeThickness3.ToString(),  "BoatRecipeThickness3", "Å", 0, 0, "None", "Boat", "", "") },
+
+
+                  { MaintenanceItemEnum.NonOperationTime1, new ScheduleMaintenanceData(MaintenanceItemEnum.NonOperationTime1.ToString(), "NonOperationTime1", "h:m", 0, 0, "None", "Conditioning", "", "") },
+                  { MaintenanceItemEnum.NonOperationTime2, new ScheduleMaintenanceData(MaintenanceItemEnum.NonOperationTime2.ToString(), "NonOperationTime2", "h:m", 0, 0, "None", "Conditioning", "", "") },
+
+                  { MaintenanceItemEnum.RecipeExecuteFreq, new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeExecuteFreq.ToString(), "Recipe Run Freq", "Times", 0, 0, "None", "Reactor.Recipe", "", "") },
+                  { MaintenanceItemEnum.RecipeThickness, new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeThickness.ToString(), "Recipe Thickness", "Å", 0, 0, "None", "Reactor.Recipe", "", "") },
+
+
+                  { MaintenanceItemEnum.RecipeStepExecuteFreq1, new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeStepExecuteFreq1.ToString(), "Recipe StepRunTime1", "Times", 0, 0, "None", "Reactor.StepRunFreq", "Step ID", "") },
+                  { MaintenanceItemEnum.RecipeStepExecuteFreq2, new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeStepExecuteFreq2.ToString(), "Recipe StepRunTime2", "Times", 0, 0, "None", "Reactor.StepRunFreq", "Step ID", "") },
+                  { MaintenanceItemEnum.RecipeStepExecuteFreq3, new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeStepExecuteFreq3.ToString(), "Recipe StepRunTime3", "Times", 0, 0, "None", "Reactor.StepRunFreq", "Step ID", "") },
+
+
+                  { MaintenanceItemEnum.RecipeStepExecuteTime1, new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeStepExecuteTime1.ToString(), "Recipe StepRunTime1", "h:m", 0, 0, "None", "Reactor.StepRunTime", "Step ID", "") },
+                  { MaintenanceItemEnum.RecipeStepExecuteTime2, new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeStepExecuteTime2.ToString(), "Recipe StepRunTime2", "h:m", 0, 0, "None", "Reactor.StepRunTime", "Step ID", "") },
+                  { MaintenanceItemEnum.RecipeStepExecuteTime3, new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeStepExecuteTime3.ToString(), "Recipe StepRunTime3", "h:m", 0, 0, "None", "Reactor.StepRunTime", "Step ID", "") },
+                  { MaintenanceItemEnum.RecipeStepExecuteTime4, new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeStepExecuteTime4.ToString(), "Recipe StepRunTime4", "h:m", 0, 0, "None", "Reactor.StepRunTime", "Step ID", "") },
+                  { MaintenanceItemEnum.RecipeStepExecuteTime5, new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeStepExecuteTime5.ToString(), "Recipe StepRunTime5", "h:m", 0, 0, "None", "Reactor.StepRunTime", "Step ID", "") },
+                  { MaintenanceItemEnum.RecipeStepExecuteTime6, new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeStepExecuteTime6.ToString(), "Recipe StepRunTime6", "h:m", 0, 0, "None", "Reactor.StepRunTime", "Step ID", "") },
+                  { MaintenanceItemEnum.RecipeStepExecuteTime7, new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeStepExecuteTime7.ToString(), "Recipe StepRunTime7", "h:m", 0, 0, "None", "Reactor.StepRunTime", "Step ID", "") },
+                  { MaintenanceItemEnum.RecipeStepExecuteTime8, new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeStepExecuteTime8.ToString(), "Recipe StepRunTime8", "h:m", 0, 0, "None", "Reactor.StepRunTime", "Step ID", "") },
+
+
+
+                  { MaintenanceItemEnum.RecipeThickness1_Step, new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeThickness1_Step.ToString(), "Recipe StepThickness1", "Å", 0, 0, "None", "Reactor.StepThickness", "Step Group", "Group 1") },
+                  { MaintenanceItemEnum.RecipeThickness2_Step, new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeThickness2_Step.ToString(), "Recipe StepThickness2", "Å", 0, 0, "None", "Reactor.StepThickness", "Step Group", "Group 2") },
+                  { MaintenanceItemEnum.RecipeThickness3_Step, new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeThickness3_Step.ToString(), "Recipe StepThickness3", "Å", 0, 0, "None", "Reactor.StepThickness", "Step Group", "Group 3") },
+                  { MaintenanceItemEnum.RecipeThickness4_Step, new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeThickness4_Step.ToString(), "Recipe StepThickness4", "Å", 0, 0, "None", "Reactor.StepThickness", "Step Group", "Group 4") },
+                  { MaintenanceItemEnum.RecipeThickness5_Step, new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeThickness5_Step.ToString(), "Recipe StepThickness5", "Å", 0, 0, "None", "Reactor.StepThickness", "Step Group", "Group 5") },
+                  { MaintenanceItemEnum.RecipeThickness6_Step, new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeThickness6_Step.ToString(), "Recipe StepThickness6", "Å", 0, 0, "None", "Reactor.StepThickness", "Step Group", "Group 6") },
+                  { MaintenanceItemEnum.RecipeThickness7_Step, new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeThickness7_Step.ToString(), "Recipe StepThickness7", "Å", 0, 0, "None", "Reactor.StepThickness", "Step Group", "Group 7") },
+                  { MaintenanceItemEnum.RecipeThickness8_Step, new ScheduleMaintenanceData(MaintenanceItemEnum.RecipeThickness8_Step.ToString(), "Recipe StepThickness8", "Å", 0, 0, "None", "Reactor.StepThickness", "Step Group", "Group 8") }
+              };
+            _stepThickness = new Dictionary<string, string>()
+            {
+                {"1","WAIT"},
+                {"2","Name"},
+            };
+        }
+        public void UpdateRecipeTotalThickness(string recipeName, float thickness)
+        {
+
+        }
+        public void UpdateRecipeStepThicknessAndTime(string stepName, float thickness, float timeS)
+        {
+            if (string.IsNullOrEmpty(stepName))
+                return;
+            var checkName = stepName;
+            var nameParas = stepName.Split(':');
+            if (nameParas != null && nameParas.Length > 1)
+                checkName = nameParas[1];
+        }
+        public bool CheckScheduleMaintenanceBeforeJobStart(out string reason)
+        {
+            reason = "";
+            return true;
+        }
+
+        public ScheduleMaintenanceData GetScheduleMaintenanceData(MaintenanceItemEnum MaintenanceItemEnum)
+        {
+            _scheduleMaintenanceDataDictionary.TryGetValue(MaintenanceItemEnum, out var data);
+            return data;
+        }
+        public void MaintenanceProcessingCommandExec(string maintenanceProcessing, Action<string> alarmReportExec, string warningMessage)
+        {
+            if (Enum.TryParse<MaintenanceProcessingCommandEnum>(maintenanceProcessing, out var command))
+            {
+                switch (command)
+                {
+                    case MaintenanceProcessingCommandEnum.None:
+                        break;
+                    case MaintenanceProcessingCommandEnum.AlarmReport:
+                        alarmReportExec(warningMessage);
+                        break;
+                    case MaintenanceProcessingCommandEnum.JobProhibition:
+                        break;
+                    case MaintenanceProcessingCommandEnum.JobManualStart:
+                        break;
+                    case MaintenanceProcessingCommandEnum.JobAutoStart:
+                        break;
+                }
+            }
+        }
+
+        public void UpdateSEDWafer()
+        {
+
+            var ccc = BinarySerializer<Dictionary<ModuleName, Dictionary<int, WaferInfo>>>.FromStream("WaferManager");
+            List<WaferInfo> waferInfos = new List<WaferInfo>();
+            if (ccc != null)
+            {
+                foreach (var moduleWafers in ccc)
+                {
+                    waferInfos.AddRange(moduleWafers.Value.Select(a => a.Value));
+                }
+                if (waferInfos.Any(a => a.WaferType == WaferType.ED))
+                {
+
+                    var maxEDUseCount = waferInfos.Where(a => a.WaferType == WaferType.ED).Max(a => a.UseCount);
+                    var maxEDUseThick = waferInfos.Where(a => a.WaferType == WaferType.ED).Max(a => a.UseThick);
+                    var maxEDUseTime = waferInfos.Where(a => a.WaferType == WaferType.ED).Max(a => a.UseTime);
+
+                    if (_scheduleMaintenanceDataDictionary.TryGetValue(MaintenanceItemEnum.FDCarrierUseFreq, out var FDCarrierUseFreq))
+                        FDCarrierUseFreq.SetValue(maxEDUseCount);
+
+                    if (_scheduleMaintenanceDataDictionary.TryGetValue(MaintenanceItemEnum.FDWaferThickness, out var FDWaferThickness))
+                        FDWaferThickness.SetValue(maxEDUseThick);
+
+                    if (_scheduleMaintenanceDataDictionary.TryGetValue(MaintenanceItemEnum.FDWaferUserTime, out var FDWaferUserTime))
+                        FDWaferUserTime.SetValue(maxEDUseTime);
+                }
+                if (waferInfos.Any(a => a.WaferType == WaferType.SD))
+                {
+
+                    var maxSDUseCount = waferInfos.Where(a => a.WaferType == WaferType.SD).Max(a => a.UseCount);
+                    var maxSDUseThick = waferInfos.Where(a => a.WaferType == WaferType.SD).Max(a => a.UseThick);
+                    var maxSDUseTime = waferInfos.Where(a => a.WaferType == WaferType.SD).Max(a => a.UseTime);
+                    if (_scheduleMaintenanceDataDictionary.TryGetValue(MaintenanceItemEnum.SDCarrierUseFreq, out var SDCarrierUseFreq))
+                        SDCarrierUseFreq.SetValue(maxSDUseCount);
+
+                    if (_scheduleMaintenanceDataDictionary.TryGetValue(MaintenanceItemEnum.SDWaferThickness, out var SDWaferThickness))
+                        SDWaferThickness.SetValue(maxSDUseThick);
+
+                    if (_scheduleMaintenanceDataDictionary.TryGetValue(MaintenanceItemEnum.SDWaferUserTime, out var SDWaferUserTime))
+                        SDWaferUserTime.SetValue(maxSDUseTime);
+                }
+
+                // var data = ccc.Select(a => a.Value.Select(e=>e.Value)).ToList();
+            }
+        }
+        #endregion
+
     }
 }
 

FrameworkLocal/Common/SubstrateTrackings/WaferManager.cs

@@ -7,6 +7,7 @@ using Aitex.Core.RT.Event;
 using Aitex.Core.RT.Log;
 using Aitex.Core.Util;
 using FabConnect.SecsGemInterface.Common;
+using MECF.Framework.Common.DataCenter;
 using MECF.Framework.Common.DBCore;
 using MECF.Framework.Common.Equipment;
 using MECF.Framework.Common.Utilities;
@@ -1049,6 +1050,9 @@ namespace MECF.Framework.Common.SubstrateTrackings
                 _locationWafers[module][slot].UseTime = useTime;
                 _locationWafers[module][slot].UseThick = useThick;
                 WaferDataRecorder.SetStatistics(_locationWafers[module][slot].InnerId.ToString(), useCount, useTime, useThick);
+
+                Singleton<ScheduleMaintenanceDataManager>.Instance.UpdateSEDWafer();
+
             }
             _needSerialize = true;
         }

FrameworkLocal/Common/Utilities/DateTimeUtil.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace MECF.Framework.Common.Utilities
+{
+    public class DateTimeUtil
+    {
+        public static int GetSecond(float number)
+        {
+            if (number.ToString().Contains('.'))
+            {
+                var strs = number.ToString().Split('.').Select(a => int.Parse(a)).ToList();
+                return strs[0] * 3600 + strs[1] * 60;
+            }
+            else
+            {
+                return (int)number * 3600;
+            }
+
+        }
+        public static void ConvertSecondsToHoursAndMinutes(int totalSeconds, out int hours, out int minutes)
+        {
+            hours = totalSeconds / 3600;
+            int remainingSeconds = totalSeconds % 3600;
+            minutes = remainingSeconds / 60;
+        }
+    }
+}

Furnace/FurnaceRT/Config/DBModel.sql

@@ -504,6 +504,7 @@ begin
                       "path" text,
                       "addition_information_name" text,
                       "addition_information_display" text,
+                      "association_process_recipeName" text,
 					  CONSTRAINT "schedule_maintenance_pkey" PRIMARY KEY ("maintenance_item" )
 					)
 					WITH (

Furnace/FurnaceRT/Equipments/Jobs/AutoTransfer.cs

@@ -36,6 +36,10 @@ using FurnaceRT.Equipments.Boats;
 using MECF.Framework.FA.Core.FAControl;
 using MECF.Framework.UI.Client.CenterViews.Operations.FA;
 using FurnaceRT.Equipments.LPs;
+using MECF.Framework.Common.CommonData.EnumData;
+using MECF.Framework.Common.DataCenter;
+using DocumentFormat.OpenXml.Drawing.Charts;
+using MECF.Framework.Common.Utilities;
 
 namespace FurnaceRT.Equipments.Jobs
 {
@@ -5898,6 +5902,7 @@ namespace FurnaceRT.Equipments.Jobs
         #endregion
 
         #region dummy use 
+
         private bool CheckDummyWaferUse(ProcessJobInfo pj)
         {
             foreach (var module in Singleton<EquipmentManager>.Instance.Modules.Keys)
@@ -5914,80 +5919,114 @@ namespace FurnaceRT.Equipments.Jobs
                 {
                     if (wafer.IsEmpty)
                         continue;
+                    #region  SD Dummy 时间/次数/膜厚限制
+
+                    var maintenanceItemSDCarrierUseFreq = ScheduleMaintenanceDataManager.Instance.GetItem(MaintenanceItemEnum.SDCarrierUseFreq.ToString());
+                    var maintenanceItemSDWaferThickness = ScheduleMaintenanceDataManager.Instance.GetItem(MaintenanceItemEnum.SDWaferThickness.ToString());
+                    var maintenanceItemSDWaferUserTime = ScheduleMaintenanceDataManager.Instance.GetItem(MaintenanceItemEnum.SDWaferUserTime.ToString());
+
+                    int SDCountWarning = (int)maintenanceItemSDCarrierUseFreq.StartValue;
+                    int SDCountAlarm = (int)maintenanceItemSDCarrierUseFreq.LimitValue;
+                    bool IsEnableSDWaferUseCountWarning = SDCountWarning > 0;
+
+
+                    int SDThicknessWarning = (int)maintenanceItemSDWaferThickness.StartValue;
+                    int SDThicknessAlarm = (int)maintenanceItemSDWaferThickness.LimitValue;
+                    bool IsEnableSDWaferThicknessWarning = SDThicknessWarning > 0;
 
-                    // SD Dummy
-                    if (wafer.WaferType == WaferType.SD && SC.GetValue<bool>($"PM1.WaferCycleTime.IsEnableSDWaferUseCountWarning") && wafer.UseCount > SC.GetValue<int>($"PM1.WaferCycleTime.SDCountWarning") && wafer.UseCount < SC.GetValue<int>($"PM1.WaferCycleTime.SDCountAlarm"))
+                    int SDTimeWarning = DateTimeUtil.GetSecond(maintenanceItemSDWaferUserTime.StartValue);
+                    int SDTimeAlarm = DateTimeUtil.GetSecond(maintenanceItemSDWaferUserTime.LimitValue);
+                    bool IsEnableSDWaferUseTimeWarning = SDTimeWarning > 0;
+                    if (wafer.WaferType == WaferType.SD && IsEnableSDWaferUseCountWarning && wafer.UseCount > SDCountWarning && wafer.UseCount < SDCountAlarm)
                     {
-                        Singleton<EquipmentManager>.Instance.SDWaferTypeUseCountWarning.Set($"more than {SC.GetValue<int>($"PM1.WaferCycleTime.SDCountWarning")} 次");
+                        Singleton<ScheduleMaintenanceDataManager>.Instance.MaintenanceProcessingCommandExec(maintenanceItemSDCarrierUseFreq.MaintenanceProcessing, Singleton<EquipmentManager>.Instance.SDWaferTypeUseCountWarning.Set, $"more than {SDCountWarning} 次");
                     }
 
-                    if (wafer.WaferType == WaferType.SD && SC.GetValue<bool>($"PM1.WaferCycleTime.IsEnableSDWaferUseTimeWarning") && wafer.UseTime / 3600 > SC.GetValue<double>($"PM1.WaferCycleTime.SDTimeWarning") && wafer.UseTime / 3600 < SC.GetValue<double>($"PM1.WaferCycleTime.SDTimeAlarm"))
+                    if (wafer.WaferType == WaferType.SD && IsEnableSDWaferUseTimeWarning && wafer.UseTime > SDTimeWarning && wafer.UseTime < SDTimeAlarm)
                     {
-                        Singleton<EquipmentManager>.Instance.SDWaferTypeUseTimeWarning.Set($"more than {SC.GetValue<double>($"PM1.WaferCycleTime.SDTimeWarning")} hour");
+                        DateTimeUtil.ConvertSecondsToHoursAndMinutes(SDTimeWarning, out var hours, out var minutes);
+                        Singleton<ScheduleMaintenanceDataManager>.Instance.MaintenanceProcessingCommandExec(maintenanceItemSDWaferUserTime.MaintenanceProcessing, Singleton<EquipmentManager>.Instance.SDWaferTypeUseTimeWarning.Set, $"more than {hours} hour {minutes} min");
                     }
 
-                    if (wafer.WaferType == WaferType.SD && SC.GetValue<bool>($"PM1.WaferCycleTime.IsEnableSDWaferThicknessWarning") && wafer.UseThick > SC.GetValue<double>($"PM1.WaferCycleTime.SDThicknessWarning") && wafer.UseThick < SC.GetValue<double>($"PM1.WaferCycleTime.SDThicknessAlarm"))
+                    if (wafer.WaferType == WaferType.SD && IsEnableSDWaferThicknessWarning && wafer.UseThick > SDThicknessWarning && wafer.UseThick < SDThicknessAlarm)
                     {
-                        Singleton<EquipmentManager>.Instance.SDWaferTypeThicknessWarning.Set($"more than {SC.GetValue<double>($"PM1.WaferCycleTime.SDThicknessWarning")} nm");
+                        Singleton<ScheduleMaintenanceDataManager>.Instance.MaintenanceProcessingCommandExec(maintenanceItemSDWaferThickness.MaintenanceProcessing, Singleton<EquipmentManager>.Instance.SDWaferTypeThicknessWarning.Set, $"more than {SDThicknessWarning} nm");
                     }
 
-                    if (wafer.WaferType == WaferType.SD && SC.GetValue<bool>($"PM1.WaferCycleTime.IsEnableSDWaferUseCountWarning") && wafer.UseCount >= SC.GetValue<int>($"PM1.WaferCycleTime.SDCountAlarm"))
+                    if (wafer.WaferType == WaferType.SD && IsEnableSDWaferUseCountWarning && wafer.UseCount >= SDCountAlarm)
                     {
-                        Singleton<EquipmentManager>.Instance.SDWaferTypeUseCountAlarm.Set($"more than {SC.GetValue<int>($"PM1.WaferCycleTime.SDCountAlarm")} 次");
-
+                        Singleton<ScheduleMaintenanceDataManager>.Instance.MaintenanceProcessingCommandExec(maintenanceItemSDCarrierUseFreq.MaintenanceProcessing, Singleton<EquipmentManager>.Instance.SDWaferTypeUseCountAlarm.Set, $"more than {SDCountAlarm} 次");
                         return false;
                     }
 
-                    if (wafer.WaferType == WaferType.SD && SC.GetValue<bool>($"PM1.WaferCycleTime.IsEnableSDWaferUseTimeWarning") && wafer.UseTime / 3600 >= SC.GetValue<double>($"PM1.WaferCycleTime.SDTimeAlarm"))
+                    if (wafer.WaferType == WaferType.SD && IsEnableSDWaferUseTimeWarning && wafer.UseTime >= SDTimeAlarm)
                     {
-                        Singleton<EquipmentManager>.Instance.SDWaferTypeUseTimeAlarm.Set($"more than {SC.GetValue<double>($"PM1.WaferCycleTime.SDTimeAlarm")} hour");
-
+                        DateTimeUtil.ConvertSecondsToHoursAndMinutes(SDTimeAlarm, out var hours, out var minutes);
+                        Singleton<ScheduleMaintenanceDataManager>.Instance.MaintenanceProcessingCommandExec(maintenanceItemSDWaferUserTime.MaintenanceProcessing, Singleton<EquipmentManager>.Instance.SDWaferTypeUseTimeAlarm.Set, $"more than {hours} hour {minutes}");
                         return false;
                     }
 
-                    if (wafer.WaferType == WaferType.SD && SC.GetValue<bool>($"PM1.WaferCycleTime.IsEnableSDWaferThicknessWarning") && wafer.UseThick >= SC.GetValue<double>($"PM1.WaferCycleTime.SDThicknessAlarm"))
+                    if (wafer.WaferType == WaferType.SD && IsEnableSDWaferThicknessWarning && wafer.UseThick >= SDThicknessAlarm)
                     {
-                        Singleton<EquipmentManager>.Instance.SDWaferTypeThicknessAlarm.Set($"more than {SC.GetValue<double>($"PM1.WaferCycleTime.SDThicknessAlarm")} nm");
-
+                        Singleton<ScheduleMaintenanceDataManager>.Instance.MaintenanceProcessingCommandExec(maintenanceItemSDWaferThickness.MaintenanceProcessing, Singleton<EquipmentManager>.Instance.SDWaferTypeThicknessAlarm.Set, $"more than {SDThicknessAlarm} nm");
                         return false;
                     }
+                    #endregion
+
+                    #region ED
+                    var maintenanceItemEDCarrierUseFreq = ScheduleMaintenanceDataManager.Instance.GetItem(MaintenanceItemEnum.FDCarrierUseFreq.ToString());
+                    var maintenanceItemEDWaferThickness = ScheduleMaintenanceDataManager.Instance.GetItem(MaintenanceItemEnum.FDWaferThickness.ToString());
+                    var maintenanceItemEDWaferUserTime = ScheduleMaintenanceDataManager.Instance.GetItem(MaintenanceItemEnum.FDWaferUserTime.ToString());
 
-                    // Extra Dummy
-                    if (wafer.WaferType == WaferType.ED && SC.GetValue<bool>($"PM1.WaferCycleTime.IsEnableEDWaferUseCountWarning") && wafer.UseCount > SC.GetValue<int>($"PM1.WaferCycleTime.EDCountWarning") && wafer.UseCount < SC.GetValue<int>($"PM1.WaferCycleTime.EDCountAlarm"))
+                    int EDCountWarning = (int)maintenanceItemEDCarrierUseFreq.StartValue;
+                    int EDCountAlarm = (int)maintenanceItemEDCarrierUseFreq.LimitValue;
+                    bool IsEnableEDWaferUseCountWarning = EDCountWarning > 0;
+
+
+                    int EDThicknessWarning = (int)maintenanceItemEDWaferThickness.StartValue;
+                    int EDThicknessAlarm = (int)maintenanceItemEDWaferThickness.LimitValue;
+                    bool IsEnableEDWaferThicknessWarning = EDThicknessWarning > 0;
+
+                    int EDTimeWarning = DateTimeUtil.GetSecond(maintenanceItemEDWaferUserTime.StartValue);
+                    int EDTimeAlarm = DateTimeUtil.GetSecond(maintenanceItemEDWaferUserTime.LimitValue);
+                    bool IsEnableEDWaferUseTimeWarning = EDTimeWarning > 0;
+                    if (wafer.WaferType == WaferType.ED && IsEnableEDWaferUseCountWarning && wafer.UseCount > EDCountWarning && wafer.UseCount < EDCountAlarm)
                     {
-                        Singleton<EquipmentManager>.Instance.EDWaferTypeUseCountWarning.Set($"more than {SC.GetValue<int>($"PM1.WaferCycleTime.EDCountWarning")} 次");
+                        Singleton<ScheduleMaintenanceDataManager>.Instance.MaintenanceProcessingCommandExec(maintenanceItemEDCarrierUseFreq.MaintenanceProcessing, Singleton<EquipmentManager>.Instance.EDWaferTypeUseCountWarning.Set, $"more than {EDCountWarning} 次");
+                        return false;
                     }
 
-                    if (wafer.WaferType == WaferType.ED && SC.GetValue<bool>($"PM1.WaferCycleTime.IsEnableEDWaferUseTimeWarning") && wafer.UseTime / 3600 > SC.GetValue<double>($"PM1.WaferCycleTime.EDTimeWarning") && wafer.UseTime / 3600 < SC.GetValue<double>($"PM1.WaferCycleTime.EDTimeAlarm"))
+                    if (wafer.WaferType == WaferType.ED && IsEnableEDWaferUseTimeWarning && wafer.UseTime > EDTimeWarning && wafer.UseTime < EDTimeAlarm)
                     {
-                        Singleton<EquipmentManager>.Instance.EDWaferTypeUseTimeWarning.Set($"more than {SC.GetValue<double>($"PM1.WaferCycleTime.EDTimeWarning")} hour");
+                        DateTimeUtil.ConvertSecondsToHoursAndMinutes(EDTimeWarning, out var hours, out var minutes);
+                        Singleton<ScheduleMaintenanceDataManager>.Instance.MaintenanceProcessingCommandExec(maintenanceItemEDWaferUserTime.MaintenanceProcessing, Singleton<EquipmentManager>.Instance.EDWaferTypeUseTimeWarning.Set, $"more than {hours} hour {minutes} min");
                     }
 
-                    if (wafer.WaferType == WaferType.ED && SC.GetValue<bool>($"PM1.WaferCycleTime.IsEnableEDWaferThicknessWarning") && wafer.UseThick > SC.GetValue<double>($"PM1.WaferCycleTime.EDThicknessWarning") && wafer.UseThick < SC.GetValue<double>($"PM1.WaferCycleTime.EDThicknessAlarm"))
+                    if (wafer.WaferType == WaferType.ED && IsEnableEDWaferThicknessWarning && wafer.UseThick > EDThicknessWarning && wafer.UseThick < EDThicknessAlarm)
                     {
-                        Singleton<EquipmentManager>.Instance.EDWaferTypeThicknessWarning.Set($"more than {SC.GetValue<double>($"PM1.WaferCycleTime.EDThicknessWarning")} nm");
+                        Singleton<ScheduleMaintenanceDataManager>.Instance.MaintenanceProcessingCommandExec(maintenanceItemEDWaferThickness.MaintenanceProcessing, Singleton<EquipmentManager>.Instance.EDWaferTypeThicknessWarning.Set, $"more than {EDThicknessWarning} nm");
                     }
 
-                    if (wafer.WaferType == WaferType.ED && SC.GetValue<bool>($"PM1.WaferCycleTime.IsEnableEDWaferUseCountWarning") && wafer.UseCount >= SC.GetValue<int>($"PM1.WaferCycleTime.EDCountAlarm"))
+                    if (wafer.WaferType == WaferType.ED && IsEnableEDWaferUseCountWarning && wafer.UseCount >= EDCountAlarm)
                     {
-                        Singleton<EquipmentManager>.Instance.EDWaferTypeUseCountAlarm.Set($"more than {SC.GetValue<int>($"PM1.WaferCycleTime.EDCountAlarm")} 次");
-
+                        Singleton<ScheduleMaintenanceDataManager>.Instance.MaintenanceProcessingCommandExec(maintenanceItemEDCarrierUseFreq.MaintenanceProcessing, Singleton<EquipmentManager>.Instance.EDWaferTypeUseCountAlarm.Set, $"more than {EDCountAlarm} 次");
                         return false;
                     }
 
-                    if (wafer.WaferType == WaferType.ED && SC.GetValue<bool>($"PM1.WaferCycleTime.IsEnableEDWaferUseTimeWarning") && wafer.UseTime / 3600 >= SC.GetValue<double>($"PM1.WaferCycleTime.EDTimeAlarm"))
+                    if (wafer.WaferType == WaferType.ED && IsEnableEDWaferUseTimeWarning && wafer.UseTime >= EDTimeAlarm)
                     {
-                        Singleton<EquipmentManager>.Instance.EDWaferTypeUseTimeAlarm.Set($"more than {SC.GetValue<double>($"PM1.WaferCycleTime.EDTimeAlarm")} hour");
-
+                        DateTimeUtil.ConvertSecondsToHoursAndMinutes(EDTimeAlarm, out var hours, out var minutes);
+                        Singleton<ScheduleMaintenanceDataManager>.Instance.MaintenanceProcessingCommandExec(maintenanceItemEDWaferUserTime.MaintenanceProcessing, Singleton<EquipmentManager>.Instance.EDWaferTypeUseTimeAlarm.Set, $"more than {hours} hour {minutes}");
                         return false;
                     }
 
-                    if (wafer.WaferType == WaferType.ED && SC.GetValue<bool>($"PM1.WaferCycleTime.IsEnableEDWaferThicknessWarning") && wafer.UseThick >= SC.GetValue<double>($"PM1.WaferCycleTime.EDThicknessAlarm"))
+                    if (wafer.WaferType == WaferType.ED && IsEnableEDWaferThicknessWarning && wafer.UseThick >= EDThicknessAlarm)
                     {
-                        Singleton<EquipmentManager>.Instance.EDWaferTypeThicknessAlarm.Set($"more than {SC.GetValue<double>($"PM1.WaferCycleTime.EDThicknessAlarm")} nm");
-
+                        Singleton<ScheduleMaintenanceDataManager>.Instance.MaintenanceProcessingCommandExec(maintenanceItemEDWaferThickness.MaintenanceProcessing, Singleton<EquipmentManager>.Instance.EDWaferTypeThicknessAlarm.Set, $"more than {EDThicknessAlarm} nm");
                         return false;
                     }
+                    #endregion
+
                 }
             }
 

Furnace/FurnaceRT/Equipments/PMs/PMModule.cs

@@ -255,7 +255,6 @@ namespace FurnaceRT.Equipments.PMs
 
             InitAlarmConditionChecker();
 
-            InitScheduleMaintenance();
 
             Singleton<EventManager>.Instance.OnAlarmEvent += Instance_OnAlarmEvent;
             ToolType = SC.GetStringValue("System.SetUp.ToolType");

Furnace/FurnaceRT/Equipments/PMs/PMScheduleMaintenance.cs

@@ -6,6 +6,7 @@ using Aitex.Core.RT.Log;
 using Aitex.Core.RT.OperationCenter;
 using Aitex.Core.RT.SCCore;
 using Aitex.Core.Util;
+using MECF.Framework.Common.CommonData.EnumData;
 using MECF.Framework.Common.DataCenter;
 using MECF.Framework.Common.Event;
 using MECF.Framework.Common.OperationCenter;
@@ -19,135 +20,6 @@ namespace FurnaceRT.Equipments.PMs
 {
     public partial class PMModule
     {
-        private Dictionary<string, string> _stepThickness;
-        private ScheduleMaintenanceData _sdCarrierUseFreq;
-        private ScheduleMaintenanceData _sdWaferThickness;
-        private ScheduleMaintenanceData _sdUsableWafer;
-        private ScheduleMaintenanceData _sdBufferRackStayTime;
-        
-        private ScheduleMaintenanceData _fdCarrierUseFreq;
-        private ScheduleMaintenanceData _fdWaferThickness;
-        private ScheduleMaintenanceData _fdUsableWafer;
-        private ScheduleMaintenanceData _fdBufferRackStayTime;
-
-        private ScheduleMaintenanceData _onBoatDummyWaferUse;
-        private ScheduleMaintenanceData _onBoatDummyWaferThick;
-        private ScheduleMaintenanceData _boatRecipeThickness1;
-        private ScheduleMaintenanceData _boatRecipeThickness2;
-        private ScheduleMaintenanceData _boatRecipeThickness3;
-
-        private ScheduleMaintenanceData _nonOperationTime1;
-        private ScheduleMaintenanceData _nonOperationTime2;
-
-        private ScheduleMaintenanceData _recipeExecuteFreq;
-        private ScheduleMaintenanceData _recipeThickness;
-
-        private ScheduleMaintenanceData _recipeStepExecuteFreq1;
-        private ScheduleMaintenanceData _recipeStepExecuteFreq2;
-        private ScheduleMaintenanceData _recipeStepExecuteFreq3;
-
-        private ScheduleMaintenanceData _recipeStepExecuteTime1;
-        private ScheduleMaintenanceData _recipeStepExecuteTime2;
-        private ScheduleMaintenanceData _recipeStepExecuteTime3;
-        private ScheduleMaintenanceData _recipeStepExecuteTime4;
-        private ScheduleMaintenanceData _recipeStepExecuteTime5;
-        private ScheduleMaintenanceData _recipeStepExecuteTime6;
-        private ScheduleMaintenanceData _recipeStepExecuteTime7;
-        private ScheduleMaintenanceData _recipeStepExecuteTime8;
-
-        private ScheduleMaintenanceData _recipeStepThickness1;
-        private ScheduleMaintenanceData _recipeStepThickness2;
-        private ScheduleMaintenanceData _recipeStepThickness3;
-        private ScheduleMaintenanceData _recipeStepThickness4;
-        private ScheduleMaintenanceData _recipeStepThickness5;
-        private ScheduleMaintenanceData _recipeStepThickness6;
-        private ScheduleMaintenanceData _recipeStepThickness7;
-        private ScheduleMaintenanceData _recipeStepThickness8;
-        private void InitScheduleMaintenance()
-        {
-            _sdCarrierUseFreq = new ScheduleMaintenanceData("SDCarrierUseFreq", "SDCarrierUseFreq", "Times", 0, 0, "None", "CarrierWafer.SieDummy", "Carrier Kind", "Side Dummy");
-            _sdWaferThickness = new ScheduleMaintenanceData("SDWaferThickness", "SDWaferThickness", "Å", 0, 0, "None", "CarrierWafer.SieDummy", "Carrier Kind", "Side Dummy");
-            _sdUsableWafer = new ScheduleMaintenanceData("SDUsableDummyWafer", "SDWaferRemain", "Sheets", 0, 0, "None", "CarrierWafer.SieDummy", "Carrier Kind", "Side Dummy");
-            _sdBufferRackStayTime = new ScheduleMaintenanceData("SDBufferRackStayTime", "SDCarrierStay", "h:m", 0, 0, "None", "CarrierWafer.SieDummy", "Carrier Kind", "Side Dummy");
-
-            _fdCarrierUseFreq = new ScheduleMaintenanceData("FDCarrierUseFreq", "FDCarrierUseFreq", "Times", 0, 0, "None", "CarrierWafer.FillDummy", "Carrier Kind", "Fill Dummy");
-            _fdWaferThickness = new ScheduleMaintenanceData("FDWaferThickness", "FDWaferThickness", "Å", 0, 0, "None", "CarrierWafer.FillDummy", "Carrier Kind", "Fill Dummy");
-            _fdUsableWafer = new ScheduleMaintenanceData("FDUsableDummyWafer", "FDWaferRemain", "Sheets", 0, 0, "None", "CarrierWafer.FillDummy", "Carrier Kind", "Fill Dummy");
-            _fdBufferRackStayTime = new ScheduleMaintenanceData("FDBufferRackStayTime", "FDCarrierStay", "h:m", 0, 0, "None", "CarrierWafer.FillDummy", "Carrier Kind", "Fill Dummy");
-
-            _onBoatDummyWaferUse = new ScheduleMaintenanceData("OnBoatDummyWaferUse", "OnBoatDummyWaferUse", "Times", 0, 0, "None", "Boat", "", "");
-            _onBoatDummyWaferThick = new ScheduleMaintenanceData("OnBoatDummyWaferThick", "OnBoatDummyWaferThick", "Å", 0, 0, "None", "Boat", "", "");
-            _boatRecipeThickness1 = new ScheduleMaintenanceData("BoatRecipeThickness1", "BoatRecipeThickness1", "Å", 0, 0, "None", "Boat", "", "");
-            _boatRecipeThickness2 = new ScheduleMaintenanceData("BoatRecipeThickness2", "BoatRecipeThickness2", "Å", 0, 0, "None", "Boat", "", "");
-            _boatRecipeThickness3 = new ScheduleMaintenanceData("BoatRecipeThickness3", "BoatRecipeThickness3", "Å", 0, 0, "None", "Boat", "", "");
-
-            _nonOperationTime1 = new ScheduleMaintenanceData("NonOperationTime1", "NonOperationTime1", "h:m", 0, 0, "None", "Conditioning", "", "");
-            _nonOperationTime2 = new ScheduleMaintenanceData("NonOperationTime2", "NonOperationTime2", "h:m", 0, 0, "None", "Conditioning", "", "");
-
-            _recipeExecuteFreq = new ScheduleMaintenanceData("RecipeExecuteFreq", "Recipe Run Freq", "Times", 0, 0, "None", "Reactor.Recipe", "", "");
-            _recipeThickness = new ScheduleMaintenanceData("RecipeThickness", "Recipe Thickness", "Å", 0, 0, "None", "Reactor.Recipe", "", "");
-
-            _recipeStepExecuteFreq1 = new ScheduleMaintenanceData("RecipeStepExecuteFreq1", "Recipe StepRunTime1", "Times", 0, 0, "None", "Reactor.StepRunFreq", "Step ID", "");
-            _recipeStepExecuteFreq2 = new ScheduleMaintenanceData("RecipeStepExecuteFreq2", "Recipe StepRunTime2", "Times", 0, 0, "None", "Reactor.StepRunFreq", "Step ID", "");
-            _recipeStepExecuteFreq3 = new ScheduleMaintenanceData("RecipeStepExecuteFreq3", "Recipe StepRunTime3", "Times", 0, 0, "None", "Reactor.StepRunFreq", "Step ID", "");
-
-            _recipeStepExecuteTime1 = new ScheduleMaintenanceData("RecipeStepExecuteTime1", "Recipe StepRunTime1", "h:m", 0, 0, "None", "Reactor.StepRunTime", "Step ID", "");
-            _recipeStepExecuteTime2 = new ScheduleMaintenanceData("RecipeStepExecuteTime2", "Recipe StepRunTime2", "h:m", 0, 0, "None", "Reactor.StepRunTime", "Step ID", "");
-            _recipeStepExecuteTime3 = new ScheduleMaintenanceData("RecipeStepExecuteTime3", "Recipe StepRunTime3", "h:m", 0, 0, "None", "Reactor.StepRunTime", "Step ID", "");
-            _recipeStepExecuteTime4 = new ScheduleMaintenanceData("RecipeStepExecuteTime4", "Recipe StepRunTime4", "h:m", 0, 0, "None", "Reactor.StepRunTime", "Step ID", "");
-            _recipeStepExecuteTime5 = new ScheduleMaintenanceData("RecipeStepExecuteTime5", "Recipe StepRunTime5", "h:m", 0, 0, "None", "Reactor.StepRunTime", "Step ID", "");
-            _recipeStepExecuteTime6 = new ScheduleMaintenanceData("RecipeStepExecuteTime6", "Recipe StepRunTime6", "h:m", 0, 0, "None", "Reactor.StepRunTime", "Step ID", "");
-            _recipeStepExecuteTime7 = new ScheduleMaintenanceData("RecipeStepExecuteTime7", "Recipe StepRunTime7", "h:m", 0, 0, "None", "Reactor.StepRunTime", "Step ID", "");
-            _recipeStepExecuteTime8 = new ScheduleMaintenanceData("RecipeStepExecuteTime8", "Recipe StepRunTime8", "h:m", 0, 0, "None", "Reactor.StepRunTime", "Step ID", "");
-
-            _recipeStepThickness1 = new ScheduleMaintenanceData("Recipe Thickness1(Step)", "Recipe StepThickness1", "Å", 0, 0, "None", "Reactor.StepThickness", "Step Group", "Group 1");
-            _recipeStepThickness2 = new ScheduleMaintenanceData("Recipe Thickness2(Step)", "Recipe StepThickness2", "Å", 0, 0, "None", "Reactor.StepThickness", "Step Group", "Group 2");
-            _recipeStepThickness3 = new ScheduleMaintenanceData("Recipe Thickness3(Step)", "Recipe StepThickness3", "Å", 0, 0, "None", "Reactor.StepThickness", "Step Group", "Group 3");
-            _recipeStepThickness4 = new ScheduleMaintenanceData("Recipe Thickness4(Step)", "Recipe StepThickness4", "Å", 0, 0, "None", "Reactor.StepThickness", "Step Group", "Group 4");
-            _recipeStepThickness5 = new ScheduleMaintenanceData("Recipe Thickness5(Step)", "Recipe StepThickness5", "Å", 0, 0, "None", "Reactor.StepThickness", "Step Group", "Group 5");
-            _recipeStepThickness6 = new ScheduleMaintenanceData("Recipe Thickness6(Step)", "Recipe StepThickness6", "Å", 0, 0, "None", "Reactor.StepThickness", "Step Group", "Group 6");
-            _recipeStepThickness7 = new ScheduleMaintenanceData("Recipe Thickness7(Step)", "Recipe StepThickness7", "Å", 0, 0, "None", "Reactor.StepThickness", "Step Group", "Group 7");
-            _recipeStepThickness8 = new ScheduleMaintenanceData("Recipe Thickness8(Step)", "Recipe StepThickness8", "Å", 0, 0, "None", "Reactor.StepThickness", "Step Group", "Group 8");
-
-            _stepThickness = new Dictionary<string, string>()
-            {
-                {"1","WAIT"},
-                {"2","Name"},
-            };
-        }
-        public void UpdateRecipeTotalThickness(string recipeName, float thickness)
-        {
-
-        }
-        public void UpdateRecipeStepThicknessAndTime(string stepName, float thickness, float timeS)
-        {
-            if (string.IsNullOrEmpty(stepName))
-                return;
-            var checkName = stepName;
-            var nameParas = stepName.Split(':');
-            if (nameParas != null && nameParas.Length > 1)
-                checkName = nameParas[1];
-        }
-        public bool CheckScheduleMaintenanceBeforeJobStart(out string reason)
-        {
-            reason = "";
-            return true;
-        }
-        private void ProcessMaintenanceProcessingCommand(string command)
-        {
-            switch(command)
-            {
-                case "None":
-                    break;
-                case "Alarm Report":
-                    break;
-                case "JobProhibition":
-                    break;
-                case "JobManualStart":
-                    break;
-                case "JobAutoStart":
-                    break;
-            }
-        }
+       
     }
 }

Furnace/FurnaceRT/Equipments/PMs/RecipeExecutions/Process.cs

@@ -14,6 +14,7 @@ using System;
 using System.Collections.Generic;
 using FurnaceRT.Equipments.PMs.Routines;
 using System.Diagnostics;
+using MECF.Framework.Common.DataCenter;
 
 namespace FurnaceRT.Equipments.PMs.RecipeExecutions
 {
@@ -744,7 +745,7 @@ namespace FurnaceRT.Equipments.PMs.RecipeExecutions
 
                                 if(!_isJumpStep)
                                 {
-                                    PMModule.UpdateRecipeStepThicknessAndTime(stepName, thickness, stepTime);
+                                    Singleton<ScheduleMaintenanceDataManager>.Instance.UpdateRecipeStepThicknessAndTime(stepName, thickness, stepTime);
                                     var wafers = WaferManager.Instance.GetWafers(ModuleHelper.Converter(Module));
                                     for (int i = 0; i < wafers.Length; i++)
                                     {

Furnace/FurnaceRT/Instances/ToolLoader.cs

@@ -84,6 +84,7 @@ namespace FurnaceRT.Instances
 
             WaferManager.Instance.Initialize();
             CarrierManager.Instance.Initialize();
+            CarrierManager.Instance.Initialize();
 
             Singleton<DeviceManager>.Instance.DisableAsyncInitialize = true;
 

Furnace/FurnaceUI/Views/Scheduled/ScheduledMaintenanceMonitorView.xaml

@@ -334,13 +334,27 @@
                     Margin="5,0"
                     FontSize="20"
                     Text="{Binding EditModel.StartValue, StringFormat={}{0:000.000}, UpdateSourceTrigger=PropertyChanged, Mode=TwoWay}" />
-                <TextBox
+
+                <ComboBox x:Name="cbPickModulesCassetteRobot" Grid.Row="1"
+Grid.Column="1"
+Height="40"
+Margin="5,0"
+FontSize="20" ItemsSource="{Binding MaintenanceProcessingList}"  SelectedItem="{Binding EditModel.MaintenanceProcessing, UpdateSourceTrigger=PropertyChanged, Mode=TwoWay}" />
+                <Button Grid.Row="1" Grid.Column="2" Visibility="{Binding JobAutoStartCommandVisibility,UpdateSourceTrigger=PropertyChanged,Converter={StaticResource bool2VisibilityConverter}}"   Grid.ColumnSpan="2" Width="auto" Content="{Binding EditModel.AssociationProcessRecipeName,UpdateSourceTrigger=PropertyChanged}">
+                    <i:Interaction.Triggers>
+                        <i:EventTrigger EventName="Click">
+                            <cal:ActionMessage MethodName="SelectProcessRecipe">
+                            </cal:ActionMessage>
+                        </i:EventTrigger>
+                    </i:Interaction.Triggers>
+                </Button>
+                <!--<TextBox
                     Grid.Row="1"
                     Grid.Column="1"
                     Height="40"
                     Margin="5,0"
                     FontSize="20"
-                    Text="{Binding EditModel.MaintenanceProcessing, UpdateSourceTrigger=PropertyChanged, Mode=TwoWay}" />
+                    Text="{Binding EditModel.MaintenanceProcessing, UpdateSourceTrigger=PropertyChanged, Mode=TwoWay}" />-->
                 <TextBox
                     Grid.Row="0"
                     Grid.Column="2"

Furnace/FurnaceUI/Views/Scheduled/ScheduledMaintenanceMonitorViewModel.cs

@@ -1,5 +1,16 @@
-using FurnaceUI.Models;
+using Aitex.Core.Util;
+using Aitex.Core.Utilities;
+using Caliburn.Micro;
+using FurnaceUI.Models;
+using MECF.Framework.Common.CommonData.EnumData;
+using MECF.Framework.Common.DataCenter;
 using MECF.Framework.Common.Utilities;
+using MECF.Framework.UI.Client.CenterViews.Editors.Recipe;
+using MECF.Framework.UI.Client.CenterViews.Editors.Sequence;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Data;
+using System.Windows.Documents;
 
 namespace FurnaceUI.Views.Editors
 {
@@ -14,7 +25,39 @@ namespace FurnaceUI.Views.Editors
         public ScheduledMaintenanceMonitorViewModel(ScheduleMaintenanceDataItem dataItem)
         {
             EditModel = CloneUtil.CloneObject(dataItem) as ScheduleMaintenanceDataItem;
+
+
+            EnumLoop<MaintenanceProcessingCommandEnum>.ForEach((item) =>
+            {
+                MaintenanceProcessingList.Add(item.ToString());
+            });
         }
+        private bool _jobAutoStartCommandVisibility = false;
+
+        public bool JobAutoStartCommandVisibility
+        {
+            get => _jobAutoStartCommandVisibility;
+            set
+            {
+                _jobAutoStartCommandVisibility = value;
+                NotifyOfPropertyChange("JobAutoStartCommandVisibility");
+            }
+        }
+
+  
+
+        private List<string> _maintenanceProcessingList = new List<string>();
+
+        public List<string> MaintenanceProcessingList
+        {
+            get => _maintenanceProcessingList;
+            set
+            {
+                _maintenanceProcessingList = value;
+                NotifyOfPropertyChange("MaintenanceProcessingList");
+            }
+        }
+
         #endregion
 
         #region 属性 EditModel
@@ -24,12 +67,15 @@ namespace FurnaceUI.Views.Editors
         public ScheduleMaintenanceDataItem EditModel { get; set; }
         #endregion
 
-      
+
         public bool IsEnable
         {
             get { return _isEnable; }
-            set { _isEnable = value;
-                NotifyOfPropertyChange("IsEnable"); }
+            set
+            {
+                _isEnable = value;
+                NotifyOfPropertyChange("IsEnable");
+            }
         }
         private bool _isEnable;
 
@@ -41,9 +87,55 @@ namespace FurnaceUI.Views.Editors
         public void CurrentValueChange()
         {
             IsEnable = !IsEnable;
-        } 
+        }
         #endregion
+        protected override void InvokeAfterUpdateProperty(Dictionary<string, object> data)
+        {
+            if (EditModel != null && !string.IsNullOrEmpty(EditModel.MaintenanceProcessing) && EditModel.MaintenanceProcessing == MaintenanceProcessingCommandEnum.JobAutoStart.ToString())
+            {
+                JobAutoStartCommandVisibility = true;
+            }
+            else
+            {
+                EditModel.AssociationProcessRecipeName = "";
+                JobAutoStartCommandVisibility = false;
+            }
+
+        }
+        public void SelectProcessRecipe()
+        {
+            RecipeSelectDialogViewModel dialog = new RecipeSelectDialogViewModel();
+            dialog.DisplayName = "Select Recipe";
+
+            var recipeProvider = new RecipeProvider();
+            var processType = QueryDataClient.Instance.Service.GetConfig($"System.Recipe.SupportedProcessType");
+            if (processType == null)
+            {
+                processType = "Process";
+            }
 
+            var ProcessTypeFileList = new ObservableCollection<ProcessTypeFileItem>();
+            string[] recipeProcessType = ((string)processType).Split(',');
+
+
+            var type = new ProcessTypeFileItem();
+            type.ProcessType = recipeProcessType[0];
+            var prefix = $"Furnace\\{recipeProcessType[0]}";
+            var recipes = recipeProvider.GetXmlRecipeList(prefix);
+            type.FileListByProcessType = RecipeSequenceTreeBuilder.BuildFileNode(prefix, "", false, recipes)[0].Files;
+            ProcessTypeFileList.Add(type);
+
+
+            dialog.ProcessTypeFileList = ProcessTypeFileList;
+
+            WindowManager wm = new WindowManager();
+            bool? bret = wm.ShowDialog(dialog);
+            if ((bool)bret)
+            {
+
+                EditModel.AssociationProcessRecipeName = dialog.DialogResult;
+            }
+        }
         #region 方法 ClearCurrentValue
         /// <summary>
         /// ClearCurrentValue
@@ -54,7 +146,7 @@ namespace FurnaceUI.Views.Editors
             {
                 EditModel.CurrentValue = 0;
             }
-        } 
+        }
         #endregion
 
         #region 方法 SetSave

Furnace/FurnaceUI/Views/Scheduled/ScheduledMaitViewModel.cs

@@ -146,7 +146,7 @@ namespace FurnaceUI.Views.Editors
                     var rtn = (wm as WindowManager)?.ShowDialogWithTitle(scheduledMaintenanceMonitorViewModel, null, "Maintenance Setting");
                     if (rtn == true)
                     {
-                     
+
                         if (!string.IsNullOrEmpty(scheduledMaintenanceMonitorViewModel.EditModel.AdditionInformationDisplay) && selectedItem.AdditionInformationDisplay != scheduledMaintenanceMonitorViewModel.EditModel.AdditionInformationDisplay)
                         {
                             selectedItem.AdditionInformationDisplay = scheduledMaintenanceMonitorViewModel.EditModel.AdditionInformationDisplay;
@@ -173,9 +173,17 @@ namespace FurnaceUI.Views.Editors
 
                         if (!string.IsNullOrEmpty(scheduledMaintenanceMonitorViewModel.EditModel.MaintenanceProcessing) && selectedItem.MaintenanceProcessing != scheduledMaintenanceMonitorViewModel.EditModel.MaintenanceProcessing)
                         {
-                            InvokeClient.Instance.Service.DoOperation("System.ScheduleMaintenance.SetMaintenanceProcessing", selectedItem.Item, selectedItem.LimitValue);
+                            selectedItem.MaintenanceProcessing = scheduledMaintenanceMonitorViewModel.EditModel.MaintenanceProcessing;
+                            InvokeClient.Instance.Service.DoOperation("System.ScheduleMaintenance.SetMaintenanceProcessing", selectedItem.Item, selectedItem.MaintenanceProcessing);
+
+                            selectedItem.AssociationProcessRecipeName = scheduledMaintenanceMonitorViewModel.EditModel.AssociationProcessRecipeName;
+                            InvokeClient.Instance.Service.DoOperation("System.ScheduleMaintenance.SetAssociationProcessRecipeName", selectedItem.Item, selectedItem.AssociationProcessRecipeName);
+                        }
+                        if (!string.IsNullOrEmpty(scheduledMaintenanceMonitorViewModel.EditModel.AssociationProcessRecipeName) && selectedItem.AssociationProcessRecipeName != scheduledMaintenanceMonitorViewModel.EditModel.AssociationProcessRecipeName)
+                        {
+                            selectedItem.AssociationProcessRecipeName = scheduledMaintenanceMonitorViewModel.EditModel.AssociationProcessRecipeName;
+                            InvokeClient.Instance.Service.DoOperation("System.ScheduleMaintenance.SetAssociationProcessRecipeName", selectedItem.Item, selectedItem.AssociationProcessRecipeName);
                         }
-                     
                         if (selectedItem.StartValue != scheduledMaintenanceMonitorViewModel.EditModel.StartValue)
                         {
                             selectedItem.StartValue = scheduledMaintenanceMonitorViewModel.EditModel.StartValue;
@@ -195,6 +203,10 @@ namespace FurnaceUI.Views.Editors
         protected override void OnViewLoaded(object view)
         {
             base.OnViewLoaded(view);
+        }
+        protected override void OnActivate()
+        {
+
             LoadData();
         }
         #endregion
@@ -220,6 +232,7 @@ namespace FurnaceUI.Views.Editors
                 item.Path = dt.Rows[i]["path"].ToString();
                 item.AdditionInformationName = dt.Rows[i]["addition_information_name"].ToString();
                 item.AdditionInformationDisplay = dt.Rows[i]["addition_information_display"].ToString();
+                item.AssociationProcessRecipeName = dt.Rows[i]["association_process_recipeName"].ToString();
                 if (float.TryParse(dt.Rows[i]["current_value"].ToString(), out float value))
                     item.CurrentValue = value;
                 if (float.TryParse(dt.Rows[i]["scheduling_start_value"].ToString(), out value))
@@ -447,7 +460,16 @@ namespace FurnaceUI.Views.Editors
         }
         private float _limitValue;
 
-
+        public string AssociationProcessRecipeName
+        {
+            get { return _associationProcessRecipeName; }
+            set
+            {
+                _associationProcessRecipeName = value;
+                InvokePropertyChanged("AssociationProcessRecipeName");
+            }
+        }
+        private string _associationProcessRecipeName;
 
         public string MaintenanceProcessing
         {