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
