Alarmpanel

Die Szene für den Alarmpanel ist der Hammer und funktioniert soweit sehr gut. Nun habe ich vier Sirenen im Haus, bei Alarmauslösung blinken drei nur und bei einer ertönt der Alarm. Gerne möchte ich die Sirene mit dem Alarm etwas verzögert schalten, wie könnte ich hier vorgehen?
Bin für jede Hilfe dankbar…
Gruss fastsnake

--[[
%% properties
%% value
%% events
%% globals
--]]

-- Einstellungen für die Sensoren (Zwingend erforderlich)
local sensorID = {28,101,134,165,182,118,222,226,230,234,244,247} -- ID der Sensoren(n)

-- Einstellungen für die Sirene(n) (Wenn keine IDs eingetragen sind, wird die Funktion nicht genutzt)
local sireneID = {8,23,115,132} -- ID der Sirene(n)

-- Einstellungen für Push-Benachrichtigungen (Wenn keine IDs eingetragen sind, wird die Funktion nicht genutzt)
local phoneID = {189,192} -- ID der Handys

-- soll ein stiller Alarm genutzt werden? (true = ja/false = nein; silent_alarm_time: Sekunden wie lang der stille Alarm bestehen soll)
-- hier werden die Sirenen/Licht erst nach einer bestimmten Zeit aktiv. Bild der Kamera, Push und Meldung des Alarmpanels wird VOR dem stillen Alarm ausgeführt
local silent_alarm = false
local silent_alarm_time = 30

-- soll ein Bild der Kamera versendet werden (true = ja/false = nein)
local camera_support = false

-- an welche Mail soll ein Bild der Kamera gesendet werden
local email = 'MAIL'

-- Einstellungen für RGBW-Notfallbeleuchtung (Wenn keine IDs eingetragen sind, wird die Funktion nicht genutzt)
local rgbwID = {} -- ID RGBW
local mode = 'programm' -- Auswahl: color = Farbwert setzen; programm = Programm starten
local programm = 5 
local color = '255,255,255,255' -- welche Farbe eingestellt werden soll

-- Sollen eigene Aktionen ausgeführt werden? (true = ja/false = nein; Bei true müssen die beiden nächsten Funktionen befüllt werden)
local own_action = true

function ownaction_alarm()
    local switel = 214
    local licht = 128

    
    fibaro:call(switel, "sendPush",os.date("Einbruchalarm!"));

 -- Licht einschalten wenn benötigt

 if fibaro:getGlobalValue("Tageslicht") == "Dunkel"
and (tonumber(fibaro:getValue(licht, "value")) < 1) 

then
    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)]
    return ""..tableDT.wday ..', ' ..tableDT.day ..'. ' ..tableDT.month ..' ' ..tableDT.year ..' '..os.date " / %H:%M Uhr" 
end 
    x= DT(os.date())
    fibaro:debug (x) 
  
	fibaro:call(licht, "turnOn");
    --fibaro:debug("----------------------------------------------------------------------------------------------------");      
    Debug("yellow",(os.date("Es ist dunkel")));   
    Debug("yellow",(os.date("Licht wurde mit Alarm eingeschaltet..!"))); 
    fibaro:debug("----------------------------------------------------------------------------------------------------");      
	
 end

    fibaro:debug('Eigene Aktionen bei Alarm ausgeführt')
end

function ownaction_afteralarm()

-- Restart Autoszenen   
---------------------------------------------------
--------- Schleifenschutz -------------------------
if  (fibaro:countScenes()>2) then
    fibaro:debug('Kill the third scene!');
    fibaro:abort();
end
 
---------------------------------------------------
------------- Config ------------------------------
    advDebug			= true
    version 			= 'v1.0'
 
---------------------------------------------------
--------- Farbiges Debug --------------------------
function debug( color, message )
	fibaro:debug(string.format('<%s style="color:%s;">%s<!--%s-->', "span", color, message, "span"));
end
 

---------------------------------------------------
--------- Farbiges Debug --------------------------
function getAutoScenes()
  --fibaro:sleep(180000); -- Zeit nach Alarm auslösung
	sceneData = api.get('/scenes')
	for i=1, #sceneData do
		if sceneData[i].autostart and sceneData[i].runConfig == "TRIGGER_AND_MANUAL" and sceneData[i] then
			debug('green','Autostart-Szene gefunden: '..sceneData[i].name..' (ID:'..sceneData[i].id..')')
			if sceneData[i].runningInstances == 0 then
				debug('red','Autostart-Szene wird nicht ausgeführt. Starte diese erneut.')
				if sceneData[i].maxRunningInstances ~= 1 then sceneData[i].maxRunningInstances = 1 else sceneData[i].maxRunningInstances = 2 end
				api.put('/scenes/'..sceneData[i].id, sceneData[i])
			end
		end
	end
