Cronjob für HC3

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 Like

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 :wink:

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 Like

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

1 Like

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 Like

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 Like

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 :wink:
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 :wink:

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 Like

Hallo pblacky,

kann ich in den Blöcken auch eine Lux/TurnOn Geschichte einbauen und wenn ja mit welchen Befehlen?

Danke & Gruss