def moduleInit(self, dictModCfg={}, dictCfgUsr={}):
dictSettings = {
"nSilenceFrom" : 19,
"nSilenceTo" : 6,
"nTellTimeInt" : 30,
"strSoundHour" : "BellToll",
}
if (not dictModCfg):
dictModCfg.update(dictSettings)
else:
for (strName, strValue) in dictSettings.items():
if strName not in dictModCfg:
dictModCfg.update({strName : strValue})
dictCfgUsr.update({
"nSilenceFrom" : {
"title" : "Beginn der Ruhezeit",
"description" : ("Der Beginn der Ruhezeit gibt an, ab welcher Stunde (0..23) "+
"keine Glockenschläge und keine Zeitansagen ausgegeben werden "+
"sollen. Zusammen mit dem Ende der Ruhezeit kann so ein "+
"Zeitfenster der Stille festgelegt werden, um Ruhestörungen "+
"zu vermeiden."),
"default" : "0"
},
"nSilenceTo" : {
"title" : "Ende der Ruhezeit",
"description" : ("Das Ende der Ruhezeit gibt an, bis zu welcher Stunde (0..23) "+
"keine Glockenschläge und keine Zeitansagen ausgegeben werden "+
"sollen. Zusammen mit dem Beginn der Ruhezeit kann so ein "+
"Zeitfenster der Stille festgelegt werden, um Ruhestörungen "+
"zu vermeiden."),
"default" : "0"
},
"nTellTimeInt" : {
"title" : "Uhrzeitansage",
"description" : ("Die Uhrzeit kann in einem festen Raster von stündlich bis "+
"alle 5 Minuten angesagt werden."),
"default" : "30",
"choices" : {
"Jede volle Stunde" : "60",
"Jede halbe Stunde" : "30",
"Jede viertel Stunde" : "15",
"Alle 5 Minuten" : "5"
}
},
"strSoundHour" : {
"title" : "Klang Stundenschlag",
"description" : ("Die akustische Anzeige der Uhrzeit erfolgt durch den "+
"angegebenen Klang."),
"default" : "BellToll",
"choices" : Globs.s_dictSettings["Sounds"],
"keyIsValue" : True
},
})
self.m_nSilenceFrom = Globs.getSetting("Clock", "nSilenceFrom", "\\d{1,2}", 19)
self.m_nSilenceTo = Globs.getSetting("Clock", "nSilenceTo", "\\d{1,2}", 6)
self.m_nTellTimeInt = Globs.getSetting("Clock", "nTellTimeInt", "\\d{1,2}", 30)
return True
def updateContext(self):
self.m_nHour24h = int(time.strftime("%H"))
self.m_nMinutes = int(time.strftime("%M"))
self.m_nUpdateHour = Globs.getSetting("Updater", "nUpdateHour", "\\d{1,2}", 1)
self.m_bAutoUpdate = Globs.getSetting("Updater", "bAutoUpdate", "True|False", False)
self.m_bAutoReboot = Globs.getSetting("Updater", "bAutoReboot", "True|False", False)
self.m_strSystemUrl = Globs.getSetting("Updater", "strSystemUrl",
"[Hh][Tt][Tt][Pp][Ss]+\\://.+/.+", "")
self.m_strChkUpdUrl = Globs.getSetting("Updater", "strChkUpdUrl",
"[Hh][Tt][Tt][Pp][Ss]+\\://.+/.+", "")
Globs.setSetting("Updater", "fChkVersion", self.m_fChkVersion)
return
def updateTime(self):
self.m_strMonName = time.strftime("%B")
self.m_strDayName = time.strftime("%A")
self.m_nMonYear = int(time.strftime("%m"))
self.m_nDayWeek = int(time.strftime("%w"))
self.m_nYear4xY = int(time.strftime("%Y"))
self.m_nYear2xY = int(time.strftime("%y"))
self.m_nWeekOfY = int(time.strftime("%W"))
self.m_nHour24h = int(time.strftime("%H"))
self.m_nHour12h = int(time.strftime("%I"))
self.m_nMinutes = int(time.strftime("%M"))
self.m_nTimeSpoken = 0
self.m_nSilenceFrom = Globs.getSetting("Clock", "nSilenceFrom", "\\d{1,2}", 19)
self.m_nSilenceTo = Globs.getSetting("Clock", "nSilenceTo", "\\d{1,2}", 6)
self.m_nTellTimeInt = Globs.getSetting("Clock", "nTellTimeInt", "\\d{1,2}", 30)
return
def moduleExec(self,
strPath,
oHtmlPage,
dictQuery,
dictForm
):
print("%r::moduleExec(strPath=%s, dictQuery=%s, dictForm=%s) [%s]" % (
self, strPath, dictQuery, dictForm, datetime.today().strftime("%X")))
if not dictQuery:
return False
# Akustische Uhrzeitanzeige
bResult = False
for (strCmd, lstArg) in dictQuery.items():
if (strCmd == "timer" and lstArg and lstArg[0] == "cron"):
self.updateTime()
# Default: Aktustische Zeitanzeige
if Globs.getSetting("System", "bTestMode", "True|False", False):
TaskSpeak(self.getWorker(), "Entschuldigung. Test.").start()
self.gong()
self.speakTime()
elif (self.isAllowed() and (self.m_nMinutes % self.m_nTellTimeInt) == 0):
self.gong()
self.speakTime()
bResult = True
elif (strCmd == "clock"):
for strArg in lstArg:
self.updateTime()
# Nur Glockenschlag ausführen
if (strArg == "gong"):
self.gong()
bResult = True
continue
# Nur Zeitansage ausführen
if (strArg == "speak"):
self.speakTime()
bResult = True
continue
# Modultest ausführen
if (strArg == "test"):
TaskSpeak(self.getWorker(), "Der Modultest für die Uhr wird jetzt gestartet").start()
nHour = 1
nMinute = 0
while (nHour <= 12):
self.m_nHour12h = nHour
TaskSpeak(self.getWorker(), "Stunde " + str(self.m_nHour12h)).start()
while (nMinute <= 59):
self.m_nMinutes = nMinute
TaskSpeak(self.getWorker(), "Minute " + str(self.m_nMinutes)).start()
self.speakTime()
self.m_nTimeSpoken = 0
nMinute += 1
nMinute = 0
nHour += 1
TaskSpeak(self.getWorker(), "Der Modultest für die Uhr ist jetzt beendet").start()
# Unbekanntes Kommando
return bResult
def gong(self):
nCount = 0
if (self.m_nMinutes % self.m_nTellTimeInt) == 0:
if self.m_nMinutes == 0:
nCount = self.m_nHour12h
elif self.m_nTellTimeInt == 30 or self.m_nTellTimeInt == 5:
nCount = 1
else:
nCount = int(self.m_nMinutes / 15)
# Testmodus berücksichtigen
if (nCount == 0 and Globs.getSetting("System", "bTestMode", "True|False", False)):
nCount = 1
# Ggf. Sound abspielen
if (nCount >= 1):
TaskSound(self.getWorker(),
Globs.getSetting("Clock", "strSoundHour", ".+", "BellToll"),
nLoops = nCount).start()
return
def getCpuTemp():
fResult = 273.15
fResult *= -1
regexSep = r"[\=\']"
parts = [[1, 2],]
strResult = subprocess.check_output(
"vcgencmd measure_temp",
stderr = subprocess.STDOUT,
shell = True,
universal_newlines = True)
temp = partList(re.split(regexSep, strResult), parts)[0]
fResult = float(temp)
if (Globs.getSetting("System", "bTestMode", "True|False", False)
and not Globs.s_oQueueTestCpuTempValues.empty()):
fResult = Globs.s_oQueueTestCpuTempValues.get(False)
return fResult
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