end
 
getAutoScenes()
  fibaro:debug('Eigene Aktionen nach dem Alarm ausgeführt')
end

local countID = 500

-- AB HIER NICHTS MEHR ÄNDERN

Debug = function ( color, message )
  fibaro:debug(string.format('<%s style="color:%s;">%s</%s>', "span", color, message, "span"))
end

-- Funktion zum Versenden der Push
function sendPush(text)
 if (phoneID[1] ~= nil) then
  for k=1, countID do
     if phoneID[k] ~= nil then
       fibaro:call(phoneID[k],'sendPush', text, 'alarm')
     end
  end
 end
end

-- Funktion zum Ein-/Ausschalten der Sirene
function onoffSirene(status)
 if (sireneID[1] ~= nil) then 
  if (status) then
   fibaro:debug('Sirenen einschalten')
   for a=1, countID do
     if sireneID[a] ~= nil then
       fibaro:call(sireneID[a],'turnOn')
     end
   end
  else
   if (sireneID[1] ~= nil) then  
    fibaro:debug('Sirenen ausschalten')
    for a=1, countID do
      if sireneID[a] ~= nil then
        fibaro:call(sireneID[a],'turnOff')
      end
    end
   end
  end
 end
end

-- Funktion zum Ein-/Ausschalten der RGBW-Notfallbeleuchtung
function emergencyRGBW(status)
 if (rgbwID[1] ~= nil) then 
  if (status) then
   if (mode == 'color') then 
    fibaro:debug('RGBW-Notfallbeleuchtung einschalten - Setze Farbe')
    local RGBWTable = {}
    local i = 1
    for value in string.gmatch(color,"(%d+)") do
     RGBWTable[i] = value
     i = i + 1
    end
    for o=1, countID do
      if rgbwID[o] ~= nil then
        fibaro:call(rgbwID[o], "setColor", RGBWTable[1], RGBWTable[2], RGBWTable[3], RGBWTable[4])
      end
    end
   elseif (mode == 'programm') then
    fibaro:debug('RGBW-Notfallbeleuchtung einschalten - Starte Programm')
    for o=1, countID do
     if rgbwID[o] ~= nil then
       fibaro:call(rgbwID[o], 'startProgram', programm)
     end
    end
   end 
  else
   if (rgbwID[1] ~= nil) then 
    fibaro:debug('RGBW-Notfallbeleuchtung ausschalten')
    for o=1, countID do
      if rgbwID[o] ~= nil then
        fibaro:call(rgbwID[o], "setColor", 255,0,0,0)
      end
    end 
   end
  end
 end
end

function cameracheck(roomID)
  for x=1, countID do
    if (fibaro:getType(x) == 'com.fibaro.ipCamera') then
      if (roomID == fibaro:getRoomID(x)) then
        fibaro:debug('Kamera ' ..x.. ' im betroffenen Raum erkannt. Sende Mail an ' ..email)
        fibaro:call(x, 'sendPhotoToEmail', email)
      else
        fibaro:debug('Keine Kamera im betroffenden Raum gefunden.')
      end
    end
  end
end

function checkSensor()
  for j=1, countID do
    if sensorID[j] ~= nil then
      if (tonumber(fibaro:getValue(sensorID[j], 'value')) == 1) then
         return sensorID[j]
      end
    end
  end
end

function checkSensorArmed()
  local armed_counter = 0 
  for j=1, countID do
    if sensorID[j] ~= nil then
      if (tonumber(fibaro:getValue(sensorID[j], 'armed')) == 1) then
         armed_counter = armed_counter+1
      end
    end
  end
  if (armed_counter == 0) then
   return false
  elseif (armed_counter > 0) then
   fibaro:debug(armed_counter..' Sensoren noch nicht entschärft ...')
   return true
 end
end
Debug( 'red', '___________________________')
Debug( 'red', 'Alarm-Szene 2.0 wurde ausgelöst.')
Debug( 'white', 'Aktionen werden ausgeführt.')
Debug( 'white', 'Sensor im Raum ' ..fibaro:getRoomNameByDeviceID(checkSensor()).. ' ausgelöst')
sendPush('Achtung! EINBRUCH-ALARM ausgelöst!')

