def moduleInit(self, dictModCfg=None, dictCfgUsr=None): print("%r::moduleInit(%s) Version 5" % (self, SDK.getCpuTemp())) return True
def moduleExec(self, strPath, oHtmlPage, dictQuery, dictForm ): print("%r::moduleExec(strPath=%s, oHtmlPage=%s, dictQuery=%r, dictForm=%r)" % ( self, strPath, oHtmlPage, dictQuery, dictForm)) if not dictQuery: return False bResult = False for (strCmd, lstArg) in dictQuery.items(): if (strCmd == "cputemp"): for strArg in lstArg: # Modultest für die CPU-Temperaturüberwachung if (strArg == "hysterese"): TaskSpeak(self.getWorker(), "Der Modultest für die Temperaturüberwachung der CPU wird vorbereitet").start() fCpuTempA = Globs.getSetting("System", "fCpuTempA", "\\d{2,}\\.\\d+", 60.0) fCpuTempB = Globs.getSetting("System", "fCpuTempB", "\\d{2,}\\.\\d+", 56.0) fCpuTempC = Globs.getSetting("System", "fCpuTempC", "\\d{2,}\\.\\d+", 53.0) fCpuTempH = Globs.getSetting("System", "fCpuTempH", "\\d{2,}\\.\\d+", 1.0) fCpuTempStep = fCpuTempH / 2.0 fCpuTempDir = 1.0 fCpuTempBase = SDK.getCpuTemp() fCpuTemp = fCpuTempBase fCpuTempHyst = fCpuTempH * 2.0 nHysTest = 0 Globs.s_oQueueTestCpuTempValues.put(fCpuTemp, block=False) # Erst steigende, dann sinkende Temperaturen while (fCpuTemp >= (fCpuTempC - (fCpuTempHyst * 2.0))): fCpuTemp += (fCpuTempStep * fCpuTempDir) Globs.s_oQueueTestCpuTempValues.put(fCpuTemp, block=False) # Erste Hysterese testen if (fCpuTemp > (fCpuTempC + fCpuTempHyst) and nHysTest == 0): while (fCpuTemp > (fCpuTempC - fCpuTempHyst)): fCpuTemp -= fCpuTempStep Globs.s_oQueueTestCpuTempValues.put(fCpuTemp, block=False) nHysTest += 1 # Zweite Hysterese testen if (fCpuTemp > (fCpuTempB + fCpuTempHyst) and nHysTest == 1): while (fCpuTemp > (fCpuTempB - fCpuTempHyst)): fCpuTemp -= fCpuTempStep Globs.s_oQueueTestCpuTempValues.put(fCpuTemp, block=False) nHysTest += 1 # Dritte Hysterese testen if (fCpuTemp > (fCpuTempA + fCpuTempHyst) and nHysTest == 2): while (fCpuTemp > (fCpuTempA - fCpuTempHyst)): fCpuTemp -= fCpuTempStep Globs.s_oQueueTestCpuTempValues.put(fCpuTemp, block=False) nHysTest += 1 # Temperaturrichtung umkehren if (fCpuTemp >= (fCpuTempA + (fCpuTempHyst * 0.75)) and nHysTest == 3): fCpuTempDir *= (-1.0) nHysTest += 1 bResult = True TaskSpeak(self.getWorker(), "Der Modultest für die Temperaturüberwachung der CPU ist jetzt bereit").start() continue # Unbekanntes Kommando return bResult
def do(self): fCpuTemp = SDK.getCpuTemp() strCpuUse = SDK.getCpuUse().strip() lstRamInfo = SDK.getRamInfo() lstDiskSpace = SDK.getDiskSpace() fCpuTempA = Globs.getSetting("System", "fCpuTempA", "\\d{2,}\\.\\d+", 60.0) fCpuTempB = Globs.getSetting("System", "fCpuTempB", "\\d{2,}\\.\\d+", 56.0) fCpuTempC = Globs.getSetting("System", "fCpuTempC", "\\d{2,}\\.\\d+", 53.0) fCpuTempH = Globs.getSetting("System", "fCpuTempH", "\\d{2,}\\.\\d+", 1.0) try: fCpuUse = float(strCpuUse.replace(",", ".", 1)) except: fCpuUse = 0.0 # IP-Adresse ermitteln if not TaskSystemWatchDog.s_strIpAddr: TaskSystemWatchDog.s_strIpAddr = SDK.getNetworkInfo( Globs.getSetting("System", "strNetInfoName")) if TaskSystemWatchDog.s_strIpAddr: TaskSpeak(self.m_oWorker, "Die aktuelle Netzwerkadresse ist: %s" % ( TaskSystemWatchDog.s_strIpAddr.replace(".", " Punkt "))).start() elif TaskSystemWatchDog.s_nIpFailCnt < 4: TaskSystemWatchDog.s_nIpFailCnt += 1 TaskSpeak(self.m_oWorker, "Die aktuelle Netzwerkadresse konnte nicht ermittelt werden.").start() else: TaskSystemWatchDog.s_strIpAddr = "127.0.0.1" TaskSpeak(self.m_oWorker, "Die Netzwerkadresse kann nicht ermittelt werden, daher wird %s angenommen." % ( TaskSystemWatchDog.s_strIpAddr.replace(".", " Punkt "))).start() # CPU-Statistik erstellen if not TaskSystemWatchDog.s_bHistory: # Statistik initialisieren TaskSystemWatchDog.s_fCpuTempMin = fCpuTemp TaskSystemWatchDog.s_fCpuTempMax = fCpuTemp TaskSystemWatchDog.s_fCpuTempAvg = fCpuTemp TaskSystemWatchDog.s_fCpuUseMin = fCpuUse TaskSystemWatchDog.s_fCpuUseMax = fCpuUse TaskSystemWatchDog.s_fCpuUseAvg = fCpuUse else: # CPU-Temperaturen TaskSystemWatchDog.s_fCpuTempMin = min( TaskSystemWatchDog.s_fCpuTempMin, fCpuTemp) TaskSystemWatchDog.s_fCpuTempMax = max( TaskSystemWatchDog.s_fCpuTempMax, fCpuTemp) TaskSystemWatchDog.s_fCpuTempAvg += fCpuTemp TaskSystemWatchDog.s_fCpuTempAvg /= 2.0 # CPU-Auslastungen TaskSystemWatchDog.s_fCpuUseMin = min( TaskSystemWatchDog.s_fCpuUseMin, fCpuUse) TaskSystemWatchDog.s_fCpuUseMax = max( TaskSystemWatchDog.s_fCpuUseMax, fCpuUse) TaskSystemWatchDog.s_fCpuUseAvg += fCpuUse TaskSystemWatchDog.s_fCpuUseAvg /= 2.0 # Systemwerte vorbereiten if "CPU" not in Globs.s_dictSystemValues: Globs.s_dictSystemValues.update({"CPU" : {}}) if "RAM" not in Globs.s_dictSystemValues: Globs.s_dictSystemValues.update({"Arbeitsspeicher" : {}}) if "MEM" not in Globs.s_dictSystemValues: Globs.s_dictSystemValues.update({"Speicherkapazität" : {}}) if "Netzwerk" not in Globs.s_dictSystemValues: Globs.s_dictSystemValues.update({"Netzwerk" : {}}) # Systemwerte eintragen Globs.s_dictSystemValues["CPU"].update({ "Auslastung" : "%s%%" % (strCpuUse), "Auslastung Min" : "%0.2f%%" % (TaskSystemWatchDog.s_fCpuUseMin), "Auslastung Max" : "%0.2f%%" % (TaskSystemWatchDog.s_fCpuUseMax), "Auslastung Avg" : "%0.2f%%" % (TaskSystemWatchDog.s_fCpuUseAvg), "Temperatur" : "%0.1f°C" % (fCpuTemp), "Temperatur Min" : "%0.2f°C" % (TaskSystemWatchDog.s_fCpuTempMin), "Temperatur Max" : "%0.2f°C" % (TaskSystemWatchDog.s_fCpuTempMax), "Temperatur Avg" : "%0.2f°C" % (TaskSystemWatchDog.s_fCpuTempAvg),}) Globs.s_dictSystemValues["Netzwerk"].update({ "IP-Adresse" : "%s" % (TaskSystemWatchDog.s_strIpAddr),}) lstLabels = ["Gesamt", "Belegt", "Frei", "Geteilt", "Gepuffert", "Im Cache"] nIndex = 0 for strData in lstRamInfo: Globs.s_dictSystemValues["RAM"].update({ lstLabels[nIndex] : strData + "K"}) nIndex += 1 lstLabels = ["Gesamt", "Belegt", "Verfügbar", "Belegung"] nIndex = 0 for strData in lstDiskSpace: Globs.s_dictSystemValues["MEM"].update({ lstLabels[nIndex] : strData}) nIndex += 1 # Nächsten Durchlauf einplanen self.m_oWorker.runSystemWatchDog() # CPU-Temperatur auswerten strCpuTemp = ("%0.1f Grad" % (TaskSystemWatchDog.s_fCpuTempAvg) ).replace(".", " Komma ") if TaskSystemWatchDog.s_fCpuTempAvg > fCpuTempA: # # Warn-Level 3 - Notabschaltung # TaskSystemWatchDog.s_nCpuTooHot += 1 if TaskSystemWatchDog.s_nCpuTempLvl != 3: TaskSpeak(self.m_oWorker, "Achtung!").start() TaskSpeak(self.m_oWorker, "Temperaturüberschreitung mit %s!" % ( strCpuTemp)).start() TaskSystemWatchDog.s_nCpuTempLvl = 3 if (TaskSystemWatchDog.s_nCpuTooHot >= 10): TaskSpeak(self.m_oWorker, "Notabschaltung eingeleitet!").start() TaskExit(self.m_oWorker, "term").start() Globs.stop() else: TaskSpeak(self.m_oWorker, "Für Abkühlung sorgen! Notabschaltung %s Prozent!" % ( TaskSystemWatchDog.s_nCpuTooHot * 10)).start() elif (TaskSystemWatchDog.s_fCpuTempAvg > fCpuTempB and TaskSystemWatchDog.s_fCpuTempAvg < (fCpuTempA - fCpuTempH)): # # Warn-Level 2 # TaskSystemWatchDog.s_nCpuTooHot = 0 # if TaskSystemWatchDog.s_nCpuTooHot > 0: # TaskSystemWatchDog.s_nCpuTooHot -= 1 if TaskSystemWatchDog.s_nCpuTempLvl != 2: TaskSpeak(self.m_oWorker, "Die Temperatur ist mit %s zu hoch!" % ( strCpuTemp)).start() TaskSystemWatchDog.s_nCpuTempLvl = 2 elif (TaskSystemWatchDog.s_fCpuTempAvg > fCpuTempC and TaskSystemWatchDog.s_fCpuTempAvg < (fCpuTempB - fCpuTempH)): # # Warn-Level 1 # TaskSystemWatchDog.s_nCpuTooHot = 0 if TaskSystemWatchDog.s_nCpuTempLvl != 1: TaskSpeak(self.m_oWorker, "Die Temperatur ist mit %s erhöht!" % ( strCpuTemp)).start() TaskSystemWatchDog.s_nCpuTempLvl = 1 elif (TaskSystemWatchDog.s_nCpuTempLvl != 0 and TaskSystemWatchDog.s_fCpuTempAvg < (fCpuTempC - fCpuTempH)): # # Warn-Level 0 - Normalbereich # TaskSystemWatchDog.s_nCpuTooHot = 0 TaskSpeak(self.m_oWorker, "Die Temperatur ist mit %s wieder im normalen Bereich" % ( strCpuTemp)).start() TaskSystemWatchDog.s_nCpuTempLvl = 0 elif not TaskSystemWatchDog.s_bHistory: TaskSpeak(self.m_oWorker, "Die Temperatur liegt mit %s im normalen Bereich" % ( strCpuTemp)).start() # Es liegen jetzt Statistikwerte aus der Vergangenheit vor if not TaskSystemWatchDog.s_bHistory: TaskSystemWatchDog.s_bHistory = True return