Aller au contenu

Squelette de scène pour gérer l'éclairage


OJC

Messages recommandés

Bonsoir,

 

Je partage le squelette de scène que j'utilise pour domotiser mon éclairage, en espérant que cela pourra être utile.  Elle est conçue pour fonctionner avec des FGD-212.

 

Ce qu'elle peut faire en natif :

  • allumer l'éclairage à un niveau donné sur détection de mouvement et l'éteindre en l'absence de mouvement depuis un temps défini, avec une diminution préalable de luminosité paramétrable pour prévenir
  • allumer l'éclairage lorsque la luminosité (lux retournée par un FGMS-001 par exemple) descend sous un seuil donné ou, au contraire, éteindre si elle dépasse un seuil donné
  • bloquer l'allumage automatique pendant un laps de temps défini lorsque la lumière est éteinte via l'interrupteur avec retour au fonctionnement automatique en l'absence de mouvement dans ce délai

 

Elle peut également, ce qui implique de mettre les mains dans le cambouis, être actionnée via une variable globale ou l'utilisation de l'interrupteur (sceneActivation).

 

Les paramètres sont documentés dans la scène.

 

--[[
%% killOtherInstances
%% properties
%% events
%% globals
--]]

  
-- CONFIGURATION ------------------------------------------------------------
-----------------------------------------------------------------------------

function configure()

  _LIGHT    = -- id du FGD-212
  _LUX      = -- id du détecteur de luminosité
  _MOTION   = -- id du détecteur de mouvement

  brightness = {
    default  = 99 -- luminosité utilisée en cas de détection de mouvement ou de lux > minLux
  }

  minLux      = -1 -- luminosité en dessous de laquelle la lumière doit être allumée ; mettre -1 si pas utilisé
  maxLux      = -1 -- luminosité au dessus de laquelle la lumière doit être éteinte ; mettre -1 si pas utilisé
  
  fadeFactor  = 0.5 -- facteur de diminution de luminosité avant l extinction de la lumière
  
  fadeDelay   = 10 -- délai en secondes entre la baisse de luminosité et l extinction de la lumière
                   -- mettre -1 pour extinction immédiate et nil pour ne pas éteindre
  litDelay    = 60 * 3 -- délai en secondes pendant laquelle la lumière reste allumée après la fin de l alarme du détecteur de mouvement
  manOffDelay = 60 * 15 -- délai en secondes entre un arrêt de la lumière via l interrupteur et la reprise du fonctionnement automatique
                        -- (concerne uniquement le mouvement et la luminosité)

--  function G.XXXX  end  -- fonction exécutée quand la variable globale XXXX est utilisée comme trigger

--  function S.S1.on()  end -- fonctions exécutées avec le trigger sceneActivation
--  function S.S1.off()  end
--  function S.S1.hold()  end
--  function S.S1.release()  end
--  function S.S1.double()  end
--  function S.S1.single()  end
--  function S.S2.on()  end
--  function S.S2.off()  end
--  function S.S2.hold()  end
--  function S.S2.release()  end
--  function S.S2.double()  end
--  function S.S2.triple()  end
--  function S.S2.single()  end

end


-- VARIABLES ----------------------------------------------------------------
-----------------------------------------------------------------------------

_f            = fibaro
LM, G, S      = {}, {}, {S1 = {}, S2 = {}}
trigger       = _f:getSourceTrigger()
switch        = {}
switch["10"]  = {"S1", "on"}
switch["11"]  = {"S1", "off"}
switch["12"]  = {"S1", "hold"}
switch["13"]  = {"S1", "release"}
switch["14"]  = {"S1", "double"}
switch["16"]  = {"S1", "single"}
switch["20"]  = {"S2", "on"}
switch["21"]  = {"S2", "off"}
switch["22"]  = {"S2", "hold"}
switch["23"]  = {"S2", "release"}
switch["24"]  = {"S2", "double"}
switch["25"]  = {"S2", "triple"}
switch["26"]  = {"S2", "single"}


-- FUNCTIONS ----------------------------------------------------------------
-----------------------------------------------------------------------------