if camera_support then
  cameracheck(fibaro:getRoomID(checkSensor()))
else
  Debug( 'red', 'Keine Kameras im Einsatz')
end

if silent_alarm then
  fibaro:debug('Stiller Alarm wurde aktiviert. Dauer: ' ..silent_alarm_time)
  counter = 0
  while (counter <= silent_alarm_time and checkSensorArmed()) do
   counter = counter + 1
   fibaro:sleep(1*1000)
  end
else
  Debug( 'white', 'Stiller Alarm wird nicht genutzt.')
end
if checkSensorArmed() then
  if (own_action) then
    ownaction_alarm()
  end
  onoffSirene(true)
  emergencyRGBW(true)
elseif silent_alarm then
  Debug('green', 'Stiller Alarm beendet, Geräte entschärft.')
end

while checkSensorArmed() do
  Debug( 'red', 'Alarm weiterhin ausgelöst.')
  fibaro:sleep(2*1000)
end
fibaro:debug('Alle Sensoren entschärft.')
Debug('green', 'Alarm wurde beendet.')
sendPush('Alarm AUSGESCHALTET!')
  if (own_action) then
    ownaction_afteralarm()
  end
emergencyRGBW(false)
onoffSirene(false)

An der Sirene können keine Einstellungen zur Verzögerung vorgenommen werden!

Einfach silent_alarm auf true setzen. Die Zeit kann man eine Zeile tiefer einstellen.

Hi,

woher kommt denn das Script?

Grüße
gringo

Hallo gringo1
Das Script findest Du hier http://siio.de/sicherheitalarm/so-nutzt-du-das-fibaro-alarmpanel-des-homecenters/

Hi jeep
Vielen Dank für Deine rasche Antwort, ich möchte bei Alarmauslösung die ersten 10 Sekunden nur die Blinker einschalten und erst danach
die Sirene!
Wenn ich auf Silent Alarm stelle, geht der ganze Alarm (also Sirene und Blinker)nach der eingestellten Zeit los.
Gruss fastsnake

Muss noch ergänzen, habe drei der Sirenen so konfiguriert dass diese nur Blinken (ohne Ton).
Diese drei möchte ich bei Alarmauslösung eingeschaltet haben (klappt auch sehr gut)
Nach einer gewissen Verzögerung, sollte dann die vierte Sirene mit Ton dazugeschaltet werden.

OK, eine Möglichkeit von vielen wäre diese:

-- Funktion zum Ein-/Ausschalten der Sirene
function onoffSirene(status)
 if (sireneID[1] ~= nil) then 
   if (status) then
     fibaro:debug('Sirenen einschalten')
     for a=1, #sireneID do
       if sireneID[a] ~= nil then
         fibaro:call(sireneID[a],'turnOn')
	     if a ==3 then
	       fibaro:sleep(10 x 1000) -- 10 Sek. warten dann 4.te Sirene ein
	     end 	  
       end
     end
  else
   if (sireneID[1] ~= nil) then  
    fibaro:debug('Sirenen ausschalten')
    for a=1, #sireneID do
      if sireneID[a] ~= nil then
        fibaro:call(sireneID[a],'turnOff')
      end
    end
   end
  end
 end
end

Die Funktion onOffSirene(status) durch diese Funktion ersetzen.
Wichtig: Die Sirene die Krach machen soll muss als letzte in der Liste der Sirenen stehen.
local sireneID = {8,23,115,132} – ID der Sirene(n) – Die 132 sollte die mit Ton sein.
Kann’s leider nicht testen da ich nur eine Sirene habe.

Hi Jeep
Endlich komme ich dazu mich bei Dir für Deinen Einsatz zu bedanken! Habe das Script getestet, es funktioniert
sehr gut :slight_smile: Möchte mich an dieser Stelle bei allen, die in diesem Forum mit ihrem unermüdlichen Einsatz den
LUA Anfänger wie ich einer bin, mit ihrem kompetenten Fachwissen zur Seite stehen.
Habe schon einige Szenen dank eurer Hilfe, nach meinen Bedürfnissen angepasst bekommen.
Also ist es mehr als nur Angebracht auch einmal DANKE zu sagen, ich schätze dieses Forum sehr!!

Gruss fastsnake

