Pushnachricht mit Device Name

Hallo,
wenn mein Alarm ausgelöst wurde möchte ich gerne in der Push Nachricht lesen, welcher Sensor ausgelöst hat. Aktuell sendet fibaro mir jeden sensor.

local Count = 0
for Index, Value in pairs( motionID ) do
Count = Count + 1
fibaro:call(Handychristoph, „sendPush“,os.date("(%d.%m.%Y) „…fibaro:getName(motionID[Count])…“ um %H:%M Uhr AKTIVIERT!"));
end

Wie bekomme ich das hin?

Hallo

Ich habe es bei meinem HC3 so gemacht das ich mir den Zustand aller an der Alarmanlage beteiligten Geräte gemerkt habe.
Dann bei einem Alarm habe ich geprüft welcher der Sensoren seinen Zustand verändert hat.
Damit bin ich universell da ich Sensoren rein oder raus nehmen kann per Alarmkonfiguration und die Sensoren Öffner oder Schließer sein können.
Ist aber nicht so mal eben gemacht und ist eine etwas aufwändigere Programmierung.
Was besseres viel mir aber nicht ein.
Wenn du möchtest kann ich dir das senden.
Gruß Frank

Weiss nicht ob ich das hin bekomme, aber versuchen kann ich es ja. Kannst du es hier schicken oder soll ich meine Mail schreiben?
Vielen Dank schonmal.

Ich versuche mal es hier zu Posten !
Deklaration

--[[
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)

Ist noch nicht komplett aber die Teile die du benötigst sind vorhanden !

Gruß Frank

Wow, das ist für mich zu schwierig. Du hast ja richtig viele Devices.
Das ist schon cool wenn man sich so gut damit aus kennt.
Ich gucke mal ob ich einige sachen raus kopieren kann.
Vielen Dank