update ui log

CyberX8_RT/Config/System.sccfg

@@ -21,6 +21,8 @@
 		</configs>
 		<config default="EFEM,PUF1,PUF2,Loader1,Transporter2,Transporter1,Prewet" name="InitializeCheckModuleList" nameView="InitializeCheckModuleList" description="Initialize检验模块集合" max="" min="" paramter="" tag="" unit="" type="String"/>
 		<config default="SN 03.Cyber101" name="ToolID" nameView="ToolID" description="Tool ID" tag="" unit="" type="String" />
+		<config default="0" name="LogsSaveDays" description="max days of log file,zero is not to delete log file" max="365" min="0" paramter="" tag="" unit="" type="Integer" />
+		<config default="True" name="IsEnableCompressLogFile" nameView="IsEnableCompressLogFile" description="is enable to compress log files" max="" min="" paramter="" tag="" unit="" type="Bool" visible="false"/>
 	</configs>
 	<configs name="Twincat" nameView="Twincat">
 		<config default="false" name="EnableReadLog" nameView="Enalbe Twincat Variable Read log" description="是否启用Twincat变量读取日志" max="" min="" paramter="" tag="" unit="" type="Bool" />

CyberX8_RT/Instances/ToolLoader.cs

@@ -53,8 +53,6 @@ namespace CyberX8_RT.Instances
         {
             LogDefineManager.Initialize(PathManager.GetCfgDir() + "LogDefine.json");
 
-            Singleton<LogManager>.Instance.Initialize();
-
             WcfServiceManager.Instance.Initialize(new Type[]
             {
                typeof (RecipeService),typeof (QueryDataService),typeof(WaferHolderDataService)
@@ -75,6 +73,7 @@ namespace CyberX8_RT.Instances
             Singleton<DataManager>.Instance.Initialize();
 
             Singleton<SystemConfigManager>.Instance.Initialize(PathManager.GetCfgDir() + "System.sccfg");
+            Singleton<LogManager>.Instance.Initialize();
 
 
             AccountExManager.Instance.Initialize(true);

CyberX8_RT/Modules/RouteManager.cs

@@ -968,8 +968,38 @@ namespace CyberX8_RT.Modules
 
         private bool FsmStartJob(object[] objs)
         {
+            bool result = CheckPMCounter();
+            if (!result)
+            {
+                return false;
+            }
             return _jobCycle.StartJob((string)objs[0],out string reason);
         }
+        /// <summary>
+        /// 检查PM counter
+        /// </summary>
+        /// <returns></returns>
+        private bool CheckPMCounter()
+        {
+            bool result = false;
+            foreach (string item in ReservoirItemManager.Instance.InstalledModules)
+            {
+                result = ReservoirUsageMonitor(item);
+                if (!result)
+                {
+                    return false;
+                }
+            }
+            foreach (string item in MetalItemManager.Instance.InstalledModules)
+            {
+                result = MetalUsageMointor(item);
+                if (!result)
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
         private bool FsmPauseJob(object[] objs)
         {
             return _jobCycle.PauseJob((string)objs[0],out string reason);
@@ -1068,6 +1098,303 @@ namespace CyberX8_RT.Modules
         public List<IModuleEntity> GetModulesByModuleType(ModuleType type)
         {
             return _modultTypeEntitiesDic.ContainsKey(type) ? _modultTypeEntitiesDic[type] : new List<IModuleEntity>();
-        } 
+        }
+
+        /// <summary>
+        /// 监控PM Counter Reservoir Usage
+        /// </summary>
+        public bool ReservoirUsageMonitor(string Module)
+        {
+            ReservoirUsage reservoirUsage = ReservoirUsageManager.Instance.GetReservoirUsage(Module);
+            ReservoirEntity reservoirEntity = Singleton<RouteManager>.Instance.GetModule<ReservoirEntity>(Module);
+            if (reservoirUsage == null || reservoirEntity == null) return true;
+            //reservoirTotalAmpHours Check
+            double reservoirTotalAmpHoursWarningLimit = 0;
+            if (SC.ContainsItem($"Reservoir.{Module}.ReservoirTotalAmpHoursWarningLimit"))
+            {
+                reservoirTotalAmpHoursWarningLimit = (double)SC.GetValue<double>($"Reservoir.{Module}.ReservoirTotalAmpHoursWarningLimit");
+            }
+            double reservoirTotalAmpHoursFaultLimit = 0;
+            if (SC.ContainsItem($"Reservoir.{Module}.ReservoirTotalAmpHoursFaultLimit"))
+            {
+                reservoirTotalAmpHoursFaultLimit = (double)SC.GetValue<double>($"Reservoir.{Module}.ReservoirTotalAmpHoursFaultLimit");
+            }
+            if (reservoirUsage.TotalUsage > reservoirTotalAmpHoursFaultLimit && reservoirTotalAmpHoursFaultLimit != 0)
+            {
+                LOG.WriteLog(eEvent.ERR_RESERVOIR, Module, $"{Module} Total Usage(AHr):{reservoirUsage.TotalUsage} is over config item ReservoirTotalAmpHoursFaultLimit:{reservoirTotalAmpHoursFaultLimit}");
+                return false;
+            }
+            else if (reservoirUsage.TotalUsage > reservoirTotalAmpHoursWarningLimit && reservoirTotalAmpHoursWarningLimit != 0)
+            {
+                LOG.WriteLog(eEvent.WARN_RESERVOIR, Module, $"{Module} Total Usage(AHr):{reservoirUsage.TotalUsage} is over config item ReservoirTotalAmpHoursWarningLimit:{reservoirTotalAmpHoursWarningLimit}");
+            }
+            //MembraneTotalAmpHoursCheck
+            double membraneTotalAmpHoursWarningLimit = 0;
+            if (SC.ContainsItem($"Reservoir.{Module}.MembraneTotalAmpHoursWarningLimit"))
+            {
+                membraneTotalAmpHoursWarningLimit = (double)SC.GetValue<double>($"Reservoir.{Module}.MembraneTotalAmpHoursWarningLimit");
+            }
+            double membraneTotalAmpHoursFaultLimit = 0;
+            if (SC.ContainsItem($"Reservoir.{Module}.MembraneTotalAmpHoursFaultLimit"))
+            {
+                membraneTotalAmpHoursFaultLimit = (double)SC.GetValue<double>($"Reservoir.{Module}.MembraneTotalAmpHoursFaultLimit");
+            }
+            if (reservoirUsage.MembranceUsage > membraneTotalAmpHoursFaultLimit && membraneTotalAmpHoursFaultLimit != 0)
+            {
+                LOG.WriteLog(eEvent.ERR_RESERVOIR, Module, $"{Module} Membrane Usage(AHr):{reservoirUsage.MembranceUsage} is over config item MembraneTotalAmpHoursFaultLimit:{membraneTotalAmpHoursFaultLimit}");
+                return false;
+            }
+            else if (reservoirUsage.MembranceUsage > membraneTotalAmpHoursWarningLimit && membraneTotalAmpHoursWarningLimit != 0)
+            {
+                LOG.WriteLog(eEvent.WARN_RESERVOIR, Module, $"{Module} Membrane Usage(AHr):{reservoirUsage.MembranceUsage} is over config item MembraneTotalAmpHoursWarningLimit:{membraneTotalAmpHoursWarningLimit}");
+            }
+            double bathTotalAmpHoursWarningLimit = 0;
+            if (SC.ContainsItem($"Reservoir.{Module}.BathTotalAmpHoursWarningLimit"))
+            {
+                bathTotalAmpHoursWarningLimit = (double)SC.GetValue<double>($"Reservoir.{Module}.BathTotalAmpHoursWarningLimit");
+            }
+            double bathTotalAmpHoursFaultLimit = 0;
+            if (SC.ContainsItem($"Reservoir.{Module}.BathTotalAmpHoursFaultLimit"))
+            {
+                bathTotalAmpHoursFaultLimit = (double)SC.GetValue<double>($"Reservoir.{Module}.BathTotalAmpHoursFaultLimit");
+            }
+            if (reservoirUsage.BathUsage > bathTotalAmpHoursFaultLimit && bathTotalAmpHoursFaultLimit != 0)
+            {
+                LOG.WriteLog(eEvent.ERR_RESERVOIR, Module, $"{Module} Bath Usage(AHr):{reservoirUsage.BathUsage} is over config item BathTotalAmpHoursFaultLimit:{bathTotalAmpHoursFaultLimit}");
+                return false;
+            }
+            else if (reservoirUsage.BathUsage > bathTotalAmpHoursWarningLimit && bathTotalAmpHoursWarningLimit != 0)
+            {
+                LOG.WriteLog(eEvent.WARN_RESERVOIR, Module, $"{Module} Bath Usage(AHr):{reservoirUsage.BathUsage} is over config item BathTotalAmpHoursWarningLimit:{bathTotalAmpHoursWarningLimit}");
+            }
+            //BathTotalDaysCheck
+            int bathTotalDaysWarningLimit = 0;
+            if (SC.ContainsItem($"Reservoir.{Module}.BathTotalDaysWarningLimit"))
+            {
+                bathTotalDaysWarningLimit = SC.GetValue<int>($"Reservoir.{Module}.BathTotalDaysWarningLimit");
+            }
+            int bathTotalDaysFaultLimit = 0;
+            if (SC.ContainsItem($"Reservoir.{Module}.BathTotalDaysFaultLimit"))
+            {
+                bathTotalDaysFaultLimit = SC.GetValue<int>($"Reservoir.{Module}.BathTotalDaysFaultLimit");
+            }
+            if (reservoirUsage.BathUsageDays > bathTotalDaysFaultLimit && bathTotalDaysFaultLimit != 0)
+            {
+                LOG.WriteLog(eEvent.ERR_RESERVOIR, Module, $"{Module} Bath Usage(Days):{reservoirUsage.BathUsageDays} is over config item BathTotalDaysFaultLimit:{bathTotalDaysFaultLimit}");
+                return false;
+            }
+            else if (reservoirUsage.BathUsageDays > bathTotalDaysWarningLimit && bathTotalDaysWarningLimit != 0)
+            {
+                LOG.WriteLog(eEvent.WARN_RESERVOIR, Module, $"{Module} Bath Usage(Days):{reservoirUsage.BathUsageDays} is over config item BathTotalDaysWarningLimit:{bathTotalDaysWarningLimit}");
+            }
+            //ReservoirTotalWafersCheck
+            int reservoirTotalWafersWarningLimit = 0;
+            if (SC.ContainsItem($"Reservoir.{Module}.ReservoirTotalWafersWarningLimit"))
+            {
+                reservoirTotalWafersWarningLimit = SC.GetValue<int>($"Reservoir.{Module}.ReservoirTotalWafersWarningLimit");
+            }
+            int reservoirTotalWafersFaultLimit = 0;
+            if (SC.ContainsItem($"Reservoir.{Module}.ReservoirTotalWafersFaultLimit"))
+            {
+                reservoirTotalWafersFaultLimit = SC.GetValue<int>($"Reservoir.{Module}.ReservoirTotalWafersFaultLimit");
+            }
+            if (reservoirUsage.TotalWafers > reservoirTotalWafersFaultLimit && reservoirTotalWafersFaultLimit != 0)
+            {
+                LOG.WriteLog(eEvent.ERR_RESERVOIR, Module, $"{Module} Total Wafers:{reservoirUsage.TotalWafers} is over config item ReservoirTotalWafersFaultLimit:{reservoirTotalWafersFaultLimit}");
+                return false;
+            }
+            else if (reservoirUsage.TotalWafers > reservoirTotalWafersWarningLimit && reservoirTotalWafersWarningLimit != 0)
+            {
+                LOG.WriteLog(eEvent.WARN_RESERVOIR, Module, $"{Module} Total Wafers:{reservoirUsage.TotalWafers} is over config item ReservoirTotalWafersWarningLimit:{reservoirTotalWafersWarningLimit}");
+            }
+            //CMMAnodeTotalAmpHoursCheck
+            double cmmAnodeTotalAmpHoursWarningLimit = 0;
+            if (SC.ContainsItem($"Reservoir.{Module}.CMMAnodeTotalAmpHoursWarningLimit"))
+            {
+                cmmAnodeTotalAmpHoursWarningLimit = (double)SC.GetValue<double>($"Reservoir.{Module}.CMMAnodeTotalAmpHoursWarningLimit");
+            }
+            double cmmAnodeTotalAmpHoursFaultLimit = 0;
+            if (SC.ContainsItem($"Reservoir.{Module}.CMMAnodeTotalAmpHoursFaultLimit"))
+            {
+                cmmAnodeTotalAmpHoursFaultLimit = (double)SC.GetValue<double>($"Reservoir.{Module}.CMMAnodeTotalAmpHoursFaultLimit");
+            }
+            if (reservoirUsage.CMMAnodeUsage > cmmAnodeTotalAmpHoursFaultLimit && cmmAnodeTotalAmpHoursFaultLimit != 0)
+            {
+                LOG.WriteLog(eEvent.ERR_RESERVOIR, Module, $"{Module} CMM Anode Usage(AHr):{reservoirUsage.CMMAnodeUsage} is over config item CMMAnodeTotalAmpHoursFaultLimit:{cmmAnodeTotalAmpHoursFaultLimit}");
+                return false;
+            }
+            else if (reservoirUsage.CMMAnodeUsage > cmmAnodeTotalAmpHoursWarningLimit && cmmAnodeTotalAmpHoursWarningLimit != 0)
+            {
+                LOG.WriteLog(eEvent.WARN_RESERVOIR, Module, $"{Module} CMM Anode Usage(AHr):{reservoirUsage.CMMAnodeUsage} is over config item CMMAnodeTotalAmpHoursWarningLimit:{cmmAnodeTotalAmpHoursWarningLimit}");
+            }
+            //CMMCathodeTotalAmpHoursCheck
+            double cmmCathodeTotalAmpHoursWarningLimit = 0;
+            if (SC.ContainsItem($"Reservoir.{Module}.CMMCathodeTotalAmpHoursWarningLimit"))
+            {
+                cmmCathodeTotalAmpHoursWarningLimit = (double)SC.GetValue<double>($"Reservoir.{Module}.CMMCathodeTotalAmpHoursWarningLimit");
+            }
+            double cmmCathodeTotalAmpHoursFaultLimit = 0;
+            if (SC.ContainsItem($"Reservoir.{Module}.CMMCathodeTotalAmpHoursFaultLimit"))
+            {
+                cmmCathodeTotalAmpHoursFaultLimit = (double)SC.GetValue<double>($"Reservoir.{Module}.CMMCathodeTotalAmpHoursFaultLimit");
+            }
+            if (reservoirUsage.CMMMembranceUsage > cmmCathodeTotalAmpHoursFaultLimit && cmmCathodeTotalAmpHoursFaultLimit != 0)
+            {
+                LOG.WriteLog(eEvent.ERR_RESERVOIR, Module, $"{Module} CMM Cathode Usage(AHr):{reservoirUsage.CMMMembranceUsage} is over config item CMMCathodeTotalAmpHoursFaultLimit:{cmmCathodeTotalAmpHoursFaultLimit}");
+                return false;
+            }
+            else if (reservoirUsage.CMMMembranceUsage > cmmCathodeTotalAmpHoursWarningLimit && cmmCathodeTotalAmpHoursWarningLimit != 0)
+            {
+                LOG.WriteLog(eEvent.WARN_RESERVOIR, Module, $"{Module} CMM Cathode Usage(AHr):{reservoirUsage.CMMMembranceUsage} is over config item CMMCathodeTotalAmpHoursWarningLimit:{cmmCathodeTotalAmpHoursWarningLimit}");
+            }
+            return true;
+        }
+        /// <summary>
+        /// 监控 PM Counter Metal用量
+        /// </summary>
+        private bool MetalUsageMointor(string Module)
+        {
+            MetalUsage metalUsage = MetalUsageManager.Instance.GetMetalUsage(Module);
+            if (metalUsage != null)
+            {
+                //TotalAUsage
+                if (metalUsage.TotalUsage > SC.GetValue<double>($"Metal.{Module}.MetalTotalAmpHoursWarningLimit") && SC.GetValue<double>($"Metal.{Module}.MetalTotalAmpHoursWarningLimit") != 0 && SC.GetValue<double>($"Metal.{Module}.MetalTotalAmpHoursFaultLimit") != 0)
+                {
+                    if (metalUsage.TotalUsage > SC.GetValue<double>($"Metal.{Module}.MetalTotalAmpHoursFaultLimit"))
+                    {
+                        LOG.WriteLog(eEvent.ERR_METAL, Module.ToString(), $"{Module} usage:{metalUsage.TotalUsage} is exceed MetalTotalAmpHoursFaultLimit:{SC.GetValue<double>($"Metal.{Module}.MetalTotalAmpHoursFaultLimit")}");
+                        return false;
+                    }
+                    else
+                    {
+                        LOG.WriteLog(eEvent.WARN_METAL, Module.ToString(), $"{Module} usage:{metalUsage.TotalUsage} is exceed MetalTotalAmpHoursWarningLimit:{SC.GetValue<double>($"Metal.{Module}.MetalTotalAmpHoursWarningLimit")}");
+                    }
+                }
+                //AnodeAUsage
+                if (metalUsage.AnodeAUsage > SC.GetValue<double>($"Metal.{Module}.AnodeATotalAmpHoursWarningLimit") && SC.GetValue<double>($"Metal.{Module}.AnodeATotalAmpHoursWarningLimit") != 0 && SC.GetValue<double>($"Metal.{Module}.AnodeATotalAmpHoursFaultLimit") != 0)
+                {
+                    if (metalUsage.AnodeAUsage > SC.GetValue<double>($"Metal.{Module}.AnodeATotalAmpHoursFaultLimit"))
+                    {
+                        LOG.WriteLog(eEvent.ERR_METAL, Module.ToString(), $"{Module} usage:{metalUsage.AnodeAUsage} is exceed AnodeATotalAmpHoursFaultLimit:{SC.GetValue<double>($"Metal.{Module}.AnodeATotalAmpHoursFaultLimit")}");
+                        return false;
+                    }
+                    else
+                    {
+                        LOG.WriteLog(eEvent.WARN_METAL, Module, $"{Module} usage:{metalUsage.AnodeAUsage} is exceed AnodeATotalAmpHoursWarningLimit:{SC.GetValue<double>($"Metal.{Module}.AnodeATotalAmpHoursWarningLimit")}");
+                    }
+                }
+                //AnodeBUsage
+                if (metalUsage.AnodeBUsage > SC.GetValue<double>($"Metal.{Module}.AnodeBTotalAmpHoursWarningLimit") && SC.GetValue<double>($"Metal.{Module}.AnodeBTotalAmpHoursWarningLimit") != 0 && SC.GetValue<double>($"Metal.{Module}.AnodeBTotalAmpHoursFaultLimit") != 0)
+                {
+                    if (metalUsage.AnodeBUsage > SC.GetValue<double>($"Metal.{Module}.AnodeBTotalAmpHoursFaultLimit"))
+                    {
+                        LOG.WriteLog(eEvent.ERR_METAL, Module, $"{Module} usage:{metalUsage.AnodeBUsage} is exceed AnodeBTotalAmpHoursFaultLimit:{SC.GetValue<double>($"Metal.{Module}.AnodeBTotalAmpHoursFaultLimit")}");
+                        return false ;
+                    }
+                    else
+                    {
+                        LOG.WriteLog(eEvent.WARN_METAL, Module, $"{Module} usage:{metalUsage.AnodeBUsage} is exceed AnodeBTotalAmpHoursWarningLimit:{SC.GetValue<double>($"Metal.{Module}.AnodeBTotalAmpHoursWarningLimit")}");
+                    }
+                }
+
+                //MembraneAUsage
+                if (metalUsage.MembranceAUsage > SC.GetValue<double>($"Metal.{Module}.MembraneATotalAmpHoursWarningLimit") && SC.GetValue<double>($"Metal.{Module}.MembraneATotalAmpHoursWarningLimit") != 0 && SC.GetValue<double>($"Metal.{Module}.MembraneATotalAmpHoursFaultLimit") != 0)
+                {
+                    if (metalUsage.MembranceAUsage > SC.GetValue<double>($"Metal.{Module}.MembraneATotalAmpHoursFaultLimit"))
+                    {
+                        LOG.WriteLog(eEvent.ERR_METAL, Module, $"{Module} usage:{metalUsage.MembranceAUsage} is exceed MembraneATotalAmpHoursFaultLimit:{SC.GetValue<double>($"Metal.{Module}.MembraneATotalAmpHoursFaultLimit")}");
+                        return false;
+                    }
+                    else
+                    {
+                        LOG.WriteLog(eEvent.WARN_METAL, Module, $"{Module} usage:{metalUsage.MembranceAUsage} is exceed MembraneATotalAmpHoursWarningLimit:{SC.GetValue<double>($"Metal.{Module}.MembraneATotalAmpHoursWarningLimit")}");
+                    }
+                }
+
+                //MembraneBUsage
+                if (metalUsage.MembranceBUsage > SC.GetValue<double>($"Metal.{Module}.MembraneBTotalAmpHoursWarningLimit") && SC.GetValue<double>($"Metal.{Module}.MembraneBTotalAmpHoursWarningLimit") != 0 && SC.GetValue<double>($"Metal.{Module}.MembraneBTotalAmpHoursFaultLimit") != 0)
+                {
+                    if (metalUsage.MembranceBUsage > SC.GetValue<double>($"Metal.{Module}.MembraneBTotalAmpHoursFaultLimit"))
+                    {
+                        LOG.WriteLog(eEvent.ERR_METAL, Module, $"{Module} usage:{metalUsage.MembranceBUsage} is exceed MembraneBTotalAmpHoursFaultLimit:{SC.GetValue<double>($"Metal.{Module}.MembraneBTotalAmpHoursFaultLimit")}");
+                    }
+                    else
+                    {
+                        LOG.WriteLog(eEvent.WARN_METAL, Module, $"{Module} usage:{metalUsage.MembranceBUsage} is exceed MembraneBTotalAmpHoursWarningLimit:{SC.GetValue<double>($"Metal.{Module}.MembraneBTotalAmpHoursWarningLimit")}");
+                    }
+                }
+
+                //TotalWafer
+                if (metalUsage.TotalWafers > SC.GetValue<int>($"Metal.{Module}.MetalTotalWafersWarningLimit") && SC.GetValue<int>($"Metal.{Module}.MetalTotalWafersWarningLimit") != 0 && SC.GetValue<int>($"Metal.{Module}.MetalTotalWafersFaultLimit") != 0)
+                {
+                    if (metalUsage.TotalWafers > SC.GetValue<int>($"Metal.{Module}.MetalTotalWafersFaultLimit"))
+                    {
+                        LOG.WriteLog(eEvent.ERR_METAL, Module, $"{Module} usage:{metalUsage.TotalWafers} is exceed MetalTotalWafersFaultLimit:{SC.GetValue<int>($"Metal.{Module}.MetalTotalWafersFaultLimit")}");
+                        return false;
+                    }
+                    else
+                    {
+                        LOG.WriteLog(eEvent.WARN_METAL, Module, $"{Module} usage:{metalUsage.TotalWafers} is exceed MetalTotalWafersWarningLimit:{SC.GetValue<int>($"Metal.{Module}.MetalTotalWafersWarningLimit")}");
+                    }
+                }
+
+                //AnodeAWafer
+                if (metalUsage.AnodeAWafers > SC.GetValue<int>($"Metal.{Module}.AnodeATotalWafersWarningLimit") && SC.GetValue<int>($"Metal.{Module}.AnodeATotalWafersWarningLimit") != 0 && SC.GetValue<int>($"Metal.{Module}.AnodeATotalWafersFaultLimit") != 0)
+                {
+                    if (metalUsage.AnodeAWafers > SC.GetValue<int>($"Metal.{Module}.AnodeATotalWafersFaultLimit"))
+                    {
+                        LOG.WriteLog(eEvent.ERR_METAL, Module, $"{Module} usage:{metalUsage.AnodeAWafers} is exceed AnodeATotalWafersFaultLimit:{SC.GetValue<int>($"Metal.{Module}.AnodeATotalWafersFaultLimit")}");
+                        return false;
+                    }
+                    else
+                    {
+                        LOG.WriteLog(eEvent.WARN_METAL, Module, $"{Module} usage:{metalUsage.AnodeAWafers} is exceed AnodeATotalWafersWarningLimit:{SC.GetValue<int>($"Metal.{Module}.AnodeATotalWafersWarningLimit")}");
+                    }
+                }
+
+                //AnodeBWafer
+                if (metalUsage.AnodeBWafers > SC.GetValue<int>($"Metal.{Module}.AnodeBTotalWafersWarningLimit") && SC.GetValue<int>($"Metal.{Module}.AnodeBTotalWafersWarningLimit") != 0 && SC.GetValue<int>($"Metal.{Module}.AnodeBTotalWafersFaultLimit") != 0)
+                {
+                    if (metalUsage.AnodeBWafers > SC.GetValue<int>($"Metal.{Module}.AnodeBTotalWafersFaultLimit"))
+                    {
+                        LOG.WriteLog(eEvent.ERR_METAL, Module, $"{Module} usage:{metalUsage.AnodeBWafers} is exceed AnodeBTotalWafersFaultLimit:{SC.GetValue<int>($"Metal.{Module}.AnodeBTotalWafersFaultLimit")}");
+                        return false;
+                    }
+                    else
+                    {
+                        LOG.WriteLog(eEvent.WARN_METAL, Module, $"{Module} usage:{metalUsage.AnodeBWafers} is exceed AnodeBTotalWafersWarningLimit:{SC.GetValue<int>($"Metal.{Module}.AnodeBTotalWafersWarningLimit")}");
+                    }
+                }
+
+                //AnodeAbathUsage
+                if (metalUsage.AnodeABathUsage > SC.GetValue<int>($"Metal.{Module}.AnodeABathTotalUsageDaysWarningLimit") && SC.GetValue<int>($"Metal.{Module}.AnodeABathTotalUsageDaysWarningLimit") != 0 && SC.GetValue<int>($"Metal.{Module}.AnodeABathTotalUsageDaysFaultLimit") != 0)
+                {
+                    if (metalUsage.AnodeABathUsage > SC.GetValue<int>($"Metal.{Module}.AnodeABathTotalUsageDaysFaultLimit"))
+                    {
+                        LOG.WriteLog(eEvent.ERR_METAL, Module, $"{Module} usage:{metalUsage.AnodeABathUsage} is exceed AnodeABathTotalUsageDaysFaultLimit:{SC.GetValue<int>($"Metal.{Module}.AnodeABathTotalUsageDaysFaultLimit")}");
+                        return false;
+                    }
+                    else
+                    {
+                        LOG.WriteLog(eEvent.WARN_METAL, Module, $"{Module} usage:{metalUsage.AnodeABathUsage} is exceed AnodeABathTotalUsageDaysWarningLimit:{SC.GetValue<int>($"Metal.{Module}.AnodeABathTotalUsageDaysWarningLimit")}");
+                    }
+                }
+
+                //AnodeBbathUsage
+                if (metalUsage.AnodeBBathUsage > SC.GetValue<int>($"Metal.{Module}.AnodeBBathTotalUsageDaysWarningLimit") && SC.GetValue<int>($"Metal.{Module}.AnodeBBathTotalUsageDaysWarningLimit") != 0 && SC.GetValue<int>($"Metal.{Module}.AnodeBBathTotalUsageDaysFaultLimit") != 0)
+                {
+                    if (metalUsage.AnodeBBathUsage > SC.GetValue<int>($"Metal.{Module}.AnodeBBathTotalUsageDaysFaultLimit"))
+                    {
+                        LOG.WriteLog(eEvent.ERR_METAL, Module, $"{Module} usage:{metalUsage.AnodeBBathUsage} is exceed AnodeBBathTotalUsageDaysFaultLimit:{SC.GetValue<int>($"Metal.{Module}.AnodeBBathTotalUsageDaysFaultLimit")}");
+                        return false;
+                    }
+                    else
+                    {
+                        LOG.WriteLog(eEvent.WARN_METAL, Module, $"{Module} usage:{metalUsage.AnodeBBathUsage} is exceed AnodeBBathTotalUsageDaysWarningLimit:{SC.GetValue<int>($"Metal.{Module}.AnodeBBathTotalUsageDaysWarningLimit")}");
+                    }
+                }
+            }
+            return true;
+        }
     }
 }

Framework/Common/Common.csproj

@@ -35,6 +35,9 @@
     <Reference Include="DocumentFormat.OpenXml">
       <HintPath>..\..\ThirdParty\DocumentFormat.OpenXml.dll</HintPath>
     </Reference>
+    <Reference Include="DotNetZip">
+      <HintPath>..\..\ThirdParty\DotNetZip.dll</HintPath>
+    </Reference>
     <Reference Include="ILNumerics.Net">
       <HintPath>..\..\ThirdParty\ILNumerics.Net.dll</HintPath>
     </Reference>

Framework/Common/Device/Galil/GalilControllerCfgManager.cs

@@ -183,10 +183,10 @@ namespace MECF.Framework.Common.Device.Galil
                 }
                 GalilAxisData galilAxisData=controllerData.GalilAxisDatas[index];
 
-                //if (SC.GetValue<bool>("System.IsSimulatorMode"))
-                //{
-                //    LOG.WriteBackgroundLog(eEvent.INFO_AXIS, moduleName, JsonConvert.SerializeObject(galilAxisData));
-                //}
+                if (SC.GetValue<bool>("System.IsSimulatorMode"))
+                {
+                    LOG.WriteBackgroundLog(eEvent.INFO_AXIS, moduleName, JsonConvert.SerializeObject(galilAxisData));
+                }
                 CheckAxisDataChanged(moduleName, galilAxisData);
             }
         }