Hallo zusammen
Nachdem mir Jeep so super weiter geholfen hat, taucht in einer weiteren Szene ein ähnliches Problem auf. Die Szene schaltet bei Abwesenheit das Licht zufällig ein und aus, klappt sehr gut! Nun mein Anliegen, wenn ich nach Hause komme und der Global Status auf Anwesend schaltet, geht das Zufallslicht aus.
Super wäre wenn die Lampe 128 (Wohnzimmer) zufällig leuchtet und der Status auf Anwesenheit wechselt, dass diese nicht ausgeschaltet wird.
Bin für jede Hilfe dankbar…
Gruss fastsnake


--[[
%% properties
%% globals
AnwesenheitsCheck
--]]

local currentDate   = os.date("*t");
local nachtstart    = 1600
local nachtende     = 0200
local handy_willi   = 189
---------------------------------------------------
--------- Schleifenschutz -------------------------

if (fibaro:countScenes()>1) then
--fibaro:debug('Kill the second scene!');
fibaro:abort();
end

-----------------------------------
---------- Einstellungen ----------
varDebug 			 = true 									-- Debug logs true oder false

gVarPresentState	 = 'AnwesenheitsCheck' 						-- Name der globalen Variable für An- und Abwesenheit
gVarLightOfDay		 = 'Tageslicht'							-- Name der globalen Variable für Tageslicht
gVarLightOfDayValues = {'Dunkel'}	-- Zu welchen Tageszeiten sollen Lichtquellen geschaltet werden
randomTimeMin		 = {3,55}									-- Zufallsminuten von bis {1,2} min, max
secondsNext			 = 90									-- x Sekunden warten bis das nächste Gerät geschaltet wird
simDevices 			 = {10,14,128, {}, {},} -- Geräteauswahl (Mitte Virtuell)
version				 = '1.0'

--------------------------------
---------- Funktionen ----------

---------------------------------------------------
--------- Farbiges Debug --------------------------
       function debug(color, message) 
	   if (varDebug) then 
	   --fibaro:debug(message) 
	   fibaro:debug(string.format('<%s style="color:%s;">%s</%s>', "span", color, message, "span"));
end
end

       ---------------------------------------------------
       ------------- waitFunction ------------------------
       -- Warte x Sekunden
       ---------------------------------------------------
       function waitFunction(sec, text)
	   while sec > 0 do
	   if sec % 10 == 0 then debug('cyan','Noch '..sec..' Sekunden '..text) end
	    sec = sec -1
	   if fibaro:getGlobal(gVarPresentState) ~= 'Abwesend'    
       then
       break;
end
	   fibaro:sleep(1000)
end
end

       ---------------------------------------------------
       ------------- radomDevice -------------------------
       -- Zufallsgerät ermitteln
       ---------------------------------------------------
       function switchRandDevice()
	   --Zufallsgerät aus deviceIDs ermitteln
       math.randomseed(os.time ())
	   randomLight = math.random(1,#simDevices)
	   randomTime = math.random(randomTimeMin[1],randomTimeMin[2]) * 60
	   deviceID = simDevices[randomLight]
	
	   if type(deviceID) == 'table' then		
	   if #deviceID == 3 then
	   debug('green','Virtuelles Device: '..fibaro:getName(deviceID[1])..' in '..fibaro:getRoomNameByDeviceID(deviceID[1])..'. Drücke Button für '..randomTime..' Sekunden.')
	   fibaro:call(deviceID[1], "pressButton", deviceID[2])
	   waitFunction(randomTime, 'bis '..fibaro:getName(deviceID[1])..' ausgeschaltet wird')
	   fibaro:call(deviceID[1], "pressButton", deviceID[3])
		
elseif 
       #deviceID == 4 then
	   debug('green','Virtuelles Device: '..fibaro:getName(deviceID[1])..' in '..fibaro:getRoomNameByDeviceID(deviceID[1])..'. Setze Slider für '..randomTime..' Sekunden.')
	   fibaro:call(deviceID[1], "setSlider", deviceID[2], deviceID[3])
	   waitFunction(randomTime, 'bis '..fibaro:getName(deviceID[1])..' ausgeschaltet wird')
	   fibaro:call(deviceID[1], "setSlider", deviceID[2], deviceID[4])
end
else        
       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)]
       return ""..tableDT.wday ..', ' ..tableDT.day ..'. ' ..tableDT.month ..' ' ..tableDT.year ..' '..os.date " / %H:%M Uhr" 
       end 
       x= DT(os.date())
       fibaro:debug (x)
    
	   debug('yellow',''..fibaro:getName(deviceID)..' in '..fibaro:getRoomNameByDeviceID(deviceID)..'. Schalte es für '..randomTime..' Sekunden ein.')
	   fibaro:call(deviceID, "turnOn")
       debug("yellow","Licht eingeschaltet...");   

	   waitFunction(randomTime, 'bis '..fibaro:getName(deviceID)..' ausgeschaltet wird')

       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)]
       return ""..tableDT.wday ..', ' ..tableDT.day ..'. ' ..tableDT.month ..' ' ..tableDT.year ..' '..os.date " / %H:%M Uhr" 
       end 
       x= DT(os.date())
       fibaro:debug (x)    
        
       fibaro:call(deviceID, "turnOff") -- Alle Lichter aus
       debug("gray","Licht ausgeschaltet...");