function LM.checkFading() if tonumber(LM.getGlobal("fading")) == 1 then minLux = -1; LM.setGlobal("fading", 0) end end
function LM.checkGlobal() if (type(_f:getGlobalValue("LightManager")) == "nil") then api.post("/globalVariables", {name="LightManager", isEnum=0}) end; local g = _f:getGlobalValue("LightManager"); if (tostring(g) == "") then g = "{}" end; g = json.decode(g); if (not g[tostring(__fibaroSceneId)]) then g[__fibaroSceneId] = {force = -1, fading = 0, manOff = 0}; _f:setGlobal("LightManager", json.encode(g)) end end
function LM.forceBrightness(v) if v >= 0 then _f:call(_LIGHT, "setValue", v) end; LM.setGlobal("force", v) end
function LM.getGlobal(i) local g = json.decode(_f:getGlobalValue("LightManager")); if type(i) == "nil" then return g else return g[tostring(__fibaroSceneId)][i] end end
function LM.getTimestamp(d) return _f:getModificationTime(d, "value") end
function LM.getValue(d) return tonumber(_f:getValue(d, "value")) end
function LM.iif(a,b,c) if a then return b else return c end end
function LM.isManOff() local n = tonumber(LM.getGlobal("manOff")); local bool = LM.getValue(_MOTION) == 0 and LM.getTimestamp(_MOTION) - manOffDelay >= n; if not (bool) and n ~= 0 then LM.setGlobal("manOff", 0) end; return bool end
function LM.isNumber(v) return type(tonumber(v)) == "number" end
function LM.isOff(d) return tonumber(LM.getValue(d)) == 0 end
function LM.setGlobal(i, v) local g = LM.getGlobal(); g[tostring(__fibaroSceneId)][i] = v; _f:setGlobal("LightManager", json.encode(g)) end
function LM.setLight(v) if LM.isNumber(v) then _f:call(_LIGHT, "setValue", v) else _f:call(_LIGHT, v) end end


function LM.luxManager()
  if LM.isOff(_LIGHT) then
    if LM.getValue(_MOTION) == 1 and LM.getValue(_LUX) < minLux then LM.setLight(brightness.default) end
  else
    if LM.getValue(_MOTION) == 1 and maxLux ~= -1 and LM.getValue(_LUX) > maxLux then LM.setLight(0) end
  end
end

function LM.motionManager()
  if LM.getValue(_MOTION) == 1 then
    local f = LM.getGlobal("force")
    if tonumber(f) ~= -1 then brightness.default = f end
    if minLux == -1 then
      if LM.getValue(_LIGHT) ~= brightness.default then LM.setLight(brightness.default) end
    else
      if LM.getValue(_LUX) < minLux then
        if LM.getValue(_LIGHT) ~= brightness.default then LM.setLight(brightness.default) end
      end
    end
  else
    if LM.isOff(_LIGHT) or type(fadeDelay) == "nil" then _f:abort() end
    setTimeout(
      function()
        if fadeDelay == -1 then
          LM.setLight(0)
        else
          local dim = math.min(math.floor(LM.getValue(_LIGHT) * fadeFactor), 99)
          LM.setGlobal("fading", 1)
          LM.setLight(dim)
          setTimeout(
            function()
              if LM.getValue(_LIGHT) == dim then
                LM.setLight(0)
                LM.setGlobal("fading", 0)
              end
            end,
            fadeDelay * 1000)
        end
      end,
      litDelay * 1000)
  end
end


-- RUN ----------------------------------------------------------------------
-----------------------------------------------------------------------------

LM.checkGlobal()
configure()

if trigger.type == "property" then
  if trigger.deviceID == _MOTION and trigger.propertyName == "value" then
    if LM.isManOff() then _f:abort() end
    LM.checkFading()
    LM.motionManager()
  elseif trigger.deviceID == _LUX and trigger.propertyName == "value" then
    if isManOff() then f:abort() end
    checkFading()
    LM.luxManager()
  elseif trigger.deviceID == _LIGHT then
    if trigger.propertyName == "sceneActivation" then
      LM.checkFading()
      local s = _f:getValue(_LIGHT, "sceneActivation")
      if tonumber(s) == 11 or tonumber(s) == 21 then
        LM.setGlobal("manOff", os.time())
      else
        if tonumber(LM.getGlobal("manOff")) ~= 0 then LM.setGlobal("manOff", 0) end
      end
      if (S[switch[s][1]][switch[s][2]]) then S[switch[s][1]][switch[s][2]]() end
    end
  end
elseif trigger.type == "global" then
  LM.checkFading()
  if (G[trigger.name]) then G[trigger.name]() end
else
  _f:abort()
end

:)

Modifié par OJC
  • Like 3
Lien vers le commentaire
Partager sur d’autres sites

×
×
  • Créer...