Framework/Common/Log/LogManager.cs

@@ -1,6 +1,11 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
+using System.Linq;
+using System.Text;
 using System.Timers;
+using Aitex.Core.RT.SCCore;
+using Ionic.Zip;
 
 namespace Aitex.Core.RT.Log
 {
@@ -9,8 +14,19 @@ namespace Aitex.Core.RT.Log
         public const int MaxLogsMonth = 3;
         public static  readonly log4net.ILog loginfo = log4net.LogManager.GetLogger("fileAppender");       
         private static Timer deleteTimer;//定义定时器,定时删除log
+        private int _logsSaveDays;
+        private bool _isEnableCompressLogFile;
         public void Initialize()
         {
+            if (SC.ContainsItem("System.LogsSaveDays"))
+            {
+                _logsSaveDays = SC.GetValue<int>("System.LogsSaveDays");
+            }
+
+            if (SC.ContainsItem("System.IsEnableCompressLogFile"))
+            {
+                _isEnableCompressLogFile = SC.GetValue<bool>("System.IsEnableCompressLogFile");
+            }
             deleteTimer = new Timer(1);
             deleteTimer.Elapsed += OnDeleteLog;
             deleteTimer.AutoReset = true;
@@ -45,12 +61,12 @@ namespace Aitex.Core.RT.Log
         /// <returns></returns>
         void OnDeleteLog(Object source, ElapsedEventArgs e)
         {
+            if (deleteTimer.Interval == 1)
+            {
+                deleteTimer.Interval = 24 * 60 * 60 * 1000;//每隔24小时删除
+            }
             try
             {
-                if (deleteTimer.Interval == 1)
-                {
-                    deleteTimer.Interval = 1000 * 60 * 60 * 24;
-                }
                 string path = string.Format(@"{0}", "Logs");
 
                 FileInfo[] fileInfos;
@@ -58,25 +74,97 @@ namespace Aitex.Core.RT.Log
                 fileInfos = curFolderInfo.GetFiles();
                 foreach (FileInfo info in fileInfos)
                 {
-                    if (info.Name.Contains("log") && info.Extension == ".txt")
+                    if (info.Extension == ".log" || info.Extension == ".txt" || info.Name.Contains("log"))
                     {
                         DateTime lastWriteTime = DateTime.Parse(info.LastWriteTime.ToShortDateString());
-                        DateTime intervalTime = DateTime.Now.AddMonths(-MaxLogsMonth);
+                        if (_logsSaveDays != 0)
+                        {
+                            DateTime intervalTime = DateTime.Now.AddDays(-_logsSaveDays);
 
-                        if (lastWriteTime < intervalTime)
+                            if (lastWriteTime < intervalTime)
+                            {
+                                File.Delete(info.FullName);
+                            }
+                        }
+                        if (_isEnableCompressLogFile && lastWriteTime < DateTime.Now.AddDays(-1))
                         {
-                            File.Delete(info.FullName);
+                            if (CompressFile(info.FullName, $"{curFolderInfo.FullName}//{info.Name}.zip"))
+                            {
+                                File.Delete(info.FullName);
+                                LOG.WriteBackgroundLog(eEvent.INFO_WINRESOURCE, "System", $"delete log successfully，logName:{info.Name}");
+                            }
                         }
                     }
                 }
-               
             }
-            catch 
+            catch(Exception ex)
             {
-               
+                LOG.WriteExeption(ex);
             }
         }
 
+        /// <summary>
+        /// 压缩文件/文件夹
+        /// </summary>
+        /// <param name="filePath">需要压缩的文件/文件夹路径</param>
+        /// <param name="zipPath">压缩文件路径（zip后缀）</param>
+        /// <param name="password">密码</param>
+        /// <param name="filterExtenList">需要过滤的文件后缀名</param>
+        private bool CompressFile(string filePath, string zipPath, string password = "", List<string> filterExtenList = null)
+        {
+            try
+            {
+                using (ZipFile zip = new ZipFile(Encoding.UTF8))
+                {
+                    if (!string.IsNullOrWhiteSpace(password))
+                    {
+                        zip.Password = password;
+                    }
+                    if (Directory.Exists(filePath))
+                    {
+                        if (filterExtenList == null)
+                            zip.AddDirectory(filePath);
+                        else
+                            AddDirectory(zip, filePath, filePath, filterExtenList);
+                    }
+                    else if (File.Exists(filePath))
+                    {
+                        zip.AddFile(filePath, "");
+                    }
+                    zip.Save(zipPath);
+                    return true;
+                }
+            }
+            catch (Exception ex)
+            {
+                LOG.WriteExeption(ex);
+            }
+            return false;
+        }
+        /// <summary>
+        /// 添加文件夹
+        /// </summary>
+        /// <param name="zip">ZipFile对象</param>
+        /// <param name="dirPath">需要压缩的文件夹路径</param>
+        /// <param name="rootPath">根目录路径</param>
+        /// <param name="filterExtenList">需要过滤的文件后缀名</param>
+        private void AddDirectory(ZipFile zip, string dirPath, string rootPath, List<string> filterExtenList)
+        {
+            var files = Directory.GetFiles(dirPath);
+            for (int i = 0; i < files.Length; i++)
+            {
+                if (filterExtenList == null || (filterExtenList != null && !filterExtenList.Any(d => Path.GetExtension(files[i]).ToLower() == d.ToLower())))
+                {
+                    string relativePath = Path.GetFullPath(dirPath).Replace(Path.GetFullPath(rootPath), "");
+                    zip.AddFile(files[i], relativePath);
+                }
+            }
+            var dirs = Directory.GetDirectories(dirPath);
+            for (int i = 0; i < dirs.Length; i++)
+            {
+                AddDirectory(zip, dirs[i], rootPath, filterExtenList);
+            }
+        }
         public void Terminate()
         {
             try

Framework/Common/OperationCenter/InvokeService.cs

@@ -18,15 +18,6 @@ namespace MECF.Framework.Common.OperationCenter
                 //    EV.PostMessage("System", EventEnum.DefaultWarning, "Software is expired. Can not do the operation");
                 //    return;
                 //}
-                string argsList = "";
-                if (args.Length > 0)
-                {
-                    foreach (object arg in args)
-                    {
-                        argsList += (" " + arg.ToString());
-                    }
-                }
-                LOG.WriteLog(eEvent.EV_DEVICE_INFO, "", $"{operationName} was execute，parameter ：{argsList}");
                 OP.DoOperation(operationName, args);
             }
             catch (Exception ex)

Framework/Common/OperationCenter/InvokeServiceClient.cs

@@ -1,4 +1,5 @@
-using Aitex.Core.Util;
+using Aitex.Core.RT.Log;
+using Aitex.Core.Util;
 using Aitex.Core.WCF;
 
 namespace MECF.Framework.Common.OperationCenter
@@ -38,6 +39,15 @@ namespace MECF.Framework.Common.OperationCenter
  
         public void DoOperation(string operationName, params object[] args)
         {
+            string argsList = "";
+            if (args.Length > 0)
+            {
+                foreach (object arg in args)
+                {
+                    argsList += (" " + arg.ToString());
+                }
+            }
+            LOG.WriteLog(eEvent.EV_DEVICE_INFO, "", $"{operationName} was execute，parameter ：{string.Join(" ", args)}");
             Invoke(svc => { svc.DoOperation(operationName, args); });
         }