end
end
       ---------------------------------------------------
       ------------- Funktion checkDaytime ---------------
       function checkDaytime(tab, val)
       for index, value in ipairs (tab) do
	   if value == val then
	   return true
end
end
       return false
end
       ---------------------------------------------------
       ------------- START -----------------------------

       sourceTrigger = fibaro:getSourceTrigger()
       PresentState  = fibaro:getGlobalValue(gVarPresentState)
       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)]
       return ""..tableDT.wday ..', ' ..tableDT.day ..'. ' ..tableDT.month ..' ' ..tableDT.year ..' '..os.date " / %H:%M Uhr" 
       end 
       x= DT(os.date())
       fibaro:debug (x)

       debug("green","--------------------START--------------------------------")
       debug('green','Anwesenheitssimulator')
       fibaro:call(handy_willi, "sendPush",os.date("(%d.%m.%Y) Zufallslicht Abwesenheit um %H:%M Uhr AKTIVIERT!"));  

       if sourceTrigger["type"] == "autostart" then
	   debug('red','Dies ist keine Autostart-Szene. Bitte Autostart entfernen')
    
elseif 
  
       sourceTrigger["type"] == "global" then
	   debug('orange','Getriggert durch '..sourceTrigger['name'])

       if PresentState == 'Abwesend' --or PresentState == 'Holiday'
       then
	   --Start PresentSim
	   debug('green','Starte Simulation...')
	   while fibaro:getGlobal(gVarPresentState) == 'Abwesend' do
	   gVarDaytime = checkDaytime(gVarLightOfDayValues, fibaro:getGlobalValue('Tageslicht'))
        
      
	   if gVarDaytime 
       and (tonumber(os.date("%H%M")) >= nachtstart or tonumber(os.date("%H%M")) <= nachtende) then
       waitFunction(secondsNext, 'bis zum nächsten Schaltvorgang')
	   switchRandDevice()
            
else
	   debug('cyan','Tageszeit = '..fibaro:getGlobalValue('Tageszeit')..'')
       debug('gray','Lichtsensor meldet '..fibaro:getGlobalValue('Tageslicht')..'')
       debug('tan','Nicht alle Bedingungen erfüllt, Szene gestoppt!')
	   debug('red','Abwesenheitsimulation wird NICHT aktiviert!')
       waitFunction(secondsNext, 'bis zum nächsten Check')
end			
end
       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)]
       return ""..tableDT.wday ..', ' ..tableDT.day ..'. ' ..tableDT.month ..' ' ..tableDT.year ..' '..os.date " / %H:%M Uhr" 
       end 
       x= DT(os.date())
       fibaro:debug (x)     
    
	   debug('red','Simulation beendet.')  
else    
       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)]
       return ""..tableDT.wday ..', ' ..tableDT.day ..'. ' ..tableDT.month ..' ' ..tableDT.year ..' '..os.date " / %H:%M Uhr" 
       end 
       x= DT(os.date())
       fibaro:debug (x)  
    
	   --Stop PresentSim
       debug('orange','Anwesenheit festgestellt!')
	   debug('red','Ende der Simulation...')
end
    
elseif  
       sourceTrigger["type"] == "other" then
	   debug('yellow','Szene manuell gestartet')
end


@fastsnake,
mach bitte einen neuen Thread auf sonst passt dass hier nicht zum Alarmpanel. Eventuell habe ich eine Lösung für Dein Problem.

Hallo Leute,

kann mir mal jemand auf die Sprünge helfen. Wozu braucht man eigentlich das Alarmpanel? Ich kann ja alles in Lua realisieren. Geht es dabei nur um das Auswählen und Scharfschalten von Sensoren?
Wenn ich immer die gleichen Sensoren und automatisierte Abläufe habe brauche ich das Alarmpanel dann?