fix bug wafer /Recipe check

Furnace/FurnaceRT/Equipments/Jobs/AutoTransfer.cs

@@ -43,6 +43,7 @@ using MECF.Framework.Common.Utilities;
 using System.Threading;
 using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.PMs;
 using System.Reflection;
+using MECF.Framework.UI.Client.CenterViews.Editors.Recipe;
 
 namespace FurnaceRT.Equipments.Jobs
 {
@@ -5922,12 +5923,362 @@ namespace FurnaceRT.Equipments.Jobs
                 if (wafers == null)
                     continue;
 
-                pm.GetAllDBRecord();
+                var isScheduleMaintenance = SC.ContainsItem("System.EnableScheduleMaintenance") && SC.GetValue<bool>("System.EnableScheduleMaintenance");
+                if (isScheduleMaintenance)
+                {
+                    pm.GetAllDBRecord();
+                }
 
-                if (!pm.CheckDumyWafer(wafers))
+                foreach (var wafer in wafers)
                 {
-                    return false;
-                };
+                    if (wafer == null || wafer.IsEmpty || (wafer.WaferType != WaferType.SD && wafer.WaferType != WaferType.ED))
+                        continue;
+                    #region New
+                    if (isScheduleMaintenance)
+                    {
+                        #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());
+
+
+
+                        if (wafer.WaferType == WaferType.SD && maintenanceItemSDCarrierUseFreq.StartValue > 0 && wafer.UseCount > maintenanceItemSDCarrierUseFreq.StartValue && wafer.UseCount < maintenanceItemSDCarrierUseFreq.LimitValue)
+                        {
+                            if (maintenanceItemSDCarrierUseFreq.MaintenanceProcessing == MaintenanceProcessingCommandEnum.AlarmReport.ToString())
+                            {
+                                var msg = pm.GetAlarmWarningMsg(maintenanceItemSDCarrierUseFreq);
+                                Singleton<EquipmentManager>.Instance.SDWaferTypeUseCountWarning.Set(msg);
+                            }
+                        }
+
+                        if (wafer.WaferType == WaferType.SD && maintenanceItemSDWaferUserTime.StartValue > 0 && wafer.UseTime > maintenanceItemSDWaferUserTime.StartValue && wafer.UseTime < maintenanceItemSDWaferUserTime.LimitValue)
+                        {
+
+                            if (maintenanceItemSDWaferUserTime.MaintenanceProcessing == MaintenanceProcessingCommandEnum.AlarmReport.ToString())
+                            {
+                                var currentValue = DateTimeUtil.SecondToHHmmss(maintenanceItemSDWaferUserTime.CurrentValue.ToString());
+                                var minValue = DateTimeUtil.SecondToHHmmss(maintenanceItemSDWaferUserTime.StartValue.ToString());
+                                var maxValue = DateTimeUtil.SecondToHHmmss(maintenanceItemSDWaferUserTime.LimitValue.ToString());
+                                var msg = pm.GetAlarmWarningMsg(maintenanceItemSDWaferUserTime, true, currentValue, minValue, maxValue);
+                                Singleton<EquipmentManager>.Instance.SDWaferTypeUseTimeWarning.Set(msg);
+                            }
+                        }
+
+                        if (wafer.WaferType == WaferType.SD && maintenanceItemSDWaferThickness.StartValue > 0 && wafer.UseThick > maintenanceItemSDWaferThickness.StartValue && wafer.UseThick < maintenanceItemSDWaferThickness.LimitValue)
+                        {
+                            if (maintenanceItemSDWaferThickness.MaintenanceProcessing == MaintenanceProcessingCommandEnum.AlarmReport.ToString())
+                            {
+                                var msg = pm.GetAlarmWarningMsg(maintenanceItemSDWaferThickness);
+                                Singleton<EquipmentManager>.Instance.SDWaferTypeThicknessWarning.Set(msg);
+                            }
+                        }
+
+                        if (wafer.WaferType == WaferType.SD && maintenanceItemSDCarrierUseFreq.StartValue > 0 && wafer.UseCount >= maintenanceItemSDCarrierUseFreq.LimitValue)
+                        {
+                            if (maintenanceItemSDCarrierUseFreq.MaintenanceProcessing == MaintenanceProcessingCommandEnum.None.ToString())
+                                continue;
+
+                            if (maintenanceItemSDCarrierUseFreq.MaintenanceProcessing == MaintenanceProcessingCommandEnum.AlarmReport.ToString())
+                            {
+                                var msg = pm.GetAlarmWarningMsg(maintenanceItemSDCarrierUseFreq);
+                                Singleton<EquipmentManager>.Instance.SDWaferTypeUseCountAlarm.Set(msg);
+                                return false;
+                            }
+                            else if (maintenanceItemSDCarrierUseFreq.MaintenanceProcessing == MaintenanceProcessingCommandEnum.JobAutoStart.ToString())
+                            {
+                                var msg = pm.GetAlarmWarningMsg(maintenanceItemSDCarrierUseFreq, true);
+
+                                if (string.IsNullOrEmpty(maintenanceItemSDCarrierUseFreq.AssociationProcessRecipeName))
+                                {
+                                    Singleton<EquipmentManager>.Instance.SDWaferTypeUseCountAlarm.Set(msg);
+                                    return false;
+                                }
+
+
+                                Singleton<EquipmentManager>.Instance.SDWaferTypeUseCountAlarm.Set(msg);
+                                pm.TriggerJobAutoStart(maintenanceItemSDCarrierUseFreq.AssociationProcessRecipeName);
+                                LOG.Info($"{msg} Trigger {maintenanceItemSDCarrierUseFreq.AssociationProcessRecipeName}");
+                                return false;
+
+                            }
+                        }
+
+                        if (wafer.WaferType == WaferType.SD && maintenanceItemSDWaferUserTime.StartValue > 0 && wafer.UseTime >= maintenanceItemSDWaferUserTime.LimitValue)
+                        {
+                            if (maintenanceItemSDWaferUserTime.MaintenanceProcessing == MaintenanceProcessingCommandEnum.None.ToString())
+                                continue;
+
+
+                            var currentValue = DateTimeUtil.SecondToHHmmss(maintenanceItemSDWaferUserTime.CurrentValue.ToString());
+                            var minValue = DateTimeUtil.SecondToHHmmss(maintenanceItemSDWaferUserTime.StartValue.ToString());
+                            var maxValue = DateTimeUtil.SecondToHHmmss(maintenanceItemSDWaferUserTime.LimitValue.ToString());
+                            var msg = pm.GetAlarmWarningMsg(maintenanceItemSDWaferUserTime, true, currentValue, minValue, maxValue);
+
+                            if (maintenanceItemSDWaferUserTime.MaintenanceProcessing == MaintenanceProcessingCommandEnum.AlarmReport.ToString())
+                            {
+                                Singleton<EquipmentManager>.Instance.SDWaferTypeUseTimeAlarm.Set(msg);
+                                return false;
+                            }
+                            else if (maintenanceItemSDWaferUserTime.MaintenanceProcessing == MaintenanceProcessingCommandEnum.JobAutoStart.ToString())
+                            {
+
+                                if (string.IsNullOrEmpty(maintenanceItemSDWaferUserTime.AssociationProcessRecipeName))
+                                {
+                                    Singleton<EquipmentManager>.Instance.SDWaferTypeUseTimeAlarm.Set(msg);
+                                    return false;
+                                }
+
+                                Singleton<EquipmentManager>.Instance.SDWaferTypeUseTimeAlarm.Set(msg);
+                                pm.TriggerJobAutoStart(maintenanceItemSDWaferUserTime.AssociationProcessRecipeName);
+                                LOG.Info($"{msg} Trigger {maintenanceItemSDWaferUserTime.AssociationProcessRecipeName}");
+                                return false;
+
+                            }
+
+                        }
+
+                        if (wafer.WaferType == WaferType.SD && maintenanceItemSDWaferThickness.StartValue > 0 && wafer.UseThick >= maintenanceItemSDWaferThickness.LimitValue)
+                        {
+                            if (maintenanceItemSDWaferThickness.MaintenanceProcessing == MaintenanceProcessingCommandEnum.None.ToString())
+                                continue;
+
+                            if (maintenanceItemSDWaferThickness.MaintenanceProcessing == MaintenanceProcessingCommandEnum.AlarmReport.ToString())
+                            {
+                                var msg = pm.GetAlarmWarningMsg(maintenanceItemSDWaferThickness);
+                                Singleton<EquipmentManager>.Instance.SDWaferTypeThicknessAlarm.Set(msg);
+                                return false;
+                            }
+                            else if (maintenanceItemSDWaferThickness.MaintenanceProcessing == MaintenanceProcessingCommandEnum.JobAutoStart.ToString())
+                            {
+                                var msg = pm.GetAlarmWarningMsg(maintenanceItemSDWaferThickness, true);
+
+                                if (string.IsNullOrEmpty(maintenanceItemSDWaferThickness.AssociationProcessRecipeName))
+                                {
+                                    Singleton<EquipmentManager>.Instance.SDWaferTypeThicknessAlarm.Set(msg);
+                                    return false;
+                                }
+
+
+                                Singleton<EquipmentManager>.Instance.SDWaferTypeThicknessAlarm.Set(msg);
+                                pm.TriggerJobAutoStart(maintenanceItemSDWaferThickness.AssociationProcessRecipeName);
+                                LOG.Info($"{msg} Trigger {maintenanceItemSDWaferThickness.AssociationProcessRecipeName}");
+                                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());
+
+                        if (wafer.WaferType == WaferType.ED && maintenanceItemEDCarrierUseFreq.StartValue > 0 && maintenanceItemEDCarrierUseFreq.CurrentValue > maintenanceItemEDCarrierUseFreq.StartValue && wafer.UseCount < maintenanceItemEDCarrierUseFreq.LimitValue)
+                        {
+                            if (maintenanceItemEDCarrierUseFreq.MaintenanceProcessing == MaintenanceProcessingCommandEnum.AlarmReport.ToString())
+                            {
+                                var msg = pm.GetAlarmWarningMsg(maintenanceItemEDCarrierUseFreq);
+                                Singleton<EquipmentManager>.Instance.EDWaferTypeUseCountWarning.Set(msg);
+                            }
+                        }
+
+                        if (wafer.WaferType == WaferType.ED && maintenanceItemEDWaferUserTime.StartValue > 0 && wafer.UseTime > maintenanceItemEDWaferUserTime.StartValue && wafer.UseTime < maintenanceItemEDWaferUserTime.LimitValue)
+                        {
+
+                            if (maintenanceItemEDWaferUserTime.MaintenanceProcessing == MaintenanceProcessingCommandEnum.AlarmReport.ToString())
+                            {
+                                var currentValue = DateTimeUtil.SecondToHHmmss(maintenanceItemEDWaferUserTime.CurrentValue.ToString());
+                                var minValue = DateTimeUtil.SecondToHHmmss(maintenanceItemEDWaferUserTime.StartValue.ToString());
+                                var maxValue = DateTimeUtil.SecondToHHmmss(maintenanceItemEDWaferUserTime.LimitValue.ToString());
+                                var msg = pm.GetAlarmWarningMsg(maintenanceItemEDWaferUserTime, true, currentValue, minValue, maxValue);
+
+                                Singleton<EquipmentManager>.Instance.EDWaferTypeUseTimeWarning.Set(msg);
+                            }
+
+                        }
+
+                        if (wafer.WaferType == WaferType.ED && maintenanceItemEDWaferThickness.StartValue > 0 && wafer.UseThick > maintenanceItemEDWaferThickness.StartValue && wafer.UseThick < maintenanceItemEDWaferThickness.LimitValue)
+                        {
+                            if (maintenanceItemEDWaferThickness.MaintenanceProcessing == MaintenanceProcessingCommandEnum.AlarmReport.ToString())
+                            {
+                                var msg = pm.GetAlarmWarningMsg(maintenanceItemEDWaferThickness);
+                                Singleton<EquipmentManager>.Instance.EDWaferTypeThicknessWarning.Set(msg);
+                            }
+                        }
+
+                        if (wafer.WaferType == WaferType.ED && maintenanceItemEDCarrierUseFreq.StartValue > 0 && wafer.UseCount >= maintenanceItemEDCarrierUseFreq.LimitValue)
+                        {
+
+                            if (maintenanceItemEDCarrierUseFreq.MaintenanceProcessing == MaintenanceProcessingCommandEnum.None.ToString())
+                                continue;
+
+                            if (maintenanceItemEDCarrierUseFreq.MaintenanceProcessing == MaintenanceProcessingCommandEnum.AlarmReport.ToString())
+                            {
+                                var msg = pm.GetAlarmWarningMsg(maintenanceItemEDCarrierUseFreq);
+                                Singleton<EquipmentManager>.Instance.EDWaferTypeUseCountAlarm.Set(msg);
+                                return false;
+                            }
+                            else if (maintenanceItemEDCarrierUseFreq.MaintenanceProcessing == MaintenanceProcessingCommandEnum.JobAutoStart.ToString())
+                            {
+                                var msg = pm.GetAlarmWarningMsg(maintenanceItemEDCarrierUseFreq);
+
+                                if (string.IsNullOrEmpty(maintenanceItemEDCarrierUseFreq.AssociationProcessRecipeName))
+                                {
+                                    Singleton<EquipmentManager>.Instance.EDWaferTypeUseCountAlarm.Set(msg);
+                                    return false;
+                                }
+                                Singleton<EquipmentManager>.Instance.EDWaferTypeUseCountAlarm.Set(msg);
+                                pm.TriggerJobAutoStart(maintenanceItemEDCarrierUseFreq.AssociationProcessRecipeName);
+                                LOG.Info($"{msg} Trigger {maintenanceItemEDCarrierUseFreq.AssociationProcessRecipeName}");
+                                return false;
+
+                            }
+                        }
+
+                        if (wafer.WaferType == WaferType.ED && maintenanceItemEDWaferUserTime.StartValue > 0 && wafer.UseTime >= maintenanceItemEDWaferUserTime.LimitValue)
+                        {
+                            if (maintenanceItemEDWaferUserTime.MaintenanceProcessing == MaintenanceProcessingCommandEnum.None.ToString())
+                                continue;
+
+                            var currentValue = DateTimeUtil.SecondToHHmmss(maintenanceItemEDWaferUserTime.CurrentValue.ToString());
+                            var minValue = DateTimeUtil.SecondToHHmmss(maintenanceItemEDWaferUserTime.StartValue.ToString());
+                            var maxValue = DateTimeUtil.SecondToHHmmss(maintenanceItemEDWaferUserTime.LimitValue.ToString());
+                            var msg = pm.GetAlarmWarningMsg(maintenanceItemEDWaferUserTime, true, currentValue, minValue, maxValue);
+
+                            if (maintenanceItemEDWaferUserTime.MaintenanceProcessing == MaintenanceProcessingCommandEnum.AlarmReport.ToString())
+                            {
+                                Singleton<EquipmentManager>.Instance.EDWaferTypeUseTimeAlarm.Set(msg);
+                                return false;
+                            }
+                            else if (maintenanceItemEDWaferUserTime.MaintenanceProcessing == MaintenanceProcessingCommandEnum.JobAutoStart.ToString())
+                            {
+
+                                if (string.IsNullOrEmpty(maintenanceItemEDWaferUserTime.AssociationProcessRecipeName))
+                                {
+                                    Singleton<EquipmentManager>.Instance.EDWaferTypeUseTimeAlarm.Set(msg);
+                                    return false;
+                                }
+
+                                Singleton<EquipmentManager>.Instance.EDWaferTypeUseTimeAlarm.Set(msg);
+                                pm.TriggerJobAutoStart(maintenanceItemEDWaferUserTime.AssociationProcessRecipeName);
+                                LOG.Info($"{msg} Trigger {maintenanceItemEDWaferUserTime.AssociationProcessRecipeName}");
+                                return false;
+
+                            }
+                        }
+
+                        if (wafer.WaferType == WaferType.ED && maintenanceItemEDWaferThickness.StartValue > 0 && wafer.UseThick >= maintenanceItemEDWaferThickness.LimitValue)
+                        {
+
+                            if (maintenanceItemEDWaferThickness.MaintenanceProcessing == MaintenanceProcessingCommandEnum.None.ToString())
+                                continue;
+
+
+                            if (maintenanceItemEDWaferThickness.MaintenanceProcessing == MaintenanceProcessingCommandEnum.AlarmReport.ToString())
+                            {
+                                var msg = pm.GetAlarmWarningMsg(maintenanceItemEDWaferThickness);
+                                Singleton<EquipmentManager>.Instance.EDWaferTypeThicknessAlarm.Set(msg);
+                                return false;
+                            }
+                            else if (maintenanceItemEDWaferThickness.MaintenanceProcessing == MaintenanceProcessingCommandEnum.JobAutoStart.ToString())
+                            {
+                                var msg = pm.GetAlarmWarningMsg(maintenanceItemEDWaferThickness, true);
+
+                                if (string.IsNullOrEmpty(maintenanceItemEDWaferThickness.AssociationProcessRecipeName))
+                                {
+                                    Singleton<EquipmentManager>.Instance.EDWaferTypeThicknessAlarm.Set(msg);
+                                    return false;
+                                }
+                                Singleton<EquipmentManager>.Instance.EDWaferTypeThicknessAlarm.Set(msg);
+                                pm.TriggerJobAutoStart(maintenanceItemEDWaferThickness.AssociationProcessRecipeName);
+                                LOG.Info($"{msg} Trigger {maintenanceItemEDWaferThickness.AssociationProcessRecipeName}");
+                                return false;
+
+                            }
+                        }
+                        #endregion
+                    }
+                    else
+                    {
+                        // 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"))
+                        {
+                            Singleton<EquipmentManager>.Instance.SDWaferTypeUseCountWarning.Set($"more than {SC.GetValue<int>($"PM1.WaferCycleTime.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"))
+                        {
+                            Singleton<EquipmentManager>.Instance.SDWaferTypeUseTimeWarning.Set($"more than {SC.GetValue<double>($"PM1.WaferCycleTime.SDTimeWarning")} hour");
+                        }
+
+                        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"))
+                        {
+                            Singleton<EquipmentManager>.Instance.SDWaferTypeThicknessWarning.Set($"more than {SC.GetValue<double>($"PM1.WaferCycleTime.SDThicknessWarning")} nm");
+                        }
+
+                        if (wafer.WaferType == WaferType.SD && SC.GetValue<bool>($"PM1.WaferCycleTime.IsEnableSDWaferUseCountWarning") && wafer.UseCount >= SC.GetValue<int>($"PM1.WaferCycleTime.SDCountAlarm"))
+                        {
+                            Singleton<EquipmentManager>.Instance.SDWaferTypeUseCountAlarm.Set($"more than {SC.GetValue<int>($"PM1.WaferCycleTime.SDCountAlarm")} 次");
+
+                            return false;
+                        }
+
+                        if (wafer.WaferType == WaferType.SD && SC.GetValue<bool>($"PM1.WaferCycleTime.IsEnableSDWaferUseTimeWarning") && wafer.UseTime / 3600 >= SC.GetValue<double>($"PM1.WaferCycleTime.SDTimeAlarm"))
+                        {
+                            Singleton<EquipmentManager>.Instance.SDWaferTypeUseTimeAlarm.Set($"more than {SC.GetValue<double>($"PM1.WaferCycleTime.SDTimeAlarm")} hour");
+
+                            return false;
+                        }
+
+                        if (wafer.WaferType == WaferType.SD && SC.GetValue<bool>($"PM1.WaferCycleTime.IsEnableSDWaferThicknessWarning") && wafer.UseThick >= SC.GetValue<double>($"PM1.WaferCycleTime.SDThicknessAlarm"))
+                        {
+                            Singleton<EquipmentManager>.Instance.SDWaferTypeThicknessAlarm.Set($"more than {SC.GetValue<double>($"PM1.WaferCycleTime.SDThicknessAlarm")} nm");
+
+                            return false;
+                        }
+
+                        // 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"))
+                        {
+                            Singleton<EquipmentManager>.Instance.EDWaferTypeUseCountWarning.Set($"more than {SC.GetValue<int>($"PM1.WaferCycleTime.EDCountWarning")} 次");
+                        }
+
+                        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"))
+                        {
+                            Singleton<EquipmentManager>.Instance.EDWaferTypeUseTimeWarning.Set($"more than {SC.GetValue<double>($"PM1.WaferCycleTime.EDTimeWarning")} hour");
+                        }
+
+                        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"))
+                        {
+                            Singleton<EquipmentManager>.Instance.EDWaferTypeThicknessWarning.Set($"more than {SC.GetValue<double>($"PM1.WaferCycleTime.EDThicknessWarning")} nm");
+                        }
+
+                        if (wafer.WaferType == WaferType.ED && SC.GetValue<bool>($"PM1.WaferCycleTime.IsEnableEDWaferUseCountWarning") && wafer.UseCount >= SC.GetValue<int>($"PM1.WaferCycleTime.EDCountAlarm"))
+                        {
+                            Singleton<EquipmentManager>.Instance.EDWaferTypeUseCountAlarm.Set($"more than {SC.GetValue<int>($"PM1.WaferCycleTime.EDCountAlarm")} 次");
+
+                            return false;
+                        }
+
+                        if (wafer.WaferType == WaferType.ED && SC.GetValue<bool>($"PM1.WaferCycleTime.IsEnableEDWaferUseTimeWarning") && wafer.UseTime / 3600 >= SC.GetValue<double>($"PM1.WaferCycleTime.EDTimeAlarm"))
+                        {
+                            Singleton<EquipmentManager>.Instance.EDWaferTypeUseTimeAlarm.Set($"more than {SC.GetValue<double>($"PM1.WaferCycleTime.EDTimeAlarm")} hour");
+
+                            return false;
+                        }
+
+                        if (wafer.WaferType == WaferType.ED && SC.GetValue<bool>($"PM1.WaferCycleTime.IsEnableEDWaferThicknessWarning") && wafer.UseThick >= SC.GetValue<double>($"PM1.WaferCycleTime.EDThicknessAlarm"))
+                        {
+                            Singleton<EquipmentManager>.Instance.EDWaferTypeThicknessAlarm.Set($"more than {SC.GetValue<double>($"PM1.WaferCycleTime.EDThicknessAlarm")} nm");
+
+                            return false;
+                        }
+
+                    }
+                    #endregion
+                }
             }
 
             return true;

Furnace/FurnaceRT/Equipments/PMs/PMMethods.cs

@@ -432,220 +432,27 @@ namespace FurnaceRT.Equipments.PMs
             return result;
         }
 
-        public bool CheckDumyWafer(WaferInfo[] wafers)
+        public void TriggerJobAutoStart(string recipe)
         {
-            var pm = (Singleton<EquipmentManager>.Instance.Modules[ModuleName.PM1] as PMModule);
-            foreach (var wafer in wafers)
-            {
-                if (wafer == null || wafer.IsEmpty || (wafer.WaferType != WaferType.SD && wafer.WaferType != WaferType.ED))
-                    continue;
-                #region New
-                var isScheduleMaintenance = SC.ContainsItem("System.EnableScheduleMaintenance") && SC.GetValue<bool>("System.EnableScheduleMaintenance");
-                if (isScheduleMaintenance)
-                {
-                    #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());
-
-
-
-                    if (wafer.WaferType == WaferType.SD && maintenanceItemSDCarrierUseFreq.StartValue > 0 && wafer.UseCount > maintenanceItemSDCarrierUseFreq.StartValue && wafer.UseCount < maintenanceItemSDCarrierUseFreq.LimitValue)
-                    {
-
-                        pm.MaintenanceProcessingCommandExec(maintenanceItemSDCarrierUseFreq, new AlarmReportItem(Singleton<EquipmentManager>.Instance.SDWaferTypeUseCountWarning.Set, $"more than {maintenanceItemSDCarrierUseFreq.StartValue} 次"));
-
-                    }
-
-                    if (wafer.WaferType == WaferType.SD && maintenanceItemSDWaferUserTime.StartValue > 0 && wafer.UseTime > maintenanceItemSDWaferUserTime.StartValue && wafer.UseTime < maintenanceItemSDWaferUserTime.LimitValue)
-                    {
-                        DateTimeUtil.ConvertSecondsToHoursAndMinutes((int)maintenanceItemSDWaferUserTime.StartValue, out var hours, out var minutes);
-
-                        pm.MaintenanceProcessingCommandExec(maintenanceItemSDWaferUserTime, new AlarmReportItem(Singleton<EquipmentManager>.Instance.SDWaferTypeUseTimeWarning.Set, $"more than {hours} hour {minutes} min"));
-
-                    }
-
-                    if (wafer.WaferType == WaferType.SD && maintenanceItemSDWaferThickness.StartValue > 0 && wafer.UseThick > maintenanceItemSDWaferThickness.StartValue && wafer.UseThick < maintenanceItemSDWaferThickness.LimitValue)
-                    {
-                        pm.MaintenanceProcessingCommandExec(maintenanceItemSDWaferThickness, new AlarmReportItem(Singleton<EquipmentManager>.Instance.SDWaferTypeThicknessWarning.Set, $"more than {maintenanceItemSDWaferThickness.StartValue} nm"));
-
-                    }
-
-                    if (wafer.WaferType == WaferType.SD && maintenanceItemSDCarrierUseFreq.StartValue > 0 && wafer.UseCount >= maintenanceItemSDCarrierUseFreq.LimitValue)
-                    {
-                        if (maintenanceItemSDCarrierUseFreq.MaintenanceProcessing == MaintenanceProcessingCommandEnum.None.ToString())
-                            return true;
-
-                        pm.MaintenanceProcessingCommandExec(maintenanceItemSDCarrierUseFreq, new AlarmReportItem(Singleton<EquipmentManager>.Instance.SDWaferTypeUseCountAlarm.Set, $"more than {maintenanceItemSDCarrierUseFreq.LimitValue} 次"), "", false);
-                        return false;
-                    }
-
-                    if (wafer.WaferType == WaferType.SD && maintenanceItemSDWaferUserTime.StartValue > 0 && wafer.UseTime >= maintenanceItemSDWaferUserTime.LimitValue)
-                    {
-                        if (maintenanceItemSDWaferUserTime.MaintenanceProcessing == MaintenanceProcessingCommandEnum.None.ToString())
-                            return true;
-
-                        DateTimeUtil.ConvertSecondsToHoursAndMinutes((int)maintenanceItemSDWaferUserTime.LimitValue, out var hours, out var minutes);
-                        pm.MaintenanceProcessingCommandExec(maintenanceItemSDWaferUserTime, new AlarmReportItem(Singleton<EquipmentManager>.Instance.SDWaferTypeUseTimeAlarm.Set, $"more than {hours} hour {minutes}"), "", false);
-
-                        return false;
-                    }
-
-                    if (wafer.WaferType == WaferType.SD && maintenanceItemSDWaferThickness.StartValue > 0 && wafer.UseThick >= maintenanceItemSDWaferThickness.LimitValue)
-                    {
-                        if (maintenanceItemSDWaferThickness.MaintenanceProcessing == MaintenanceProcessingCommandEnum.None.ToString())
-                            return true;
-
-                        pm.MaintenanceProcessingCommandExec(maintenanceItemSDWaferThickness, new AlarmReportItem(Singleton<EquipmentManager>.Instance.SDWaferTypeThicknessAlarm.Set, $"more than {maintenanceItemSDWaferThickness.LimitValue} nm"), "", false);
-
-                        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());
-
-
-
-
-                    if (wafer.WaferType == WaferType.ED && maintenanceItemEDCarrierUseFreq.StartValue > 0 && maintenanceItemEDCarrierUseFreq.CurrentValue > maintenanceItemEDCarrierUseFreq.StartValue && wafer.UseCount < maintenanceItemEDCarrierUseFreq.LimitValue)
-                    {
-                        pm.MaintenanceProcessingCommandExec(maintenanceItemEDCarrierUseFreq, new AlarmReportItem(Singleton<EquipmentManager>.Instance.EDWaferTypeUseCountWarning.Set));
-                    }
-
-                    if (wafer.WaferType == WaferType.ED && maintenanceItemEDWaferUserTime.StartValue > 0 && wafer.UseTime > maintenanceItemEDWaferUserTime.StartValue && wafer.UseTime < maintenanceItemEDWaferUserTime.LimitValue)
-                    {
-                        var currentValue = DateTimeUtil.SecondToHHmmss(maintenanceItemEDWaferUserTime.CurrentValue.ToString());
-                        var startValue = DateTimeUtil.SecondToHHmmss(maintenanceItemEDWaferUserTime.StartValue.ToString());
-                        var limitValue = DateTimeUtil.SecondToHHmmss(maintenanceItemEDWaferUserTime.LimitValue.ToString());
-
-
-                        var msg = $"{maintenanceItemEDWaferUserTime.Item}-{maintenanceItemEDWaferUserTime.Display} {maintenanceItemEDWaferUserTime.AdditionInformationDisplay}  {currentValue} limit is ({startValue}~{limitValue}) {maintenanceItemEDWaferUserTime.Unit}";
-                        pm.MaintenanceProcessingCommandExec(maintenanceItemEDWaferUserTime, new AlarmReportItem(Singleton<EquipmentManager>.Instance.EDWaferTypeUseTimeWarning.Set, msg));
-
-
-                    }
-
-                    if (wafer.WaferType == WaferType.ED && maintenanceItemEDWaferThickness.StartValue > 0 && wafer.UseThick > maintenanceItemEDWaferThickness.StartValue && wafer.UseThick < maintenanceItemEDWaferThickness.LimitValue)
-                    {
-                        pm.MaintenanceProcessingCommandExec(maintenanceItemEDWaferThickness, new AlarmReportItem(Singleton<EquipmentManager>.Instance.EDWaferTypeThicknessWarning.Set, $"more than {maintenanceItemEDWaferThickness.StartValue} nm"));
-
-                    }
-
-                    if (wafer.WaferType == WaferType.ED && maintenanceItemEDCarrierUseFreq.StartValue > 0 && wafer.UseCount >= maintenanceItemEDCarrierUseFreq.LimitValue)
-                    {
-                        if (maintenanceItemEDCarrierUseFreq.MaintenanceProcessing == MaintenanceProcessingCommandEnum.None.ToString())
-                            return true;
-
-                        pm.MaintenanceProcessingCommandExec(maintenanceItemEDCarrierUseFreq, new AlarmReportItem(Singleton<EquipmentManager>.Instance.EDWaferTypeUseCountAlarm.Set, $"more than {maintenanceItemEDCarrierUseFreq.LimitValue} 次"), "", false);
-                        return false;
-                    }
-
-                    if (wafer.WaferType == WaferType.ED && maintenanceItemEDWaferUserTime.StartValue > 0 && wafer.UseTime >= maintenanceItemEDWaferUserTime.LimitValue)
-                    {
+            CheckToPostMessage((int)MSG.RunOtherRecipe, recipe, "Process");
 
-                        if (maintenanceItemEDWaferUserTime.MaintenanceProcessing == MaintenanceProcessingCommandEnum.None.ToString())
-                            return true;
-
-                        DateTimeUtil.ConvertSecondsToHoursAndMinutes((int)maintenanceItemEDWaferUserTime.LimitValue, out var hours, out var minutes);
-                        pm.MaintenanceProcessingCommandExec(maintenanceItemEDWaferUserTime, new AlarmReportItem(Singleton<EquipmentManager>.Instance.EDWaferTypeUseTimeAlarm.Set, $"more than {hours} hour {minutes}"), "", false);
-                        return false;
-                    }
-
-                    if (wafer.WaferType == WaferType.ED && maintenanceItemEDWaferThickness.StartValue > 0 && wafer.UseThick >= maintenanceItemEDWaferThickness.LimitValue)
-                    {
-
-                        if (maintenanceItemEDWaferThickness.MaintenanceProcessing == MaintenanceProcessingCommandEnum.None.ToString())
-                            return true;
-
-                        pm.MaintenanceProcessingCommandExec(maintenanceItemEDWaferThickness, new AlarmReportItem(Singleton<EquipmentManager>.Instance.EDWaferTypeThicknessAlarm.Set, $"more than {maintenanceItemEDWaferThickness.LimitValue} nm"), "", false);
-                        return false;
-                    }
-                    #endregion
-                }
-                else
-                {
-                    // 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"))
-                    {
-                        Singleton<EquipmentManager>.Instance.SDWaferTypeUseCountWarning.Set($"more than {SC.GetValue<int>($"PM1.WaferCycleTime.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"))
-                    {
-                        Singleton<EquipmentManager>.Instance.SDWaferTypeUseTimeWarning.Set($"more than {SC.GetValue<double>($"PM1.WaferCycleTime.SDTimeWarning")} hour");
-                    }
-
-                    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"))
-                    {
-                        Singleton<EquipmentManager>.Instance.SDWaferTypeThicknessWarning.Set($"more than {SC.GetValue<double>($"PM1.WaferCycleTime.SDThicknessWarning")} nm");
-                    }
-
-                    if (wafer.WaferType == WaferType.SD && SC.GetValue<bool>($"PM1.WaferCycleTime.IsEnableSDWaferUseCountWarning") && wafer.UseCount >= SC.GetValue<int>($"PM1.WaferCycleTime.SDCountAlarm"))
-                    {
-                        Singleton<EquipmentManager>.Instance.SDWaferTypeUseCountAlarm.Set($"more than {SC.GetValue<int>($"PM1.WaferCycleTime.SDCountAlarm")} 次");
-
-                        return false;
-                    }
-
-                    if (wafer.WaferType == WaferType.SD && SC.GetValue<bool>($"PM1.WaferCycleTime.IsEnableSDWaferUseTimeWarning") && wafer.UseTime / 3600 >= SC.GetValue<double>($"PM1.WaferCycleTime.SDTimeAlarm"))
-                    {
-                        Singleton<EquipmentManager>.Instance.SDWaferTypeUseTimeAlarm.Set($"more than {SC.GetValue<double>($"PM1.WaferCycleTime.SDTimeAlarm")} hour");
-
-                        return false;
-                    }
-
-                    if (wafer.WaferType == WaferType.SD && SC.GetValue<bool>($"PM1.WaferCycleTime.IsEnableSDWaferThicknessWarning") && wafer.UseThick >= SC.GetValue<double>($"PM1.WaferCycleTime.SDThicknessAlarm"))
-                    {
-                        Singleton<EquipmentManager>.Instance.SDWaferTypeThicknessAlarm.Set($"more than {SC.GetValue<double>($"PM1.WaferCycleTime.SDThicknessAlarm")} nm");
-
-                        return false;
-                    }
-
-                    // 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"))
-                    {
-                        Singleton<EquipmentManager>.Instance.EDWaferTypeUseCountWarning.Set($"more than {SC.GetValue<int>($"PM1.WaferCycleTime.EDCountWarning")} 次");
-                    }
-
-                    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"))
-                    {
-                        Singleton<EquipmentManager>.Instance.EDWaferTypeUseTimeWarning.Set($"more than {SC.GetValue<double>($"PM1.WaferCycleTime.EDTimeWarning")} hour");
-                    }
-
-                    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"))
-                    {
-                        Singleton<EquipmentManager>.Instance.EDWaferTypeThicknessWarning.Set($"more than {SC.GetValue<double>($"PM1.WaferCycleTime.EDThicknessWarning")} nm");
-                    }
-
-                    if (wafer.WaferType == WaferType.ED && SC.GetValue<bool>($"PM1.WaferCycleTime.IsEnableEDWaferUseCountWarning") && wafer.UseCount >= SC.GetValue<int>($"PM1.WaferCycleTime.EDCountAlarm"))
-                    {
-                        Singleton<EquipmentManager>.Instance.EDWaferTypeUseCountAlarm.Set($"more than {SC.GetValue<int>($"PM1.WaferCycleTime.EDCountAlarm")} 次");
-
-                        return false;
-                    }
-
-                    if (wafer.WaferType == WaferType.ED && SC.GetValue<bool>($"PM1.WaferCycleTime.IsEnableEDWaferUseTimeWarning") && wafer.UseTime / 3600 >= SC.GetValue<double>($"PM1.WaferCycleTime.EDTimeAlarm"))
-                    {
-                        Singleton<EquipmentManager>.Instance.EDWaferTypeUseTimeAlarm.Set($"more than {SC.GetValue<double>($"PM1.WaferCycleTime.EDTimeAlarm")} hour");
-
-                        return false;
-                    }
+        }
+        public string GetAlarmWarningMsg(ScheduleMaintenanceDataItem item, bool isJobAutoStart = false, string currentValue = "", string minValue = "", string maxValue = "")
+        {
+            string nullMessage = $"{item.Display} No recipe file associated, unable to trigger JobAutoStart";
 
-                    if (wafer.WaferType == WaferType.ED && SC.GetValue<bool>($"PM1.WaferCycleTime.IsEnableEDWaferThicknessWarning") && wafer.UseThick >= SC.GetValue<double>($"PM1.WaferCycleTime.EDThicknessAlarm"))
-                    {
-                        Singleton<EquipmentManager>.Instance.EDWaferTypeThicknessAlarm.Set($"more than {SC.GetValue<double>($"PM1.WaferCycleTime.EDThicknessAlarm")} nm");
+            if (!string.IsNullOrEmpty(minValue) && !string.IsNullOrEmpty(maxValue)&&!string.IsNullOrEmpty(currentValue))
+            {
+                return $"{item.Item}-{item.Display} {item.AdditionInformationDisplay}  {currentValue} limit is ({minValue}~{maxValue}) {item.Unit}"; ;
 
-                        return false;
-                    }
+            }
 
-                }
-                #endregion
+            if (isJobAutoStart && string.IsNullOrEmpty(item.AssociationProcessRecipeName))
+            {
+                return nullMessage;
             }
-            return true;
+            return $"{item.Item}-{item.Display} {item.AdditionInformationDisplay}  {item.CurrentValue} limit is ({item.StartValue}~{item.LimitValue}) {item.Unit}"; ;
+
         }
     }
 

Furnace/FurnaceRT/Equipments/PMs/PMScheduleMaintenance.cs

@@ -119,44 +119,9 @@ namespace FurnaceRT.Equipments.PMs
 
 
         }
-
-        public void MaintenanceProcessingCommandExec(ScheduleMaintenanceDataItem item, AlarmReportItem alarmReportItem, string msg = "", bool isWarning = true)
-        {
-            string message = !string.IsNullOrEmpty(msg) ? msg : $"{item.Item}-{item.Display} {item.AdditionInformationDisplay}  {item.CurrentValue} limit is ({item.StartValue}~{item.LimitValue}) {item.Unit}";
-            string nullMessage = $"{item.Display} No recipe file associated, unable to trigger JobAutoStart";
-
-            if (Enum.TryParse<MaintenanceProcessingCommandEnum>(item.MaintenanceProcessing, out var command))
-            {
-                switch (command)
-                {
-                    case MaintenanceProcessingCommandEnum.None:
-                        break;
-                    case MaintenanceProcessingCommandEnum.AlarmReport:
-                        alarmReportItem?.Exec(message);
-                        break;
-
-                    case MaintenanceProcessingCommandEnum.JobAutoStart:
-                        if (isWarning)
-                        {
-                            return;
-                        }
-                        if (string.IsNullOrEmpty(item.AssociationProcessRecipeName))
-                        {
-                            Singleton<EquipmentManager>.Instance.RecipeThicknessAlarm.Set(nullMessage);
-                        }
-                        else
-                        {
-                            LOG.Info($"{message} Trigger {item.AssociationProcessRecipeName}");
-                            CheckToPostMessage((int)MSG.RunOtherRecipe, item.AssociationProcessRecipeName, "Process");
-                        }
-                        break;
-
-                }
-            }
-        }
-
         #region Carrier/Wafer
 
+      
         public void UpdateSEDWafer(List<WaferInfo> waferInfos)
         {
             if (waferInfos == null)
@@ -491,7 +456,7 @@ namespace FurnaceRT.Equipments.PMs
             string message = $"{item.Item}-{item.Display} {item.AdditionInformationDisplay}  {item.CurrentValue} limit is ({item.StartValue}~{item.LimitValue}) times";
 
 
-            bool isWarning = item.CurrentValue >= item.StartValue && item.CurrentValue < item.LimitValue;
+            bool isWarning = item.CurrentValue > item.StartValue && item.CurrentValue < item.LimitValue;
             bool isAlarm = item.CurrentValue >= item.LimitValue;
             if (isWarning)
             {
@@ -499,7 +464,7 @@ namespace FurnaceRT.Equipments.PMs
             }
             if (isAlarm)
             {
-                Singleton<EquipmentManager>.Instance.RecipeExecuteFreqWarning.Set(message);
+                Singleton<EquipmentManager>.Instance.RecipeExecuteFreqAlarm.Set(message);
                 if (command == MaintenanceProcessingCommandEnum.JobAutoStart)
                 {
                     if (string.IsNullOrEmpty(item.AssociationProcessRecipeName))

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

@@ -8,6 +8,11 @@ using FurnaceRT.Equipments.Systems;
 using Aitex.Core.Util;
 using MECF.Framework.Common.SubstrateTrackings;
 using System.Linq;
+using Aitex.Core.Common;
+using MECF.Framework.Common.CommonData.EnumData;
+using MECF.Framework.Common.DataCenter;
+using MECF.Framework.Common.Utilities;
+using Aitex.Core.RT.Log;
 
 namespace FurnaceRT.Equipments.PMs.RecipeExecutions
 {
@@ -50,8 +55,8 @@ namespace FurnaceRT.Equipments.PMs.RecipeExecutions
             if (_isProcessRecipe)
             {
 
-                
-            
+
+
 
                 if (!RecipeParser.Parse(_recipeName, Module, out recipeHead, out recipeSteps, out reason, "Process"))
                 {
@@ -61,8 +66,6 @@ namespace FurnaceRT.Equipments.PMs.RecipeExecutions
 
                 #region MyRegion
 
-            
-
                 var isScheduleMaintenance = SC.ContainsItem("System.EnableScheduleMaintenance") && SC.GetValue<bool>("System.EnableScheduleMaintenance");
                 if (isScheduleMaintenance)
                 {
@@ -74,10 +77,281 @@ namespace FurnaceRT.Equipments.PMs.RecipeExecutions
                     var wafers = WaferManager.Instance.GetWafers(ModuleName.PM1);
                     if (wafers != null && wafers.Count() > 0)
                     {
-                        if (!pm.CheckDumyWafer(wafers))
+                        foreach (var wafer in wafers)
                         {
-                            return Result.FAIL;
-                        };
+                            if (wafer == null || wafer.IsEmpty || (wafer.WaferType != WaferType.SD && wafer.WaferType != WaferType.ED))
+                                continue;
+
+                            #region New
+                            if (isScheduleMaintenance)
+                            {
+                                #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());
+
+
+
+                                if (wafer.WaferType == WaferType.SD && maintenanceItemSDCarrierUseFreq.StartValue > 0 && wafer.UseCount > maintenanceItemSDCarrierUseFreq.StartValue && wafer.UseCount < maintenanceItemSDCarrierUseFreq.LimitValue)
+                                {
+                                    if (maintenanceItemSDCarrierUseFreq.MaintenanceProcessing == MaintenanceProcessingCommandEnum.AlarmReport.ToString())
+                                    {
+                                        var msg = pm.GetAlarmWarningMsg(maintenanceItemSDCarrierUseFreq);
+                                        Singleton<EquipmentManager>.Instance.SDWaferTypeUseCountWarning.Set(msg);
+                                    }
+                                }
+
+                                if (wafer.WaferType == WaferType.SD && maintenanceItemSDWaferUserTime.StartValue > 0 && wafer.UseTime > maintenanceItemSDWaferUserTime.StartValue && wafer.UseTime < maintenanceItemSDWaferUserTime.LimitValue)
+                                {
+
+                                    if (maintenanceItemSDWaferUserTime.MaintenanceProcessing == MaintenanceProcessingCommandEnum.AlarmReport.ToString())
+                                    {
+                                        var currentValue = DateTimeUtil.SecondToHHmmss(maintenanceItemSDWaferUserTime.CurrentValue.ToString());
+                                        var minValue = DateTimeUtil.SecondToHHmmss(maintenanceItemSDWaferUserTime.StartValue.ToString());
+                                        var maxValue = DateTimeUtil.SecondToHHmmss(maintenanceItemSDWaferUserTime.LimitValue.ToString());
+                                        var msg = pm.GetAlarmWarningMsg(maintenanceItemSDWaferUserTime, true, currentValue, minValue, maxValue);
+                                        Singleton<EquipmentManager>.Instance.SDWaferTypeUseTimeWarning.Set(msg);
+                                    }
+                                }
+
+                                if (wafer.WaferType == WaferType.SD && maintenanceItemSDWaferThickness.StartValue > 0 && wafer.UseThick > maintenanceItemSDWaferThickness.StartValue && wafer.UseThick < maintenanceItemSDWaferThickness.LimitValue)
+                                {
+                                    if (maintenanceItemSDWaferThickness.MaintenanceProcessing == MaintenanceProcessingCommandEnum.AlarmReport.ToString())
+                                    {
+                                        var msg = pm.GetAlarmWarningMsg(maintenanceItemSDWaferThickness);
+                                        Singleton<EquipmentManager>.Instance.SDWaferTypeThicknessWarning.Set(msg);
+                                    }
+                                }
+
+                                if (wafer.WaferType == WaferType.SD && maintenanceItemSDCarrierUseFreq.StartValue > 0 && wafer.UseCount >= maintenanceItemSDCarrierUseFreq.LimitValue)
+                                {
+                                    if (maintenanceItemSDCarrierUseFreq.MaintenanceProcessing == MaintenanceProcessingCommandEnum.None.ToString())
+                                        continue;
+
+                                    if (maintenanceItemSDCarrierUseFreq.MaintenanceProcessing == MaintenanceProcessingCommandEnum.AlarmReport.ToString())
+                                    {
+                                        var msg = pm.GetAlarmWarningMsg(maintenanceItemSDCarrierUseFreq);
+                                        Singleton<EquipmentManager>.Instance.SDWaferTypeUseCountAlarm.Set(msg);
+                                           return Result.FAIL;
+                                    }
+                                    else if (maintenanceItemSDCarrierUseFreq.MaintenanceProcessing == MaintenanceProcessingCommandEnum.JobAutoStart.ToString())
+                                    {
+                                        var msg = pm.GetAlarmWarningMsg(maintenanceItemSDCarrierUseFreq, true);
+
+                                        if (string.IsNullOrEmpty(maintenanceItemSDCarrierUseFreq.AssociationProcessRecipeName))
+                                        {
+                                            Singleton<EquipmentManager>.Instance.SDWaferTypeUseCountAlarm.Set(msg);
+                                               return Result.FAIL;
+                                        }
+
+
+                                        Singleton<EquipmentManager>.Instance.SDWaferTypeUseCountAlarm.Set(msg);
+                                        pm.TriggerJobAutoStart(maintenanceItemSDCarrierUseFreq.AssociationProcessRecipeName);
+                                        LOG.Info($"{msg} Trigger {maintenanceItemSDCarrierUseFreq.AssociationProcessRecipeName}");
+                                           return Result.FAIL;
+
+                                    }
+                                }
+
+                                if (wafer.WaferType == WaferType.SD && maintenanceItemSDWaferUserTime.StartValue > 0 && wafer.UseTime >= maintenanceItemSDWaferUserTime.LimitValue)
+                                {
+                                    if (maintenanceItemSDWaferUserTime.MaintenanceProcessing == MaintenanceProcessingCommandEnum.None.ToString())
+                                        continue;
+
+
+                                    var currentValue = DateTimeUtil.SecondToHHmmss(maintenanceItemSDWaferUserTime.CurrentValue.ToString());
+                                    var minValue = DateTimeUtil.SecondToHHmmss(maintenanceItemSDWaferUserTime.StartValue.ToString());
+                                    var maxValue = DateTimeUtil.SecondToHHmmss(maintenanceItemSDWaferUserTime.LimitValue.ToString());
+                                    var msg = pm.GetAlarmWarningMsg(maintenanceItemSDWaferUserTime, true, currentValue, minValue, maxValue);
+
+                                    if (maintenanceItemSDWaferUserTime.MaintenanceProcessing == MaintenanceProcessingCommandEnum.AlarmReport.ToString())
+                                    {
+                                        Singleton<EquipmentManager>.Instance.SDWaferTypeUseTimeAlarm.Set(msg);
+                                           return Result.FAIL;
+                                    }
+                                    else if (maintenanceItemSDWaferUserTime.MaintenanceProcessing == MaintenanceProcessingCommandEnum.JobAutoStart.ToString())
+                                    {
+
+                                        if (string.IsNullOrEmpty(maintenanceItemSDWaferUserTime.AssociationProcessRecipeName))
+                                        {
+                                            Singleton<EquipmentManager>.Instance.SDWaferTypeUseTimeAlarm.Set(msg);
+                                               return Result.FAIL;
+                                        }
+
+                                        Singleton<EquipmentManager>.Instance.SDWaferTypeUseTimeAlarm.Set(msg);
+                                        pm.TriggerJobAutoStart(maintenanceItemSDWaferUserTime.AssociationProcessRecipeName);
+                                        LOG.Info($"{msg} Trigger {maintenanceItemSDWaferUserTime.AssociationProcessRecipeName}");
+                                           return Result.FAIL;
+
+                                    }
+
+                                }
+
+                                if (wafer.WaferType == WaferType.SD && maintenanceItemSDWaferThickness.StartValue > 0 && wafer.UseThick >= maintenanceItemSDWaferThickness.LimitValue)
+                                {
+                                    if (maintenanceItemSDWaferThickness.MaintenanceProcessing == MaintenanceProcessingCommandEnum.None.ToString())
+                                        continue;
+
+                                    if (maintenanceItemSDWaferThickness.MaintenanceProcessing == MaintenanceProcessingCommandEnum.AlarmReport.ToString())
+                                    {
+                                        var msg = pm.GetAlarmWarningMsg(maintenanceItemSDWaferThickness);
+                                        Singleton<EquipmentManager>.Instance.SDWaferTypeThicknessAlarm.Set(msg);
+                                           return Result.FAIL;
+                                    }
+                                    else if (maintenanceItemSDWaferThickness.MaintenanceProcessing == MaintenanceProcessingCommandEnum.JobAutoStart.ToString())
+                                    {
+                                        var msg = pm.GetAlarmWarningMsg(maintenanceItemSDWaferThickness, true);
+
+                                        if (string.IsNullOrEmpty(maintenanceItemSDWaferThickness.AssociationProcessRecipeName))
+                                        {
+                                            Singleton<EquipmentManager>.Instance.SDWaferTypeThicknessAlarm.Set(msg);
+                                               return Result.FAIL;
+                                        }
+
+
+                                        Singleton<EquipmentManager>.Instance.SDWaferTypeThicknessAlarm.Set(msg);
+                                        pm.TriggerJobAutoStart(maintenanceItemSDWaferThickness.AssociationProcessRecipeName);
+                                        LOG.Info($"{msg} Trigger {maintenanceItemSDWaferThickness.AssociationProcessRecipeName}");
+                                           return Result.FAIL;
+
+                                    }
+                                }
+                                #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());
+
+                                if (wafer.WaferType == WaferType.ED && maintenanceItemEDCarrierUseFreq.StartValue > 0 && maintenanceItemEDCarrierUseFreq.CurrentValue > maintenanceItemEDCarrierUseFreq.StartValue && wafer.UseCount < maintenanceItemEDCarrierUseFreq.LimitValue)
+                                {
+                                    if (maintenanceItemEDCarrierUseFreq.MaintenanceProcessing == MaintenanceProcessingCommandEnum.AlarmReport.ToString())
+                                    {
+                                        var msg = pm.GetAlarmWarningMsg(maintenanceItemEDCarrierUseFreq);
+                                        Singleton<EquipmentManager>.Instance.EDWaferTypeUseCountWarning.Set(msg);
+                                    }
+                                }
+
+                                if (wafer.WaferType == WaferType.ED && maintenanceItemEDWaferUserTime.StartValue > 0 && wafer.UseTime > maintenanceItemEDWaferUserTime.StartValue && wafer.UseTime < maintenanceItemEDWaferUserTime.LimitValue)
+                                {
+
+                                    if (maintenanceItemEDWaferUserTime.MaintenanceProcessing == MaintenanceProcessingCommandEnum.AlarmReport.ToString())
+                                    {
+                                        var currentValue = DateTimeUtil.SecondToHHmmss(maintenanceItemEDWaferUserTime.CurrentValue.ToString());
+                                        var minValue = DateTimeUtil.SecondToHHmmss(maintenanceItemEDWaferUserTime.StartValue.ToString());
+                                        var maxValue = DateTimeUtil.SecondToHHmmss(maintenanceItemEDWaferUserTime.LimitValue.ToString());
+                                        var msg = pm.GetAlarmWarningMsg(maintenanceItemEDWaferUserTime, true, currentValue, minValue, maxValue);
+
+                                        Singleton<EquipmentManager>.Instance.EDWaferTypeUseTimeWarning.Set(msg);
+                                    }
+
+                                }
+
+                                if (wafer.WaferType == WaferType.ED && maintenanceItemEDWaferThickness.StartValue > 0 && wafer.UseThick > maintenanceItemEDWaferThickness.StartValue && wafer.UseThick < maintenanceItemEDWaferThickness.LimitValue)
+                                {
+                                    if (maintenanceItemEDWaferThickness.MaintenanceProcessing == MaintenanceProcessingCommandEnum.AlarmReport.ToString())
+                                    {
+                                        var msg = pm.GetAlarmWarningMsg(maintenanceItemEDWaferThickness);
+                                        Singleton<EquipmentManager>.Instance.EDWaferTypeThicknessWarning.Set(msg);
+                                    }
+                                }
+
+                                if (wafer.WaferType == WaferType.ED && maintenanceItemEDCarrierUseFreq.StartValue > 0 && wafer.UseCount >= maintenanceItemEDCarrierUseFreq.LimitValue)
+                                {
+
+                                    if (maintenanceItemEDCarrierUseFreq.MaintenanceProcessing == MaintenanceProcessingCommandEnum.None.ToString())
+                                        continue;
+
+                                    if (maintenanceItemEDCarrierUseFreq.MaintenanceProcessing == MaintenanceProcessingCommandEnum.AlarmReport.ToString())
+                                    {
+                                        var msg = pm.GetAlarmWarningMsg(maintenanceItemEDCarrierUseFreq);
+                                        Singleton<EquipmentManager>.Instance.EDWaferTypeUseCountAlarm.Set(msg);
+                                           return Result.FAIL;
+                                    }
+                                    else if (maintenanceItemEDCarrierUseFreq.MaintenanceProcessing == MaintenanceProcessingCommandEnum.JobAutoStart.ToString())
+                                    {
+                                        var msg = pm.GetAlarmWarningMsg(maintenanceItemEDCarrierUseFreq);
+
+                                        if (string.IsNullOrEmpty(maintenanceItemEDCarrierUseFreq.AssociationProcessRecipeName))
+                                        {
+                                            Singleton<EquipmentManager>.Instance.EDWaferTypeUseCountAlarm.Set(msg);
+                                               return Result.FAIL;
+                                        }
+                                        Singleton<EquipmentManager>.Instance.EDWaferTypeUseCountAlarm.Set(msg);
+                                        pm.TriggerJobAutoStart(maintenanceItemEDCarrierUseFreq.AssociationProcessRecipeName);
+                                        LOG.Info($"{msg} Trigger {maintenanceItemEDCarrierUseFreq.AssociationProcessRecipeName}");
+                                           return Result.FAIL;
+
+                                    }
+                                }
+
+                                if (wafer.WaferType == WaferType.ED && maintenanceItemEDWaferUserTime.StartValue > 0 && wafer.UseTime >= maintenanceItemEDWaferUserTime.LimitValue)
+                                {
+                                    if (maintenanceItemEDWaferUserTime.MaintenanceProcessing == MaintenanceProcessingCommandEnum.None.ToString())
+                                        continue;
+
+                                    var currentValue = DateTimeUtil.SecondToHHmmss(maintenanceItemEDWaferUserTime.CurrentValue.ToString());
+                                    var minValue = DateTimeUtil.SecondToHHmmss(maintenanceItemEDWaferUserTime.StartValue.ToString());
+                                    var maxValue = DateTimeUtil.SecondToHHmmss(maintenanceItemEDWaferUserTime.LimitValue.ToString());
+                                    var msg = pm.GetAlarmWarningMsg(maintenanceItemEDWaferUserTime, true, currentValue, minValue, maxValue);
+
+                                    if (maintenanceItemEDWaferUserTime.MaintenanceProcessing == MaintenanceProcessingCommandEnum.AlarmReport.ToString())
+                                    {
+                                        Singleton<EquipmentManager>.Instance.EDWaferTypeUseTimeAlarm.Set(msg);
+                                           return Result.FAIL;
+                                    }
+                                    else if (maintenanceItemEDWaferUserTime.MaintenanceProcessing == MaintenanceProcessingCommandEnum.JobAutoStart.ToString())
+                                    {
+
+                                        if (string.IsNullOrEmpty(maintenanceItemEDWaferUserTime.AssociationProcessRecipeName))
+                                        {
+                                            Singleton<EquipmentManager>.Instance.EDWaferTypeUseTimeAlarm.Set(msg);
+                                               return Result.FAIL;
+                                        }
+
+                                        Singleton<EquipmentManager>.Instance.EDWaferTypeUseTimeAlarm.Set(msg);
+                                        pm.TriggerJobAutoStart(maintenanceItemEDWaferUserTime.AssociationProcessRecipeName);
+                                        LOG.Info($"{msg} Trigger {maintenanceItemEDWaferUserTime.AssociationProcessRecipeName}");
+                                           return Result.FAIL;
+
+                                    }
+                                }
+
+                                if (wafer.WaferType == WaferType.ED && maintenanceItemEDWaferThickness.StartValue > 0 && wafer.UseThick >= maintenanceItemEDWaferThickness.LimitValue)
+                                {
+
+                                    if (maintenanceItemEDWaferThickness.MaintenanceProcessing == MaintenanceProcessingCommandEnum.None.ToString())
+                                        continue;
+
+
+                                    if (maintenanceItemEDWaferThickness.MaintenanceProcessing == MaintenanceProcessingCommandEnum.AlarmReport.ToString())
+                                    {
+                                        var msg = pm.GetAlarmWarningMsg(maintenanceItemEDWaferThickness);
+                                        Singleton<EquipmentManager>.Instance.EDWaferTypeThicknessAlarm.Set(msg);
+                                           return Result.FAIL;
+                                    }
+                                    else if (maintenanceItemEDWaferThickness.MaintenanceProcessing == MaintenanceProcessingCommandEnum.JobAutoStart.ToString())
+                                    {
+                                        var msg = pm.GetAlarmWarningMsg(maintenanceItemEDWaferThickness, true);
+
+                                        if (string.IsNullOrEmpty(maintenanceItemEDWaferThickness.AssociationProcessRecipeName))
+                                        {
+                                            Singleton<EquipmentManager>.Instance.EDWaferTypeThicknessAlarm.Set(msg);
+                                            return Result.FAIL;
+                                        }
+                                        Singleton<EquipmentManager>.Instance.EDWaferTypeThicknessAlarm.Set(msg);
+                                        pm.TriggerJobAutoStart(maintenanceItemEDWaferThickness.AssociationProcessRecipeName);
+                                        LOG.Info($"{msg} Trigger {maintenanceItemEDWaferThickness.AssociationProcessRecipeName}");
+                                        return Result.FAIL;
+
+                                    }
+                                }
+                                #endregion
+
+                            }
+                            #endregion
+                        }
                     }