Hallo zusammen, bin auf der suche nach einer cronjob szene, die mir z.B. alle 2 Minuten ein andere szene triggert. Kann mir da einer helfen oder was zur Verfügung stellen?
Thx skywiesel
Hallo
Möglicherweise hilft dir das über die Straße !
interval = 300 Entspricht 5 x 60 Sekunden.
Auf deine Bedürfnisse anpassen.
Hier zu finden !
https://manuals.fibaro.com/home-center-3-lua-scenes/
Grüße aus dem Sauerland
Frank
1 „Gefällt mir“
Hi Leute,
Ich habe auf der HC2 seit 2018 ein tolles CronJob Skript aus diesem Thread laufen.
Hat jemand schon so etwas für die HC3 realisiert?
Oder besser gefragt, macht so ein Skript auf der HC3 noch Sinn, oder gibt es dafür eine elegantere Lösung?
@pblacky
Ich bin mir nicht sicher ob ich das richtig interpretiere, in dem Skript kannst du Zeitgesteuert einzelne Szenen starten!?
Wenn das so ist, so macht das jetzt beim HC3 keinen Sinn.
Schau mal in dieser Doku nach, da ist eine Beschreibung der Triggermöglichkeiten drin.
https://manuals.fibaro.com/home-center-3-lua-scenes/
Die Variantenvielfalt ist Gewaltig und sollte alle Wünsche abdecken.
Einige sind etwas Tricki aber irgendwie Genial.
Ich glaube das Skript benötigst du nicht mehr.
Gruß Frank
@Berges01
GENAU, das Skript läuft kontinuierlich alle 15 Sekunden und prüft ob es irgendwas zu tun gibt. Wenn ja, dann wird der Bereich mit dem entsprechenden Zeitstempel ausgeführt.
Vorteil: ALLES was automatisch gestartet wird, in einem Skript übersichtlich zusammengefasst!
Wenn ich mir die LUA Doku durchsehe dann erkenne ich zwar das von dir beschriebene Potential und die Variantenvielfalt, die Einstiegshürde für so ein grosses Projekt scheint jedoch noch relativ hoch 
Würdest du auf der HC3 jede Automatisierung in ein eigenes Skript legen?
Wenn ja, wie bekomme ich dann einen Überblich was alles Zeitgesteuert abläuft?
Oder was wäre ein kluger Ansatz ??
Ich habe dir ja schon in einer PN geantwortet.
Das können aber nicht alle mitlesen.
Also ein Resüme.
Ich habe Funktionsblöcke gebaut z.B
Alarmanlage, Rauchmelder Kontrolle & Aktion, Rolladensteuerung, Heizkörpersteuerung, Alarmmeldungen, Lichtsteuerung
Eine Main-Szene habe ich auch laufen da ich festgestellt habe das wenn Szenen zusammen laufen das die CPU-Last zu hoch (Für meine Ansprüche) ist.
So Starte ich in der Main die Hauptszenen Zeitlich voneinander getrennt.
Das brachte eine sehr niedrige Auslastung der CPU und ist demnach so geblieben.
Die Aufteilung in Funktionsgruppen mache ich aus Gründen der Übersichtlichkeit und so kann ich an einer Szene schrauben und Abends einfach wieder zurücktauschen alles läuft wieder.
Am Morgen dann umgekehrt usw. So kann ich schön basteln ohne ein lauffähiges System zu verlieren.
Ist aber auch meinem Beruf geschuldet (Steuerungs/Mess und Regel sowie Prüftechnik).
Mann kann halt nicht aus seiner Haut (Auch als Rentner).
Als Deviese sollte gelten immer Übersichtlich und mit Dokumentation versehen damit auch mal zur Not ein Anderer damit zurecht kommt.
Gruß Frank
Das klingt genial!
Magst du uns hier mit einigen Codeschnipseln davon inspirieren?
Oder sind die zu „persönlich“ …
Main Szene von der aus alles gestartet wird.
Trigger
…
--[[
Tag Nacht umschaltung
Setzen von Globalen Variablen
30.03.2020 F.B. Version 1.0
--]]
-- Das ist ein 1min. Trigger
----------------------------------
{
conditions = {
{
type = "date",
property = "cron",
operator = "match",
value = {"*", "*", "*", "*", "*", "*"},
isTrigger = true
}
},
operator = "all"
}
…
Aktion
…
--[[
Globale Variablen
Für ...........
--------------------------------------------
Tag
Nacht
Für die Rollosteuerung
--------------------------------------------
RollozaehlerTag
RollozaehlerNacht
Minutenzaehler
]]
--Setzen der Tagesrelevanten Daten
local currentDate =os.date("%d/%m/%Y")
local day = os.date("%A", os.time())
local TimeNow = os.date("%H:%M", os.time())
local sunrise=fibaro.getValue(1, "sunriseHour")
local sunset=fibaro.getValue(1, "sunsetHour")
--[[ Ausgabeformat !
print("currentDate = ",currentDate) = 30/03/2020
print("Day = ",day) = Monday
print("TimeNow = ",TimeNow) = 10:32
print("sunrise = ",sunrise) = 07:08
print("sunset = ",sunset) = 20:00
--]]
--Sonnenaufgang wird nur einmal durchlaufen
if TimeNow == sunrise and fibaro.getGlobalVariable("Nacht") == "1" then
print("jetzt ist Sonnenaufgang")
--Bei Start des Tags so
fibaro.setGlobalVariable('Nacht', '0')
fibaro.setGlobalVariable('Tag', '1')
fibaro.setGlobalVariable('RollozaehlerTag', '1')
fibaro.setGlobalVariable('RollozaehlerNacht', '0')
fibaro.setGlobalVariable('Minutenzaehler', '0')
end
--Sonnenuntergang wird nur einmal durchlaufen
if TimeNow == sunset and fibaro.getGlobalVariable("Tag") == "1" then
print("jetzt ist Sonnenuntergang")
--bei Start der Nacht so
fibaro.setGlobalVariable('Nacht', '1')
fibaro.setGlobalVariable('Tag', '0')
fibaro.setGlobalVariable('RollozaehlerTag', '0')
fibaro.setGlobalVariable('RollozaehlerNacht', '1')
fibaro.setGlobalVariable('Minutenzaehler', '0')
end
--Starten der Programmblöcke um die CPU nacheinander zu belasten
--Alles Startet Paralell 2000 endspricht 2 Sekunden
fibaro.setTimeout(2000, function()
fibaro.scene("execute", {170})-- Start Heizungs Steuerung
end)
fibaro.setTimeout(4000, function()
fibaro.scene("execute", {176})-- Start Rollos Steuerung
end)
fibaro.setTimeout(6000, function()
fibaro.scene("execute", {211})-- Start Heizkörper Steuerung
end)
fibaro.setTimeout(8000, function()
fibaro.scene("execute", {216})-- Start Alarmausgabe
end)
…
Das wahr die Mainszene völlig unspektakulär und einfach.
Gruss Frank
1 „Gefällt mir“
Jetzt die Heizungssteuerung auch eine einfache Kiste.
Trigger
…
--[[
Geschaltet werden :
Heizung immer an
Warmwasserumwälzpumpe Zeitgesteuert
Überwachung der Heizung auf dem Dachbode.
Überwacht werden :
Wasseraustritt
Wasserdruck
Heizkreis Warmwasser Vorlaufthemeratur
Heizkreis Heizung Vorlauf
wird gestartet von :
Der Main-Szene mit Execute befehl
Dem Heizungsrelais (ID172) wenn es unter 30W fällt oder >= 30W ansteigt
Sowie dem Taster (ID501) Heizung ein-/Ausschalten wenn er gedrückt wird
Sowie dem Taster (ID502) Heizung Störung löschen
--]]
{
conditions =
{ {
id = 172,
isTrigger = true,
operator = ">=",
property = "power",
type = "device",
value = 30
}, {
id = 172,
isTrigger = true,
operator = "<",
property = "power",
type = "device",
value = 30
}, {
id = 501,
isTrigger = true,
operator = "==",
property = "value",
type = "device",
value = true
}, {
id = 502,
isTrigger = true,
operator = "==",
property = "value",
type = "device",
value = true
} },
operator = "any"
}
…
Aktion
…
-- Locale Variablen mit Globalen füllen
local mel_heizung_druck = tonumber(fibaro.getGlobalVariable("Mel_Heizung_Druck"))
local mel_heizung_wasser = tonumber(fibaro.getGlobalVariable("Mel_Heizung_Wasser"))
local mel_heizung_ausgefal = tonumber(fibaro.getGlobalVariable("Mel_Heizung_ausgefal"))
--Benutzte Geräte ID´s
----------------------------------------------------------------------------------------
local heizung_ein_aus = 172
local taster_heizung_ein_aus = 501
local taster_heizung_stoerung_loeschen =502
local LED_heizung_ein = 505
local LED_heizung_stoerung = 506
local ww_umwaelzpumpe = 173
local wasser_laeuft_aus_heizung = 178
local wasserdruckmesser = 191
local heizung_vorlauf_temp = 181
--Setzen der Tagesrelevanten Daten
----------------------------------------------------------------------------------------
local TimeNow = os.date("%H:%M", os.time())
--print("TimeNow = ",TimeNow) --z.B 10:32
--Warum wurde die Szene getriggert ?
----------------------------------------
--print("Trigger ID = ",json.encode(sourceTrigger.id))
--print ("Trigger Grund = ",json.encode(sourceTrigger.property))
--Warmwasser Umwälzpumpe Ein/Aus
----------------------------------------------------------------------------------------
if (TimeNow == "05:00") and (fibaro.getValue(ww_umwaelzpumpe,"value")) == false then
fibaro.call(ww_umwaelzpumpe, 'turnOn')
--print("Wasserpumpe ein")
end
if (TimeNow == "22:00") and (fibaro.getValue(ww_umwaelzpumpe,"value")) then
fibaro.call(ww_umwaelzpumpe, 'turnOff')
--print("Wasserpumpe aus")
end
--Heizung Ein-/Ausschalten und Anzeige ob die Heizung läuft (Leistung >30W)
----------------------------------------------------------------------------------------
if (json.encode(sourceTrigger.property) == '"execute"') then
-- print('Szene manuell ausgeführt - UserID: ' ..json.encode(sourceTrigger.id))
-- Aktion Manuel nicht vorgesehen !
elseif (tonumber(json.encode(sourceTrigger.id)) == taster_heizung_ein_aus)
and (json.encode(sourceTrigger.property) == '"value"')then -- Tastertrigger
fibaro.call(heizung_ein_aus, 'toggle') -- Heizung Ein- / Ausschalten
elseif (tonumber(json.encode(sourceTrigger.id)) == heizung_ein_aus)
and (json.encode(sourceTrigger.property) == '"power"') then -- Leistungstrigger
if fibaro.getValue(heizung_ein_aus, 'power') >= 30 then
fibaro.call(LED_heizung_ein, 'turnOn')
else
fibaro.call(LED_heizung_ein, 'turnOff')
end
end
--Heizungsstörungen anzeigen und löschen
----------------------------------------------------------------------------------------
if (mel_heizung_wasser == 1) or
(mel_heizung_druck == 1) or
(mel_heizung_ausgefal == 1) then
fibaro.call(LED_heizung_stoerung, 'turnOn')
end
if (tonumber(json.encode(sourceTrigger.id)) == taster_heizung_stoerung_loeschen) then
mel_heizung_wasser = 0
mel_heizung_druck = 0
mel_heizung_ausgefal = 0
fibaro.call(LED_heizung_stoerung, 'turnOff')
end
--Kontrollabläufe
----------------------------------------------------------------------------------------
-- Wasser läuft aus der Heizung
if fibaro.getValue(wasser_laeuft_aus_heizung,"value") then
mel_heizung_wasser = 1 -- Übergabe an Zentrale Meldung
end
-- Wasserdruck der Heizung < 1 Bar
if fibaro.getValue(wasserdruckmesser,"value") < 1.0 then
mel_heizung_druck = 1 -- Übergabe an Zentrale Meldung
end
-- Heizung Vorlauf Heizkreis < 16°C
if fibaro.getValue(heizung_vorlauf_temp,"value") < 16 then
mel_heizung_ausgefal = 1 -- Übergabe an Zentrale Meldung
end
-- Locale an Globale Variablen übergeben
fibaro.setGlobalVariable("Mel_Heizung_Druck",tostring(mel_heizung_druck))
fibaro.setGlobalVariable("Mel_Heizung_Wasser",tostring(mel_heizung_wasser))
fibaro.setGlobalVariable("Mel_Heizung_ausgefal",tostring(mel_heizung_ausgefal))
…
So eigendlich auch nix Spektakuläres nur Abfragen und son Zeugs
So Rollosteuerung auch keine Kunst.
Trigger
…
--[[
Steuerung der Rollos Sonnenaufgang + xmin oder Direkte Zeit
29.03.2020 F.B. Version 1.1
wird von der Mainszene gestartet
--]]
…
Ja Nix drin !
Aktion
…
--[[
Steuerung (dieser Teil wird jede Minute einmal durchlaufen
2 Globale Variablen sind dafür wichtig :
1. Minutenzähler
2. RollozaehlerNacht
3. RollozaehlerTag
Der RollozählerTag und der Rollezähler Nacht werden von der Tag/Nachtumschaltung auf 1 gesetzt und der Ablauf beginnt.
Nach ablauf aller Rollo öffnungen oder schließungen werden wie Variablen wieder auf 0 gesetzt
Der Minutenzähler dient dazu den Zeitversatz zu der Sonnenaufgangs und Sonnenuntergangszeit zu bestimmen
Damit werden die unterschiedlichen Rollos dann gesteuert.
--]]
--Globale nach Localen Variablen übertragen
tag = fibaro.getGlobalVariable("Tag")
nacht = fibaro.getGlobalVariable("Nacht")
--Locale Variablen
-- Rollo ID nur hier zu ändern
ro_eg_kueche = 209 --EG-Küche
ro_eg_esszimmer = 235 -- EG-Esszimmer
ro_eg_wohnzimmer = 244 -- EG-Wohnzimmer
ro_kg_trepp_li = 294 -- KG-Wohnzimmer Treppenaufgang links
ro_kg_trepp_re = 299 -- KG-Wohnzimmer Treppenaufgang rechts
ro_kg_garten_li = 304 -- KG-Wohnzimmer Gartenseite links
ro_kg_garten_tuer = 309 -- KG-Wohnzimmer Gartenseite Tür
-- Hiermt werden die Minuten für den Zeitversatz gesteuert
local Minuten = fibaro.getGlobalVariable("Minutenzaehler")
Minuten = Minuten + 1
fibaro.setGlobalVariable("Minutenzaehler",tostring(Minuten))
--Tagsteuerung
------------------------------------------------------------------------------------
local TagRollo = fibaro.getGlobalVariable("RollozaehlerTag")
--EG-Küche
if os.date("%H:%M", os.time()) == "05:00" then
fibaro.call(ro_eg_kueche, 'open')
end
--EG-Wohnzimmer Rollo im Sommer Später auf
if (os.date("%H:%M", os.time()) == "08:00") and (tag == "1") then
fibaro.call(ro_eg_wohnzimmer , 'open')
end
if TagRollo ~= "0" then --Wird von der Tag und Nacht Umschaltung auf 1 gesetzt
if Minuten == 2 then
-- EG-Esszimmer
fibaro.call(ro_eg_esszimmer, 'open')
TagRollo = TagRollo + 1
end
if (Minuten == 20) then
if (os.date("%H:%M", os.time()) >= "08:00") then
-- EG-Wohnzimmer
fibaro.call(ro_eg_wohnzimmer , 'open')
end
TagRollo = TagRollo + 1
end
if Minuten == 6 then
-- KG-Wohnzimmer Treppenaufgang links
fibaro.call(ro_kg_trepp_li, 'open')
TagRollo = TagRollo + 1
end
if Minuten == 7 then
-- KG-Wohnzimmer Treppenaufgang rechts
fibaro.call(ro_kg_trepp_re, 'open')
TagRollo = TagRollo + 1
end
if Minuten == 8 then
-- KG-Wohnzimmer Gartenseite links
fibaro.call(ro_kg_garten_li, 'open')
TagRollo = TagRollo + 1
end
if Minuten == 9 then
-- KG-Wohnzimmer Gartenseite Tür
fibaro.call(ro_kg_garten_tuer, 'open')
TagRollo = TagRollo + 1
end
if TagRollo == 7 then -- Alles Rollos raufgesteuert Anzahl der Rollos
TagRollo = 0
end
fibaro.setGlobalVariable("RollozaehlerTag",tostring(TagRollo))
end
--Nachtsteuerung
------------------------------------------------------------------------------------
local NachtRollo = fibaro.getGlobalVariable(tostring("RollozaehlerNacht"))
--EG-Küche
if os.date("%H:%M", os.time()) == "22:30" then
fibaro.call(ro_eg_kueche, 'close')
end
--EG-Wohnzimmer im Sommer früher zu
if (os.date("%H:%M", os.time()) == "20:00") and (tag == "1") then
fibaro.call(247, 'setValue', 20)
end
if NachtRollo ~= "0" then --Wird von der Tag und Nacht Umschaltung auf 1 gesetzt
if Minuten == 20 then
-- EG-Esszimmer
fibaro.call(ro_eg_esszimmer, 'close')
NachtRollo = NachtRollo + 1
end
if Minuten == 1 then
-- EG-Wohnzimmer
fibaro.call(ro_eg_wohnzimmer, 'close')
NachtRollo = NachtRollo + 1
end
if Minuten == 21 then
-- KG-Wohnzimmer Treppenaufgang links
fibaro.call(ro_kg_trepp_li, 'close')
NachtRollo = NachtRollo + 1
end
if Minuten == 22 then
-- KG-Wohnzimmer Treppenaufgang rechts
fibaro.call(ro_kg_trepp_re, 'close')
NachtRollo = NachtRollo + 1
end
if Minuten == 23 then
-- KG-Wohnzimmer Gartenseite links
fibaro.call(ro_kg_garten_li, 'close')
NachtRollo = NachtRollo + 1
end
if Minuten == 24 then
-- KG-Wohnzimmer Gartenseite Tür
fibaro.call(ro_kg_garten_tuer, 'close')
NachtRollo = NachtRollo + 1
end
if NachtRollo == 7 then --Alles Rollos runtergesteuert Anzahl der Rollos
NachtRollo = 0
end
fibaro.setGlobalVariable("RollozaehlerNacht",tostring(NachtRollo))
end
--[[
Etwas ausführlicher erklährt !
------------------------------------
In der Tag um Nacht umschaltung werden die Variablen gesetzt damit in der Rolladensteuerung die
Zeiten des öffnens und schliessens der Rollos durchgeführt werden.
fibaro.setGlobalVariable(‚Nacht‘, ‚0‘)
fibaro.setGlobalVariable(‚Tag‘, ‚1‘)
fibaro.setGlobalVariable(‚RollozaehlerTag‘, ‚1‘)
fibaro.setGlobalVariable(‚RollozaehlerNacht‘, ‚0‘)
fibaro.setGlobalVariable(‚Minutenzaehler‘, ‚0‘)
Die Variablen Tag bzw Nacht Steuern unter anderem die Gruppen die nach Sonnenauf- / Sonnenuntergang gefahren werden sollen.
Die Rolladenzähler Zählen die Rolladen die schon bearbeitet wurden.
Die Minuten Counten die Zeit vom Beginn der Tag- / Nachtumschaltung.
In der Rolladen Steuerung
Werden die Minuten hochgezählt (+1)
Dann gibt es 2 Bereiche die für das Rauf (Tag) und für das Runter (Nacht)
In jeder Gruppe wird so abgefragt :
------------------------------
if Minuten == 20 then
– EG-Wohnzimmer
fibaro.call(244, ‚open‘)
TagRollo = TagRollo + 1
end
------------------------------
Wenn die Minuten seit der Tag/Nacht umschaltung die 20 (Minuten) erreicht haben werden die endsprechenden Rollos rauf oder Runter gefahren.
Weiterhin wird der Rolladenzähler um 1 erhöht denn eine weitere Rollade ist abgearbeitet.
Am Ende der Abfragen wird noch abgefragt ob alle Rolladen gefahren sind:
------------------------------
if TagRollo == 7 then – Alles Rollos runtergesteuert Anzahl der Rollos
TagRollo = 0
end
------------------------------
Wenn das erfüllt ist, wird die Variabel TagRollo oder NachtRollo auf 0 gesetzt und der Sack ist zu.
Soll heißen diese jeweiligen Abläufe sind erledigt.
Die Rollade EG-Küche wird unabhängig von Sonnenaufgang oder Untergang immer zur gleichen Zeit gesteuert.
Sollte (wie geplant) eine Neue Rollade dazu kommen so ist das ohne Großen Aufwand schnell erweitert
Damit ist es jetzt möglich ohne langes Überlegen die jeweiligen Rolladen unabhängig voneinander zu unterschiedlichen Zeiten rauf oder Runter zu steuern.
--]]
…
Das ist schon etwas mehr und hat mir am Anfang einiges an Überlegung gekostet
2 „Gefällt mir“
Danke Frank, ist ja ganz schön umfangreich, werde es mir in den nächsten Tagen ansehen!
Erst mal danke für die vielen posts, besonders an Frank!
kann einer kurz über meinen cronjob drüber schauen?!
hab keinen Plan warums immer noch nicht läuft…
{
type = „date“,
property = „cron“,
operator = „matchInterval“,
value = {
date = { „0“, „12“, „5“, „4“, „*“, „2020“ },
interval = 180
},
isTrigger = true
}
Aktion:
fibaro.scene(‚execute‘, {121})
Versuche mal den Trigger
{
conditions = { {
isTrigger = true,
operator = „matchInterval“,
property = „cron“,
type = „date“,
value = {
date = { „00“, „12“, „5“, „4“, „*“, „2020“ },
interval = 180
}
} },
operator = „any“
}
Start am 05.04.2020 12:00 Uhr
Von da an alle 3 Min.
Gruß Frank
1 „Gefällt mir“
So ich hatte noch die Alarmanlage in Aussicht gestellt. Hier ist sie
Das ist umfangreicher und Tricki
Trigger
…
--[[
Programm Alarmanlage
Version 1.0
05.06.2020 c. F.Berges
Fehlende Programmteile :
1. SMS oder Push
2. Sirene
3. Alarmverhinderung
Die Szene wird ausgelöst von :
Alarmbedientafel
---------------------
id 489 = Starttaster
id 490 = Stopptaster
Bedienfeld (QA)
---------------------
id 569-Wert=3 = Alarm scharfschalten
id 569-Wert=4 = Alarmanlage endschärfen
HC3 Meldung
---------------------
homeBreached = Komplettes Haus Alarm
--]]
{
conditions = { {
id = 489,
isTrigger = true,
operator = "==",
property = "value",
type = "device",
value = true
}, {
id = 490,
isTrigger = true,
operator = "==",
property = "value",
type = "device",
value = true
}, {
id = 569,
isTrigger = true,
operator = "==",
property = "value",
type = "device",
value = 3
}, {
id = 569,
isTrigger = true,
operator = "==",
property = "value",
type = "device",
value = 4
}, {
isTrigger = true,
operator = "==",
property = "homeBreached",
type = "alarm",
value = true
} },
operator = "any"
}
…
Aktion
…
--[[
Alarmanlage Scharfschalten und Unscharfschalten
Wird die Starttaste gedrückt, beginnt die Rote LED über dem Taster an zu blinken für 00:05 sprich 5min.
Die Grüne LED für Umscharf geht aus.
Nach Ablauf der Zeit ist die Anlage Scharf
Beim Bestätigen der Stoptaste
Geht die Rote LED aus und die Grüne an.
Jetzt ist die Alarmanlage unscharf.
Bei einem Alarm hat man 5min Zeit bevor der Radau los geht.
Die Grüne und die Rore LED blinken
Die Globalen Variablen werden gefüllt wenn ein Alarm besteht mit :
Alarm = 1 = Alarm
Alarm_Etage_ID = ID Nummer der Etage in der der Alarm ausgelöst wurde
Alarm_Etage_Name = Der Klartextname der Etage
Alarm_Device_ID = ID Nummer des Devices der den Alarm ausgelöst hat
Alarm_Etage_Name = Der Klartextname des Devices
Noch in Planung ! :
Eine Push Nachricht wird aber sofort gesendet.
Sirene
Blinkendes Licht i kompletten Haus ?! Noch unklar ob Gut oder schlecht
--]]
--Globale Variablen übergeben
local alarm = tonumber(fibaro.getGlobalVariable("Alarm"))
local alarm_etage_id = tonumber(fibaro.getGlobalVariable("Alarm_Etage_ID"))
local alarm_etage_name = fibaro.getGlobalVariable("Alarm_Etage_Name")
local alarm_device_id = tonumber(fibaro.getGlobalVariable("Alarm_Device_ID"))
local alarm_device_name = fibaro.getGlobalVariable("Alarm_Device_Name")
-- Lokale Veriablen (Geräte ID´s)
starttaster = 489
stoptaster = 490
start_led_rot = 493
stop_led_gruen = 494
bedienfeld = 569
-- Anzeige Was hat das Programm gestartet
print("Start", json.encode(sourceTrigger.id)," Wert = ", fibaro.getValue(bedienfeld,"value"))
------------------------------------------------------------------------------------
-- Funktion welcher Bereich und welcher Teilnehmer hat ausgelöst
------------------------------------------------------------------------------------
--[[
In der Alarmeinstellung des HC3 werden die Etagen und Teilnehmer am Alarmgeschehen eingetragen.
Um es Universell halten zu können wird mit dieser Funktion rausgesucht welche Etage
und welcher Teilnehmer denn nun ausgelöst hat.
Das geschieht bei der Etage über das raussuchen im "/alarms/v1/partitions" String.
Bei den Geräten passiert das über eine Value-Veränderung in den vorher abgespeicherten Gerätestaus.
--]]
function Frage_Alarm_wo()
local data, status = api.get('/alarms/v1/partitions')
local alarm = 0
local alarm_etagen_id = 0
local alarm_etagen_id_name = ""
local alarm_device_id = 0
local alarm_device_name = ""
for _, v in pairs(data) do --raussuchen welcher Bereich auf Alarm ist
if (json.encode(v.breached) == 'true') and (alarm == 0) then --Nur der Erste Alarm wird gemeldet
alarm_etage_id = json.encode(v.id) -- Etagen ID
alarm_etage_name = json.encode(v.name) -- Etagen Name
alarm = "1"
break -- Vergleichsschleife beenden Etage gefunden
end
end
-- Gemerkte Zustände der Device zurückholen
local data = fibaro.getGlobalVariable("Alarm_Device_Zustand")
tabelle = json.decode(data)
for _, v in pairs(tabelle) do -- Device raussuchen das ausgelöst hat
if fibaro.getValue(tonumber(json.encode(v.ID)),"value") ~= v.zustand then -- Momentaner Zustand anders als der Abgespeicherte ?
alarm_device_id = v.ID
alarm_device_name = fibaro.getName(tonumber(json.encode(v.ID)))
break -- Vergleichsschleife beenden Teilnehmer gefunden
end
end
return alarm,alarm_etage_id,alarm_etage_name,alarm_device_id,alarm_device_name
end --Frage_Alarm_wo()
------------------------------------------------------------------------------------
------------------------------------------------------------------------------------
-- Funktion Alarmbereiche scharfschalten und Sicherungsgeräte merken
------------------------------------------------------------------------------------
--[[
In dieser Funktion werden die einzelnen Bereiche im String "/alarms/v1/partitions" scharfgeschaltet.
Weterhin werden alle Geräte und deren Zustand abgespeichert die an der Alarmüberwachung teilnehmen.
Die Geräte finden sich im Gleichen String.
Das Abspeichern ist notwendig um zu/auf unabhängig zu sein und um hinterher eindeutig sagen zu können wer
den nun ausgelöst hat.
--]]
function Alarm_bereiche_scharf()
local data, status = api.get('/alarms/v1/partitions')
local geraete={} --Zustand der Alarm-Device merken
for _, v in pairs(data) do
--Bereiche scharfschalten
if (json.encode(v.armed) == 'false') then
fibaro.alarm(tonumber(json.encode(v.id)), 'arm')
end
-- Zustand der Alarm-Device einsammeln
i=1
repeat
--Device die in der Alarmkette sind mit deren Zustand abspeichern
local neugeraet =
{
etage = tonumber(json.encode(v.id)),
ID = tonumber(json.encode(v.devices[i])),
zustand = fibaro.getValue(tonumber(json.encode(v.devices[i])),"value")
}
table.insert(geraete,neugeraet)
i = i+1 --Nächster Device
until json.encode(v.devices[i]) == "null" or i == 200 --200 Angst essen Seele auf !
end
--Alles auf Globale Variablen abspeichern
fibaro.setGlobalVariable("Alarm_Device_Zustand",json.encode(geraete)) --Alle Alarmdevice Zustände Global abspeichern
end --Alarm_bereiche_scharf()
------------------------------------------------------------------------------------
------------------------------------------------------------------------------------
-- Funktion Bereiche unscharfschalten
------------------------------------------------------------------------------------
--[[
Hier werden alle Alarmbereiche (Etagen) wieder unscharf geschaltet.
Auch das ist keine Feste vorgabe sondern richtet sich nach den vorher festgelegten Bereichen in der HC3 Alarmeinstellung
--]]
function Alarm_bereiche_unscharf()
local data, status = api.get('/alarms/v1/partitions')
for _, v in pairs(data) do
if (json.encode(v.armed) == 'true') then
fibaro.alarm(tonumber(json.encode(v.id)), 'disarm')
end
end
end --Alarm_bereiche_unscharf()
------------------------------------------------------------------------------------
------------------------------------------------------------------------------------
-- Türen & Fenster alle zu ?
------------------------------------------------------------------------------------
--[[
Hier werden alle Türen und Fenster die geschlssen sein sollten abgefragt ob sie auch zu sind.
Das geschieht über die IDs der Geräte.
Dazu ist mir noch nichts universelles eingefallen.
--]]
function TuerFenZu()
local tuerfensterID =
{
31, --EG Computerraum Tür Gartenseite
53, --EG Flur Garagentür
65, --EG Toilette Fenster
83, --EG Garage Tor
110, --DG Badezimmer Fenster
113, --DG Badezimmer Tür
134, --DG Sonjas-Zimmer Fenster
143, --DG Wii-Zimmer Tür
148, --DG Wii-Zimmer Fenster
158, --DG Noras-Zimmer Fenster
202, --EG Küche Fenster
213, --EG Esszimmer Fenster
243, --EG Wohnzimmer Fenster
274, --EG Eingang Tür
313, --KG Wohnzimmer Tür
321, --KG Wohnzimmer Treppenseite Fenster
344, --KG Eingang Tür
350, --KG Küche Fenster
474, --DG Sonjas-Zimmer Tür
}
local dasistoffen = ""
for index, tfID in pairs(tuerfensterID) do --raussuchen welcher ID auf/zu ist
if fibaro.getValue(tfID, "value") == true then
--print("TürFenster ID =",tfID," = zu")
--print(" >> Raum = ",fibaro.getRoomNameByDeviceID(tfID))
--print(" >> Name = ",fibaro.getName(tfID))
dasistoffen = ""..fibaro.getRoomNameByDeviceID(tfID).." / "..fibaro.getName(tfID)
break
end
if fibaro.getValue(tfID, "value") == false then
--print("TürFenster ID =",tfID," = auf")
--print(" >> Raum = ",fibaro.getRoomNameByDeviceID(tfID))
--print(" >> Name = ",fibaro.getName(tfID))
end
end
return dasistoffen
end --TuerFenZu()
------------------------------------------------------------------------------------
------------------------------------------------------------------------------------
-- Funktion Alarmanlage scharfschalten
------------------------------------------------------------------------------------
--[[
Abfrage alle wichtigen Türen/Fenster geschlossen sonst werden diese im Alarmpannel angezeigt.
Bei geöffneten Türen/Fenstern lässt sich kein Alarm scharf schalten.
Nach Ablauf einer Zeit hier 20 Sek wird die Alarmanlage scharf.
--]]
function Alarmanlage_scharfschalten()
local starttime = 0
local timenow = 0
local offen_ist = ""
-- Kontrolle alle Türen und Fenster zu ?
-- Nur die die in der function TuerFenZu stehen
offen_ist = TuerFenZu()
if offen_ist ~= "" then -- noch was offen
starttime = os.time()
fibaro.call(bedienfeld,"Alarmhinweis_ausgeben","Nicht alles geschlossen")
fibaro.call(bedienfeld,"Alarm_ausgeben",offen_ist)
repeat
fibaro.call(stop_led_gruen,"turnOff")
fibaro.sleep(1000)
fibaro.call(bedienfeld,"Alarmhinweis_ausgeben","ACHTUNG")
fibaro.call(stop_led_gruen,"turnOn")
fibaro.sleep(1000)
fibaro.call(bedienfeld,"Alarmhinweis_ausgeben","Nicht alles geschlossen")
timenow = os.time()
print("Zeit = ",timenow - starttime)
until timenow - starttime >= 20 --Warten nach Start in Sekunden
fibaro.call(bedienfeld,"Alarmhinweis_ausgeben","Alarmanlage")
fibaro.call(bedienfeld,"Alarm_ausgeben","Alarmanlage endschärft")
elseif offen_ist == "" then -- alles geschlossen = ""?
--Scharf schalten
--print("Start scharfschalten = ", os.date("%H:%M", os.time()))
fibaro.call(stop_led_gruen,"turnOff")
starttime = os.time()
repeat
fibaro.call(start_led_rot,"turnOn")
fibaro.sleep(1000)
fibaro.call(start_led_rot,"turnOff")
fibaro.sleep(1000)
timenow = os.time()
until timenow - starttime == 300 --Warten nach Start in Sekunden
fibaro.call(start_led_rot,"turnOn")
Alarm_bereiche_scharf()
alarm = 0
alarm_etage_id = 0
alarm_etage_name = ""
alarm_device_id = 0
alarm_device_name = ""
print("Scharf = ", os.date("%H:%M", os.time()))
fibaro.call(bedienfeld,"Alarmhinweis_ausgeben","Alarmanlage")
fibaro.call(bedienfeld,"Alarm_ausgeben","Alarmanlage scharf")
-- Jetzt ist die Kiste Scharf
end
end --Alarmanlage_scharfschalten()
------------------------------------------------------------------------------------
------------------------------------------------------------------------------------
-- Funktion Alarmanlage unscharfschalten
------------------------------------------------------------------------------------
--[[
Unscharfschalten der Alarmanlage vorbereiten und Signalisieren
--]]
function Alarmanlage_uncharfschalten()
print("Stoptaster getriggert")
--Unscharf schalten & Alarm löschen
fibaro.call(stop_led_gruen,"turnOn")
fibaro.call(start_led_rot,"turnOff")
Alarm_bereiche_unscharf()
alarm = 0
alarm_etage_id = 0
alarm_etage_name = ""
alarm_device_id = 0
alarm_device_name = ""
fibaro.call(bedienfeld,"Alarmhinweis_ausgeben","Alarmanlage")
fibaro.call(bedienfeld,"Alarm_ausgeben","Alarmanlage endschärft")
print("Unscharf = ", os.date("%H:%M", os.time()))
-- Jetzt ist die Kiste Unscharf
end -- Alarmanlage_uncharfschalten()
------------------------------------------------------------------------------------
------------------------------------------------------------------------------------
-- Funktion Alarmanlage alarmmelden
------------------------------------------------------------------------------------
--[[
Bei einem Alarm wird festgestellt wo und diese Informationen könen ausgegeben werden.
Hier ist es auf dem Bedienfeld angezeigt.
sollte nach (Hier) 300Sek nicht gestoppt werden so beginnt der Radau.
Angezeit wird die Alarmierung über die Alarmbedientafel.
--]]
function Alarmanlage_alarmmelden()
print("Hausalarm getriggert")
-- Alarmanlage meldet Alarm
-- feststellen wo der Alarm herkommt
print("Es wurde alarm ausgelöst")
local alarm,alarm_etage_id,alarm_etage_name,alarm_device_id,alarm_device_name = Frage_Alarm_wo()
--Alarmdaten anzeigen
print("Alarm da ? = ",alarm, "Uhrzeit = ", os.date("%H:%M", os.time()))
print("Alarm-Bereich ID = ",alarm_etage_id)
print("Alarm-Bereich Name =",alarm_etage_name)
print("Alarm_Device ID = ",alarm_device_id)
print("Alarm_Device Name = ",alarm_device_name)
local alarmdaten = "Uhrzeit = " + os.date("%H:%M", os.time())
+ alarm_etage_name + alarm_device_name
fibaro.call(bedienfeld,"Alarmhinweis_ausgeben","Alarmanlage")
fibaro.call(bedienfeld,"Alarm_ausgeben",alarmdaten)
starttime = os.time()
fibaro.call(start_led_rot,"turnOff")
repeat --Rote und grüne LED blinken lassen
fibaro.call(start_led_rot,"turnOn")
fibaro.call(stop_led_gruen,"turnOn")
fibaro.sleep(1000)
fibaro.call(start_led_rot,"turnOff")
fibaro.call(stop_led_gruen,"turnOff")
fibaro.sleep(1000)
timenow = os.time()
until timenow - starttime == 300 --Warten nach Start in Sekunden
fibaro.call(start_led_rot,"turnOn")
fibaro.call(stop_led_gruen,"turnOn")
--Jetzt geht der Alarm los
end --Alarmanlage_alarmmelden()
------------------------------------------------------------------------------------
------------------------------------------------------------------------------------
---------------------------------- Hauptprogramm -----------------------------------
------------------------------------------------------------------------------------
--Woher kommt der Trigger und wie soll reagiert werden
if (json.encode(sourceTrigger.property) == '"execute"') then
-- print('Szene manuell ausgeführt - UserID: ' ..json.encode(sourceTrigger.id))
-- Alarmaktion Manuel nicht vorgesehen !
elseif json.encode(sourceTrigger.id) == tostring(starttaster) then -- Starttaste hat getriggert
Alarmanlage_scharfschalten()
elseif fibaro.getValue(bedienfeld,"value") == 3.0 then -- Bedienfeld Starttaste hat getriggert
Alarmanlage_scharfschalten()
elseif json.encode(sourceTrigger.id) == tostring(stoptaster) then --Stoptaste hat getriggert
Alarmanlage_uncharfschalten()
elseif fibaro.getValue(bedienfeld,"value") == 4.0 then --Bedienfeld Stoptaste hat getriggert
Alarmanlage_uncharfschalten()
elseif json.encode(sourceTrigger.id) == "null" then --Hausalarm hat getriggert
Alarmanlage_alarmmelden()
end
------------------------------------------------------------------------------------
------------------------------------------------------------------------------------
--Locale Variablen übergeben
fibaro.setGlobalVariable("Alarm",tostring(alarm))
fibaro.setGlobalVariable("Alarm_Etage_ID",tostring(alarm_etage__id))
fibaro.setGlobalVariable("Alarm_Etage_Name",alarm_etage_name)
fibaro.setGlobalVariable("Alarm_Device_ID",tostring(alarm_device_id))
fibaro.setGlobalVariable("Alarm_Device_Name",alarm_device_name)
Wau ich hätte nicht gedacht das das mit einer Mess geht.
1 „Gefällt mir“
Zu dem Allen um es besser zu verstehen gehören noch Das Tasten und Bedienfeld !
Das sieht so aus mit ei2 x SmartImplant drin.
Und den QA für Bedienung und Sirenen.
Sirenen-fqa.txt (18,9 KB) Bedienfeld-fqa.txt (7,4 KB)
Die beiden Datein umbennenen in Bedienfeld.fqa und Sirenen.fqa dann könnt Ihr die laden.
So nun viel Spaas mit dem durchschauen von dem was ich verzapft habe.
Ist sicherlich nicht alles Optimal aber es läuft und funktioniert wunderbar.
Ist hoffentlich leicht zu verstehen sonst einfach fragen.
Wenn einer eine Verbesserung hat immer her damit aber vorher bitte testen !
So zum Schluß noch Fenster-/Tür auf und Heizkörper runterregeln.
Trigger
…
--[[
Heizkörpersteuerung bei Tür und oder Fenster auf
Bei offenen Tür oder Fenster wird der Heizkörper nach 5min auf 8°C abgeregelt.
Wird das Fenster und oder Tür wieder geschlossen wird der Normale Heizplan wieder aktiviert
wird von der Main Szene gestartet
--]]
…
Aktion
…
--[[
Globale Variablen
Für die einzelnen Heizkreise
Bezeichnung Global-Variable ID des Heizkreises
------------------------------------------------------------------
Dachgeschoss WII Zimmer Heiz_DG_WII 2
Dachgeschoss Noras Zimmer Heiz_DG_Noras 3
Dachgeschoss Sonjas Zimmer Heiz_DG_Sonjas 4
Dachgeschoss Badezimmer Heiz_DG_Bad 8
Erdgeschoss Flur Heiz_EG_Flur 5
Erdgeschoss Toilette Heiz_EG_Toil 6
Erdgeschoss Computerraum Heiz_EG_Comp 7
Erdgeschoss Küche Heiz_EG_Kueche 10
Erdgeschoss Esszimmer Heiz_EG_Essz 11
Erdgeschoss Wohnzimmer Heiz_EG_Wohnz 12
Kellergeschoss Wohnzimmer Heiz_KG_Wohnz 13
Kellergeschoss Kueche Heiz_KG_Kueche 14
Kellergeschoss Eingang Heiz_KG_Eing 15
--]]
---------------------------------------------------------------------------------------
--------------- Funcition Tür zu, Fenster zu sonst Heizung runterregeln ---------------
-- Solte es eine Tür oder ein Fenster nicht geben, so das Feld mit 0 oder "" besetzen.
-- Beispiel hzone_tuer_fenster(Z_1,168,210,"",12)
-- Z_1 = Globale Zählvariabel der jeweiligen Heizzohne (String)
-- 168 = ID des Türkontaktes
-- 210 = ID des Fenster1 Kontaktes
-- "" = Platzhalter für 2. Fenster
-- 12 = ID der Heizzohne
---------------------------------------------------------------------------------------
function hzone_tuer_fenster(v_global,tuer,fenster1,fenster2,zone_id)
local z_fenster1 = false
local z_fenster2 = false
local z_tuer = false
-- Zählvariabel Global nach Local holen
local v_local = tonumber(fibaro.getGlobalVariable(v_global))
--Gibt es ein Fenster1 oder nicht
if fenster1 == 0 or fenster1 == "" then
z_fenster1 = false
else
z_fenster1 = fibaro.getValue(tonumber(fenster1), "value")
end
--Gibt es ein Fenster2 oder nicht
if fenster2 == 0 or fenster2 == "" then
z_fenster2 = false
else
z_fenster2 = fibaro.getValue(tonumber(fenster2), "value")
end
--Gibt es eine Tür oder nicht
if tuer == 0 or tuer == "" then
z_tuer = false
else
z_tuer = fibaro.getValue(tonumber(tuer), "value")
end
--print(" zustand in Reihenfolge ",v_local," ",z_tuer, " ", z_fenster1, " ", z_fenster2)
if v_local > 0 or (z_tuer == true) or (z_fenster1 == true) or (fenster2 == true) then
--print("Los gehts Tür, Fenster1 oder Fenster2 ist auf")
v_local = v_local + 1
--print("Öffnungszeit in Minuten = ",v_local)
end
if v_local == 6 then -- 5min
--print("Heizplan ", zone_id ," auf 8°C")
fibaro.homeCenter.climate.setClimateZoneToManualMode(tonumber(zone_id), 'Heat',"Hold", 8, nil)
end
if (z_tuer == false) and (z_fenster1 == false) and (z_fenster2 == false) and (v_local ~= 0) then
--print("Heizplan ",zone_id ," wieder aktivieren")
fibaro.homeCenter.climate.setClimateZoneToScheduleMode(tonumber(zone_id))
v_local = 0
end
--Zählvariabel Local auf Global zurückschreiben
fibaro.setGlobalVariable(v_global,tostring(v_local))
end --function
------------------------------------------------------------------------------------
---------------------------------- Hauptprogramm -----------------------------------
------------------------------------------------------------------------------------
--print("Start Heiz-F.oT.Steuerung")
-----------------------------------------------------------------------------
hzone_tuer_fenster("Heiz_DG_WII",143,148,0,2) --Dachgeschoss WII-Zimmer
-----------------------------------------------------------------------------
hzone_tuer_fenster("Heiz_DG_Noras",0,158,0,3) --Dachgeschoss Noras-Zimmer
-----------------------------------------------------------------------------
hzone_tuer_fenster("Heiz_DG_Sonjas",134,472,0,4) --Dachgeschoss Sonjas-Zimmer
-----------------------------------------------------------------------------
hzone_tuer_fenster("Heiz_DG_Bad",110,113,0,8) --Dachgeschoss Badezimmer
-----------------------------------------------------------------------------
hzone_tuer_fenster("Heiz_EG_Flur",544,0,0,5) --Erdgeschoss Flur zur Garage
-----------------------------------------------------------------------------
hzone_tuer_fenster("Heiz_EG_Toil",0,65,0,6) --Erdgeschoss Toilette
-----------------------------------------------------------------------------
hzone_tuer_fenster("Heiz_EG_Comp",0,539,0,7) --Erdgeschoss Computerraum
-----------------------------------------------------------------------------
hzone_tuer_fenster("Heiz_EG_Kueche",0,202,0,10) --Erdgeschoss Küche
-----------------------------------------------------------------------------
hzone_tuer_fenster("Heiz_EG_Essz",0,213,243,11) --Erdgeschoss Esszimmer
-----------------------------------------------------------------------------
hzone_tuer_fenster("Heiz_EG_Wohnz",0,213,243,12) --Erdgeschoss Wohnzimmer
-----------------------------------------------------------------------------
hzone_tuer_fenster("Heiz_KG_Eing",344,0,0,15) --Kellergeschoss Eingang
-----------------------------------------------------------------------------
hzone_tuer_fenster("Heiz_KG_Kueche",0,350,0,14) --Kellergeschoss Küche
-----------------------------------------------------------------------------
hzone_tuer_fenster("Heiz_KG_Wohnz",313,321,0,13) --Kellergeschoss Wohnzimmer
…
Grüße aus dem Sauerland
Frank
Hallo Frank,
Vielen Dank für das bereitwillige Teilen deiner Skripte. Habe mir jetzt alle mal runtergeladen und werde sie in meiner HC3 ansehen & testen!
Habe auch die beiden QA runtergeladen. Kann das Sirenen.fqa nicht importieren, da kommt ein Fehler (siehe Anhang)
Das Bedienfeld.fqa hat geklappt!
So, habe jetzt wieder etwas Zeit um mich dem CronJob zu widmen
Habe jetzt mal alle Skripte von dir @Berges01 durchgesehen. Soweit ich es verstanden hab sind die sehr individuell auf DICH zugeschnitten! Daher hab ich beschlossen doch eine eigene CronJob Szene zu entwickeln, die etwas universeller genutzt werden kann.
Derzeit habe ich folgendes:
{
conditions = {
{
type = "date",
property = "cron",
operator = "match",
value = {"*", "*", "*", "*", "*", "*"},
isTrigger = true
}
},
operator = "all"
}
Läuft und schreibt mir jede Minute einen Debug ins Fenster, soweit SUPERl!
Bei der Entwicklung des CronJob für die HC2 die hier im Forum dokumentiert ist
war eine Vorgabe, dass der CronJob alle 15 Sekunden gestartet wird!
Grund dafür ist, dass im weiteren Code die Uhrzeit auf Minuten abgefragt wird. Damit das auch über Minuten Grenzen zuverlässig funktioniert ist diese Taktung WICHTIG!
Ich setze voraus dass die HC3 kein Problem mit dieser „Last“ hat, wenn es auf meiner HC2 seit vielen Monaten zuverlässig läuft
Wo ich noch Hilfe brauche ist:
- Wie kann ich die oben angeführte Szene statt jede Mintue alle 15 Sek starten?
Was ich auch noch rausfinden möchte:
- Wie muss ich den Code aus der HC2 umschreiben, damit die entsprechenden Variablen richtig gefüllt werden?
function DT(DATETIME)
local WD = {'Sonntag','Montag','Dienstag','Mittwoch','Donnerstag','Freitag','Samstag'}
local M = {'Januar','Februar','März','April','Mai','Juni','Juli','August','September','Oktober','November','Dezember'}
local tableDT= (os.date('*t', tonumber(DATETIME)))
tableDT.month = M[tonumber(tableDT.month)]
tableDT.wday = WD[tonumber(tableDT.wday)]
now_sec = (tableDT.sec)
now_min = os.date("%M", timestamp)
now_hour = os.date("%H", timestamp)
now_day = os.date("%d", timestamp)
now_day_long = (tableDT.wday)
now_month = os.date("%m", timestamp)
now_month_long = (tableDT.month)
now_year = (tableDT.year)
now_date_long = (tableDT.wday ..' - ' ..tableDT.day ..'. ' ..tableDT.month ..' ' ..tableDT.year ..' ')
if now_day_long == "Montag" or now_day_long == "Dienstag" or now_day_long == "Mittwoch" or now_day_long == "Donnerstag" or now_day_long == "Freitag" then
now_week_state = "Wochentag"
elseif now_day_long == "Samstag" or now_day_long == "Sonntag" then
now_week_state = "Wochenende"
else
now_week_state = "falsch"
end
end
Kann mir da jemand Tipps geben?
Oder gibt es dafür eine Doku, die ich bis jetzt nicht gefunden hab?
Da es hier leider relativ ruhig war, hab ich mal selber geforscht und meine erste Version des CronJob entworfen.
Ziel ist es EIN Skript zu haben, wo alle zeitlichen Abläufe zusammengefasst laufen und administriert werden können.
Bitte seht das als Beispiel!!
Sollte jemand eine elegantere Möglichkeit gefunden haben, die in der HC3 besser oder sinnvoller läuft, oder Verbesserungsvorschläge haben, freue ich mich über einen Kommentar.
Um es vollständig zu testen müsst ihr folgende Variablen anlegen
- DayState - zum Speichertn der Tageszeit als Text (Morgen, Abend u.s.w)
- TimeSek - speichert die Zeit in Minuten für die Ausfallmeldung nach dem Start
- SunriseTime
- SunsetTime
Hier nun der Code, ist natürlich beliebig erweiterbar:
---DECLARATIONS
{
conditions = {
{
type = "se-start",
property = "start",
operator = "==",
value = true,
isTrigger = true
},
{
type = "date",
property = "cron",
operator = "match",
value = {"*", "*", "*", "*", "*", "*"},
isTrigger = true
}
},
operator = "any"
}
-- ACTION
function DT() -- setzt alle nötigen Zeitvariablen
now_hour = os.date("%H")-- Stunde (00-23)
now_min = os.date("%M") -- Minute (00-59)
now_sec = os.date("%S") -- Sekunde (00-59)
now_day = os.date("%d") -- Tag (01-31)
-- Wochentag in deutsch
local now_Wday = tonumber(os.date("%w", os.time()))+1 --+1 weil Sonntag =0 ist
local WD = {'Sonntag','Montag','Dienstag','Mittwoch','Donnerstag','Freitag','Samstag'}
now_day_long = (WD[now_Wday]) -- aktueller Wochentag
-- Monatsname in deutsch
local MNow = tonumber(os.date("%m", os.time()))
local MON = {'Jänner','Februar','März','April','Mail','Juni','Juli','August','September','Oktober','November','Dezember'}
now_month_long = (MON[MNow])
now_year = os.date("%Y")
now_date_long = (now_day_long..', '..now_day..'.'..now_month_long..' ' ..now_year)
end
---------------------------------------------- Start des Minuten Moduls ----------------------------------------------
function MinuteFunc()
DT()
gDayState = fibaro.getGlobalVariable("DayState")
---------------------------------------------------------------------- jede Minute ---------------------------------
--HC3 schreibt jede Minute die Zeit in Minuten in die Variable TimeSek
gTimeSek = os.date("%H", os.time()) *60 + os.date("%M", os.time())
fibaro.setGlobalVariable("TimeSek", string.format("%.0f",gTimeSek))
---------------------------------------------------------------------- Intervall Skripte, alle xx Minuten----------
-- Beispiel alle 3 Minutengeht auch mit anderen Minutenwerten von 2-60 Min
if now_min%3==0 then
print("alle 3 Minuten")
end
--------------------------------------------- 0:40 Uhr setzt Sonnenaufgang Variablen ------------------------------
if now_hour == '00' and now_min == '40' then
sunrise=fibaro.getValue(1, "sunriseHour")
sunset=fibaro.getValue(1, "sunsetHour")
fibaro.setGlobalVariable("SunriseTime", sunrise)
fibaro.setGlobalVariable("SunsetTime", sunset)
end
--------------------------------------------- wenn Sonnenaufgang ---------------------------------------------------
if string.format("%02d", now_hour) .. ":" .. string.format("%02d", now_min) == sunrise then
fibaro.setGlobalVariable("DayState", "Morning")
end
----------------------------------------- täglich um 8:30 Uhr --------------------------------------------------------
if now_hour == '08' and now_min == '30' then
fibaro.setGlobalVariable("DayState", "Day")
end
--------------------------------------------- wenn Sonnenuntergang ---------------------------------------------------
if string.format("%02d", now_hour) .. ":" .. string.format("%02d", now_min) == sunset then
fibaro.setGlobalVariable("DayState", "Evening")
end
----------------------------------------- täglich um 23:59 Uhr --------------------------------------------------------
if now_hour == '23' and now_min == '59' then
fibaro.setGlobalVariable("DayState", "Night")
end
end ------------------------------------------ ENDE der Schleife MinuteFunc() -----------------------------------------
if json.encode(sourceTrigger.property) == '"cron"' then
MinuteFunc()
elseif json.encode(sourceTrigger.property) == '"start"' then
-- Schickt ein Email wie lange die HC3 offline war
gTimeSek = os.date("%H", os.time()) *60 + os.date("%M", os.time())
print ("HC3 wurde gerade neu gestartet, war "..string.format("%.0f",gTimeSek - (fibaro.getGlobalVariable("TimeSek"))).. " Minuten(n) außer Betrieb")
fibaro.alert("email", {2},"HC3 wurde gerade neu gestartet, war "..string.format("%.0f",gTimeSek - (fibaro.getGlobalVariable("TimeSek"))).. " Minuten(n) außer Betrieb")
end
Viel Spass beim Testen…
2 „Gefällt mir“
Hallo pblacky,
kann ich in den Blöcken auch eine Lux/TurnOn Geschichte einbauen und wenn ja mit welchen Befehlen?
Danke & Gruss
Sorry @fische02, der Emailreminder hat mir keine Nachricht geschickt, daher habe ich deinen Kommentar erst jetzt zufällig entdeckt.
Du kannst in dem CronJob grundsätzlich zu JEDER Zeit irgendwas ausführen lassen.
Dazu musst du einfach einen neuen Block mit der entsprechenden Uhrzeit einbauen und fertig.
Beispiel für 8:30 Uhr:
if now_hour == '08' and now_min == '30' then
--dein Befehl wird um 8:30 Uhr ausgeführt
end