Aller au contenu

Rechercher dans la communauté

Affichage des résultats pour les étiquettes 'scène'.



Plus d’options de recherche

  • Rechercher par étiquettes

    Saisir les étiquettes en les séparant par une virgule.
  • Rechercher par auteur

Type du contenu


Forums

  • Bienvenue
    • Nouveau ? Présentez-vous
    • Le bistrot
    • Mon installation domotique
    • Annonces et suggestions
  • La Home Center et ses périphériques
    • La Home Center pour les nuls
    • HC 2 & Lite
    • HC 3
    • Modules Fibaro
    • Modules Z-wave
    • Périphériques et matériels autres
    • Plugins
    • Quick App
    • Multimédia (audio, vidéo ...)
    • Chauffage et Energie
    • Actionneurs & Ouvrants (Portail, volets, piscines, ...)
    • Eclairage
    • Applications Smartphones et Tablettes
  • Autres solutions domotiques
    • Box / Logiciel
    • Modules Nice (433 & 866 MHz)
    • Modules Zigbee
    • GCE Electronics
    • Modules Bluetooth Low Energy
  • Objets connectés
    • Les Assistants Vocaux
    • Netatmo
    • Philips Hue
    • DIY (Do It Yoursel)
  • Sécurité
    • Alarmes
    • Caméras
    • Portiers
    • Serrures
  • Informatique / Réseau
    • Tutoriels
    • Matériels Réseaux
    • Matériels Informatique
    • NAS
    • Virtualisation
  • Les bonnes affaires
    • Sites internet
    • Petites annonces

Calendriers

Aucun résultat à afficher.


Rechercher les résultats dans…

Rechercher les résultats qui…


Date de création

  • Début

    Fin


Dernière mise à jour

  • Début

    Fin


Filtrer par nombre de…

Inscription

  • Début

    Fin


Groupe


Jabber


Skype


Ville :


Intéret :


Version

44 résultats trouvés

  1. Voici 2 petits scripts LUA pour explorer les objets accessibles dans les QuickApps et les Scènes sur HC3. Quand on développe, il est toujours intéressant de découvrir des variables et fonctions non documentées, ou voir quelles fonctions sont disponibles dans les QuickApps ou dans les Scènes car il y a pas mal de différences. Cela permettra aussi de suivre les ajouts de fonctions par Fibaro au fur et à mesure des nouveaux firmwares. Les résultats donnés dans ce post sont été obtenus avec le firmware 5.031.33 QuickApps Créer un QA avec un seul bouton pour lancer l'exécution du code : function QuickApp:browse(racine, tableau) local variables, functions, objects = {}, {}, {} for k, v in pairs(tableau) do if type(v) == "table" then if v ~= _G then local variables2, functions2, objects2 = self:browse(racine .. k .. ".", v) for i = 1, #variables2 do variables[#variables+1] = variables2[i] end for i = 1, #functions2 do functions[#functions+1] = functions2[i] end for i = 1, #objects2 do objects[#objects+1] = objects2[i] end end elseif type(v) == "function" then functions[#functions+1] = racine .. k .. '()' elseif type(v) == "string" then variables[#variables+1] = racine .. k .. ' = "' .. v .. '"' elseif type(v) == "number" then variables[#variables+1] = racine .. k .. ' = ' .. tostring(v) elseif type(v) == "integer" then variables[#variables+1] = racine .. k .. ' = ' .. tostring(v) elseif type(v) == "boolean" then variables[#variables+1] = racine .. k .. ' = ' .. tostring(v) else objects[#objects+1] = racine .. k .. " => " .. type(v) end end table.sort(variables) table.sort(functions) table.sort(objects) return variables, functions, objects end function QuickApp:onButtonClic(event) self:trace("") local variables, functions, objects = self:browse("", _G) self:trace("Variables :") for _, v in ipairs(variables) do self:debug(v) end self:trace("Fonctions :") for _, v in ipairs(functions) do self:debug(v) end self:trace("Objets :") for _, v in ipairs(objects) do self:debug(v) end self:debug("Terminé") end function QuickApp:onInit() end Résultat : Variables : _VERSION = "Lua 5.3" __TAG = "QuickApp152" json._COPYRIGHT = "Copyright (c) 2007-2017 Thomas Harning Jr. " json._DESCRIPTION = "LuaJSON : customizable JSON decoder/encoder" json._VERSION = "1.3.4" json.decode.simple.array.allowEmptyElement = false json.decode.simple.array.trailingComma = true json.decode.simple.calls.allowEmptyElement = false json.decode.simple.calls.allowUndefined = false json.decode.simple.calls.trailingComma = true json.decode.simple.number.exp = true json.decode.simple.number.frac = true json.decode.simple.number.hex = false json.decode.simple.number.inf = true json.decode.simple.number.nan = true json.decode.simple.object.allowEmptyElement = false json.decode.simple.object.identifier = true json.decode.simple.object.number = true json.decode.simple.object.trailingComma = true json.decode.simple.others.allowUndefined = true json.decode.simple.others.null = false json.decode.simple.others.undefined = false json.decode.simple.strings.additionalEscapes = false json.decode.simple.strings.badChars = "" json.decode.simple.strings.strict_quotes = false json.decode.strict.array.allowEmptyElement = false json.decode.strict.array.trailingComma = false json.decode.strict.calls.allowEmptyElement = false json.decode.strict.calls.allowUndefined = false json.decode.strict.calls.trailingComma = true json.decode.strict.initialObject = true json.decode.strict.nothrow = false json.decode.strict.number.exp = true json.decode.strict.number.frac = true json.decode.strict.number.hex = false json.decode.strict.number.inf = false json.decode.strict.number.nan = false json.decode.strict.object.allowEmptyElement = false json.decode.strict.object.identifier = false json.decode.strict.object.number = false json.decode.strict.object.trailingComma = false json.decode.strict.others.allowUndefined = false json.decode.strict.strings.additionalEscapes = false json.decode.strict.strings.badChars = " " json.decode.strict.strings.strict_quotes = true json.decode.strict.unicodeWhitespace = true json.decode.util.DecimalLpegVersion = 1.0 json.encode.default.number.inf = true json.encode.default.number.nan = true json.encode.default.others.allowUndefined = true json.encode.default.strings.encodeSet = "\"/%z-" json.encode.default.strings.xEncode = false json.encode.strict.initialObject = true json.encode.strict.number.inf = false json.encode.strict.number.nan = false json.encode.strict.others.allowUndefined = false json.encode.strict.strings.encodeSet = "\"/%z-" json.encode.strict.strings.xEncode = false logger.DEBUG = 1 logger.ERROR = 4 logger.FATAL = 5 logger.INFO = 2 logger.TRACE = 0 logger.WARNING = 3 math.huge = inf math.maxinteger = 9223372036854775807 math.mininteger = -9223372036854775808 math.pi = 3.1415926535898 plugin.mainDeviceId = 152 utf8.charpattern = "[-�-�][�-�]*" Fonctions : __assert_type() __fibaroSleep() __fibaroUseAsyncHandler() __fibaro_add_debug_message() __fibaro_get_device() __fibaro_get_device_property() __fibaro_get_devices() __fibaro_get_global_variable() __fibaro_get_room() __fibaro_get_scene() __print() __ternary() api.delete() api.get() api.post() api.put() assert() bit32.arshift() bit32.band() bit32.bnot() bit32.bor() bit32.btest() bit32.bxor() bit32.extract() bit32.lrotate() bit32.lshift() bit32.replace() bit32.rrotate() bit32.rshift() class() clearInterval() clearTimeout() collectgarbage() configure() error() fibaro.__houseAlarm() fibaro.alarm() fibaro.alert() fibaro.call() fibaro.callGroupAction() fibaro.clearTimeout() fibaro.debug() fibaro.emitCustomEvent() fibaro.error() fibaro.get() fibaro.getDevicesID() fibaro.getGlobalVariable() fibaro.getIds() fibaro.getName() fibaro.getRoomID() fibaro.getRoomName() fibaro.getRoomNameByDeviceID() fibaro.getSectionID() fibaro.getType() fibaro.getValue() fibaro.profile() fibaro.scene() fibaro.setGlobalVariable() fibaro.setTimeout() fibaro.sleep() fibaro.trace() fibaro.useAsyncHandler() fibaro.wakeUpDeadDevice() fibaro.warning() getHierarchy() ipairs() json.array() json.decode.decode() json.decode.getDecoder() json.decode.simple.object.setObjectKey() json.decode.simple.strings.decodeUnicode() json.decode.strict.object.setObjectKey() json.decode.strict.others.null() json.decode.strict.others.undefined() json.decode.strict.strings.decodeUnicode() json.decode.util.denied() json.decode.util.get_invalid_character_info() json.decode.util.setObjectKeyForceNumber() json.decode.util.unexpected() json.encode.default.array.isArray() json.encode.default.others.null() json.encode.default.others.undefined() json.encode.encode() json.encode.getEncoder() json.encode.strict.array.isArray() json.encode.strict.others.null() json.encode.strict.others.undefined() json.null() json.util.InitArray() json.util.IsArray() json.util.buildCall() json.util.clone() json.util.decodeCall() json.util.doOptionMerge() json.util.isCall() json.util.merge() json.util.null() json.util.printValue() json.util.undefined() logger.debug() logger.error() logger.fatal() logger.getLevel() logger.info() logger.log() logger.setLevel() logger.trace() logger.warning() math.abs() math.acos() math.asin() math.atan() math.atan2() math.ceil() math.cos() math.cosh() math.deg() math.exp() math.floor() math.fmod() math.frexp() math.ldexp() math.log() math.log10() math.max() math.min() math.modf() math.pow() math.rad() math.random() math.randomseed() math.sin() math.sinh() math.sqrt() math.tan() math.tanh() math.tointeger() math.type() math.ult() next() onAction() onUIEvent() os.clock() os.date() os.difftime() os.exit() os.time() pairs() pcall() plugin.createChildDevice() plugin.deleteDevice() plugin.getChildDevices() plugin.getDevice() plugin.getProperty() plugin.restart() print() property() rawlen() select() setInterval() setTimeout() string.byte() string.char() string.dump() string.find() string.format() string.gmatch() string.gsub() string.len() string.lower() string.match() string.pack() string.packsize() string.rep() string.reverse() string.split() string.starts() string.sub() string.unpack() string.upper() super() table.concat() table.insert() table.move() table.pack() table.remove() table.sort() table.unpack() tonumber() tostring() type() unpack() utf8.char() utf8.codepoint() utf8.codes() utf8.len() utf8.offset() xpcall() Objets : Device => userdata Hierarchy => userdata QuickApp => userdata QuickAppBase => userdata QuickAppChild => userdata core.EventTarget => userdata json.decode.simple.strings.escapeCheck => userdata json.decode.strict.strings.escapeCheck => userdata json.decode.util.ascii_ignored => userdata json.decode.util.ascii_space => userdata json.decode.util.comment => userdata json.decode.util.comments.c => userdata json.decode.util.comments.cpp => userdata json.decode.util.hex => userdata json.decode.util.hexpair => userdata json.decode.util.identifier => userdata json.decode.util.unicode_ignored => userdata json.decode.util.unicode_space => userdata mqtt.Client => userdata mqtt.ConnectReturnCode => userdata mqtt.QoS => userdata net.HTTPClient => userdata net.TCPSocket => userdata quickApp => userdata Scènes Créer une scène LUA en exécution manuelle avec ce code : local function browse(racine, tableau) local variables, functions, objects = {}, {}, {} for k, v in pairs(tableau) do if type(v) == "table" then if v ~= _G and v ~= _ENV and v ~= __index and k ~= "__index" then local variables2, functions2, objects2 = browse(racine .. k .. ".", v) for i = 1, #variables2 do variables[#variables+1] = variables2[i] end for i = 1, #functions2 do functions[#functions+1] = functions2[i] end for i = 1, #objects2 do objects[#objects+1] = objects2[i] end end elseif type(v) == "function" then functions[#functions+1] = racine .. k .. '()' elseif type(v) == "string" then variables[#variables+1] = racine .. k .. ' = "' .. v .. '"' elseif type(v) == "number" then variables[#variables+1] = racine .. k .. ' = ' .. tostring(v) elseif type(v) == "integer" then variables[#variables+1] = racine .. k .. ' = ' .. tostring(v) elseif type(v) == "boolean" then variables[#variables+1] = racine .. k .. ' = ' .. tostring(v) else objects[#objects+1] = racine .. k .. " => " .. type(v) end end table.sort(variables) table.sort(functions) table.sort(objects) return variables, functions, objects end fibaro.trace(tag, "") local variables, functions, objects = browse("", _ENV) fibaro.trace(tag, "Variables :") for _, v in ipairs(variables) do fibaro.debug(tag, v) end fibaro.trace(tag, "Fonctions :") for _, v in ipairs(functions) do fibaro.debug(tag, v) end fibaro.trace(tag, "Objets :") for _, v in ipairs(objects) do fibaro.debug(tag, v) end fibaro.debug(tag, "Terminé") Résultat : Variables : fibaro.version = "1.0.0" json._version = "0.1.0" math.huge = inf math.maxinteger = 9223372036854775807 math.mininteger = -9223372036854775808 math.pi = 3.1415926535898 sceneId = 10 sourceTrigger.id = 2 sourceTrigger.property = "execute" sourceTrigger.type = "user" tag = "Scene10" Fonctions : api.delete() api.get() api.post() api.put() assert() error() fibaro.alarm() fibaro.alert() fibaro.call() fibaro.callGroupAction() fibaro.debug() fibaro.emitCustomEvent() fibaro.error() fibaro.get() fibaro.getAllDeviceIds() fibaro.getDevicesID() fibaro.getGlobalVariable() fibaro.getIds() fibaro.getName() fibaro.getRoomID() fibaro.getRoomName() fibaro.getRoomNameByDeviceID() fibaro.getSectionID() fibaro.getType() fibaro.getValue() fibaro.homeCenter.climate.setClimateZoneToManualMode() fibaro.homeCenter.climate.setClimateZoneToScheduleMode() fibaro.homeCenter.climate.setClimateZoneToVacationMode() fibaro.homeCenter.notificationService.publish() fibaro.homeCenter.notificationService.remove() fibaro.homeCenter.notificationService.update() fibaro.homeCenter.popupService.publish() fibaro.homeCenter.systemService.reboot() fibaro.homeCenter.systemService.suspend() fibaro.profile() fibaro.scene() fibaro.setGlobalVariable() fibaro.setTimeout() fibaro.sleep() fibaro.trace() fibaro.wakeUpDeadDevice() fibaro.warning() ipairs() json.decode() json.encode() math.abs() math.acos() math.asin() math.atan() math.atan2() math.ceil() math.cos() math.cosh() math.deg() math.exp() math.floor() math.fmod() math.frexp() math.ldexp() math.log() math.log10() math.max() math.min() math.modf() math.pow() math.rad() math.random() math.randomseed() math.sin() math.sinh() math.sqrt() math.tan() math.tanh() math.tointeger() math.type() math.ult() net.HTTPClient.new() net.HTTPClient.request() next() os.date() os.time() pairs() pcall() print() select() string.byte() string.char() string.dump() string.find() string.format() string.gmatch() string.gsub() string.len() string.lower() string.match() string.pack() string.packsize() string.rep() string.reverse() string.sub() string.unpack() string.upper() table.concat() table.insert() table.move() table.pack() table.remove() table.sort() table.unpack() tonumber() tostring() type()
  2. Sowliny

    Envoi de push... sur HC3

    Bonjour à toutes et tous, Je suis en train de refondre toutes mes scènes et plus particulièrement mes fonctions. L'une d'elles me sert pour l'envoi des push. J'ai effectué des tests tout fonctionnait - et depuis peu (maj en 5.030.45 en cause ?)b plus aucun push ne passe... ! J'utilise bien sûr la nouvelle syntaxe : fibaro.alert("push", {25}, "Hello Woolf !") J'ai vainement recherché des pistes dans les topics mais rien ne m'a permis de résoudre ce problème. Y a s'il une petite idée ? Merci d'avance
  3. Bonjour à tous, Quelqu’un peut il m’aider à la réalisation d’une scène permettant d’ouvrir et de fermer une électrovanne à différents moments de la journée : Je souhaiterais en une seule scène : A 6h00 ouvrir l’électrovanne pendant 10 min. Ensuite la fermer A 7h00 ouvrir l’électrovanne pendant 10 min. Ensuite la fermer Et idem à 8h00 et 09h00 Ca peut paraitre simple pour la majorité d’entre vous, mais pour moi, ca ne marche pas Un tout grand merci à qui veut bien me donner un coup de main
  4. Utilisation de net.HTTPClient() asynchrone - dans une scène en LUA sur HC2/HC3 - - dans un QuickApp sur HC3 - Dans les scènes, Fibaro ne nous laisse pas le choix, dès que l'on veut faire des appels HTTP, on est obligé d'utiliser la fonction asynchronse net.HTTPClient(). La fonction Net.FHTTP() synchrone utilisée dans les VD n'est pas disponible dans les scènes. Toutefois, l'avantage de net.HTTPClient() est d'accepter les connexions sécurisées HTTPS devenues majoritaires sur Internet. Exemple de code simple pour une requête de type GET local http = net.HTTPClient() http:request("http://1.2.3.4/url", { success = function(response) if response.status == 200 then print('OK, réponse : '.. response.data) else print("Erreur : status=" .. tostring(response.status)) end end, error = function(err) print("Erreur : " .. err) end, options = { method = 'GET' } }) L'exemple suivant effectue une requête de type POST permettant d'envoyer des données vers le site distant. De plus, la fonction success() récupère les données de type JSON en vue d'un traitement ultérieur (notez que les données envoyées vers le site Web et les données reçues depuis le site Web sont différentes, cela dépend de l'application qui tourne sur le site) : -- Les données à envoyer au formulaire local myJson = { "couleurs": { [1] = "bleu", [2] = "blanc", [3] = "rouge" }, "fruits": { [1] = "pomme", [2] = "banane" }, } -- Appel HTTPS local http = net.HTTPClient() http:request("https://www.domaine.com/url", { success = function(response) if response.status == 200 then if response.data and response.data ~= "" then print('Retour : '.. response.data) local jsonTable = json.decode(response.data) -- Parcours de la table JSON local k, v for k, v in pairs(jsonTable) do print("key = " .. k .. " - type(v) = " .. type(v)) end -- Ici la suite du code, exécuté en asynchrone, donc après la fin de l'exécution du code appelant http:request() -- ... else print("Error : empty response data") end else print("Erreur : status=" .. tostring(response.status)) end end, error = function(err) print("Erreur : " .. err) end, options = { method = 'POST', timeout = 5000, checkCertificate = false, headers = { ["content-type"] = 'application/x-www-form-urlencoded;', ["Authorization"] = "Basic YWRtaW46cGFzc3dvcmQ=" -- username:password encodé en Base64 (admin:password) }, data = json.encode(myJson) } }) -- Ici la suite du code, exécuté en synchrone, donc avant l'exécution du contenu de la fonction success() -- ... On remarque dans les options que l'on peut choisir les paramètres suivants : method : obligatoire : GET ou PUT ou POST ou DELETE timeout : facultatif : délai d'attente en millisecondes avant échec de la requête. Peut être utile avec certains serveurs un peu trop lents à répondre. Dans le doute, inutile d'utiliser ce paramètre. checkCertificate : facultatif : true ou false, permet d'ignorer les alertes de sécurité sur les certificats auto-signés (non reconnus pas une autorité de certification approuvée) headers : facultatif : permet de passer le(s) en-tête(s) HTTP de son choix vers le site Web distant. Si vous ne savez pas ce qu'est un Header, c'est que vous n'avez probablement pas besoin d'envoyer de header, donc ignorez ce paramètre. data : facultatif : ce sont les données à envoyer dans les formulaires POST et PUT sous forme de chaine de caractères. Donc si les données sont de type tableau JSON, il faut les encoder avec json.encode(). Asynchronisme net.HTTPClient() est asynchrone, le code dans les fonctions success() et error() appelées en callback s'exécute toujours après la fin de l'exécution du thread principal. Quand on commence à programmer en asynchrone, il ne faut plus jamais utiliser de fonctions synchrones comme sleep(), sous peine de comportement surprenant. Préférer à la place l'emploi de la fonction settimout() qui est elle-même asynchrone (chercher les exemples sur le forum) La bonne pratique quand on programme en asynchrone est la suivante : Après un appel à net.HTTPClient(), le code devrait se terminer le plus rapidement possible afin de laisser la main à la fonction success() appelée en callback de net.HTTPClient(). La suite du code se déroule donc dans la fonction success(). Celle-ci, à sont tour, peut faire d'autres appels à net.HTTPClient() ou settimeout() pour déclencher de nouveaux appels de fonctions en callback asynchrone. Etc... C'est la technique que j'ai employé dans mes scènes Watchdog et Yamaha MusicCast, partagées sur le forum. C'est une certaine gymnastique qui n'est pas évidente au début, et oblige à revoir toute la structure de son code LUA. En complément je vous invite à lire ce sujet sur la protection des requêtes http avec pcall() :
  5. Bonjour, débutant en LUA et scène, j'aimerai retourner la valeur de l'appareil (Aeotec meter Gen5) et pas seulement faire un déclanchement de la scène si > x par exemple ? Merci, HC3, 5.100.22
  6. En évaluant le job que j’aurai potentiellement à faire pour changer de box, je me suis mis à inventorier le code LUA utilisé sur ma HC2. Je me suis rendu compte que j’avais dupliqué pas mal de code (fonctions, routines, etc.) et surtout lors de correction de certaines portions de code j’ai oublié de le corriger dans quelques scènes ou ce code était dupliqué… Alors ce week-end, j’ai planché sur une solution me permettant de simplifier mon code et de le centraliser. Donc voici ci-dessous, ce que j'ai effectué. Stratégie création d'une scène que j'ai nommée scGloFuncLib (id:186) et qui est structurée comme suit : VARIABLES/CONSTANTES PERSONNALISABLE PAR L'UTILISATEUR; variables et constantes, modifiable par l'utilisateur, lui permettant d'adapter les valeurs à son environnement; VARIABLES/CONSTANTES INTERNES (à ne pas modifier); variables et constantes, nécessaires au bon fonctionnement de la scène. La valeurs définies ici sont sensées être optimisées et ne devraient pas être modifiées par les utilisateurs => risques d'effets de bord non maîtrisés; LES FONCTIONS INTERNES les fonction internes sont les fonction qui ne sont pas appelée en dehors de la scène, mais qui sont utiles à aux fonctions "exposées"; LES FONCTIONS EXPOSÉES les fonctions exposées, sont les fonction accessibles avec un appel externe depuis une autre scène/VD; MAIN permet d'analyser les arguments et d'appeler les fonctions concernées en vérifiant et en passant les bons paramètres; appel de la scène susmentionnée depuis une autre scène/VD avec le code suivant : fibaro:startScene(186, { "myFunction1", "p1", "p2", "pN" }) Limitations La limitation de ce système pour l'instant et le retour de valeur entre la scène qui appelle la fonction et celle qui l'exécute. N'ayant pour l'instant pas ce besoin, je n'ai rien fait. Mais si cela devait changer, je procéderais certainement de la manière suivante : création d'une variable globale avant l'appel de la fonction; appelle de la fonction via la scène scGloFuncLib en passant le nom de la variable globale créée; récupération de la valeur de la variable globale; destruction de la variable globale. Squelette du code LUA ---- *********************************************************************** ---- VARIABLES/CONSTENTES PERSONNALISABLES PAR L'UTILISATEUR ---- *********************************************************************** ---- Description ---- variables et constantes, modifiable par l'utilisateur, lui ---- permettant d'adapter les valeurs à son système. ---- ------------------------------------------------------------------- ---- myFonction1 ---- ------------------------------------------------------------------- FUNCTION1_DEF_PARAM2 = "123456asdf"; ---- ------------------------------------------------------------------- ---- log_debug ---- ------------------------------------------------------------------- IS_DEBUG_MODE = true; ---- *********************************************************************** ---- VARIABLES/CONSTENTES INTERNES (à ne pas modifier); ---- *********************************************************************** ---- Description ---- variables et constantes, nécessaires au bon fonctionnement de la ---- scène. La valeurs définies ici sont ensées être optimisées et ne ---- devraient pas être modifiées par les utilisateurs => risques ---- d'effets de bord non maîtrisés. ---- ------------------------------------------------------------------- ---- System ---- ------------------------------------------------------------------- MD5_HASH = "cb2b8c02de4f322cd67fd8e7a88d420f"; ---- *********************************************************************** ---- LES FONCTIONS INTERNES ---- *********************************************************************** ---- Description ---- les fonction internes sont les fonction qui ne sont pas appelées ---- en dehors de cette scène, mais qui sont utiles aux fonctions ---- "exposées". ---- ------------------------------------------------------------------- ---- function : log_std ---- ------------------------------------------------------------------- ---- paramètres : ---- str : log a envoyer dans la fenêtre de debug ---- retour : <aucun> ---- ------------------------------------------------------------------- function log_std(str) if IS_DEBUG_MODE then fibaro:debug("<font color='yellow'>"..str.."</font>"); end end ---- *********************************************************************** ---- LES FONCTIONS EXPOSÉES ---- *********************************************************************** ---- Description ---- les fonctions exposées, sont les fonction accessibles avec ---- un appel externe depuis une autre scène/VD. ---- ------------------------------------------------------------------- ---- function : myFunction1 ---- ------------------------------------------------------------------- ---- paramètres ---- _param_no1 : paramètre1 ---- _param_no2 : paramètre2 ---- retour : <aucun> ---- ------------------------------------------------------------------- function myFunction1 (_param_no1, _param_no2) -- * exécution de ma fonction "exposée end ---- *********************************************************************** ---- MAIN ---- *********************************************************************** ---- Description : ---- la boucle principal permet d'analyser les arguments et d'appeler ---- les fonctions concernées en leurs passant les bons paramètres. ---- Arguments : ---- args[1] = <functionName> : nom de la fonction appelée ---- args[n] = <parameters> : parametres des fonctions appelées ---- ------------------------------------------------------------------- -- * première chose à faire vérifier s'il y a des arguments if fibaro:args() == nil then -- * pas d'argmuent alors on sort de la scène return else -- * arguments, alors on les entre dans une table func_args = fibaro:args(); -- * puis on vérifie que le premier argument (nom de la fonction) existe if func_args[1] == nil or func_args[1] == "" then -- * pas de args[1] alors on sort de la scène, car aucune fonction a appeler return -- * si args[1] = myFunction1 alors on traite les paramètres par rapport à cette fonction elseif func_args[1] =="myFunction1" then ---- ------------------------------------------------------------------- ---- calling myFunction1 function ---- ------------------------------------------------------------------- ---- Parameters : ---- args[2] = param_no1 (obligatoire) ---- args[3] = param_no2 ---- ------------------------------------------------------------------- local param_no1,param_no2 -- * vérificatio du premier paramètre args[2] qui est obligatoire if func_args[2] == nil or func_args[2] == "" then -- * le paramètre est obligatoire, alors si pas renseigné on sort de la scène return else -- * on attribue args[2] à la variable param_no1 param_no1 = func_args[2]; end -- * vérificatio du deuxième paramètre args[2] qui est facultatif if func_args[3] == nil or func_args[3] == "" then -- * le paramètre est facultatif, possibilité d'attribuer une valeur par défaut si vide ou null param_no2 = FUNCTION1_DEF_PARAM2; else -- * on attribue args[2] à la variable param_no2 param_no2 = func_args[3]; end myFunction1 (param_no1,param_no2); return else -- * si args[1] ne correspond à aucune des fonctions exposées (func_args[1] =="FunctionName") , alors on sort de la scène. return end -- fin de l'execution de la scène. end
  7. Voici un Scène qui va vous permettre de savoir si on est le jour ou la nuit et d'avoir un décalage en minute par rapport ou jour ou a la nuit IL va nous falloir pour cette scène 2 variables globales et 1 variable globale prédéfinie Jour_Nuit (Variable prédéfinie avec comme valeur Jour ou Nuit. elle aura 2 déclenchements) SoleilLever (cette variable recevra les valeurs de la table TLever elle aura donc autant de déclenchement que de valeur dans la table TLever) SoleilCoucher (Cette variable recevra les valeurs de la table TCoucher, elle aura donc autant de déclenchement que de valeur dans la table TCoucher) Ces variables seront créées automatiquement si vous êtes en V4. Vous pouvez donnez un autre nom a chaque variable globales que les valeurs par défaut. -- Nom des Variables Globales local VGJourNuit = "Jour_Nuit" local VGLeverSoleil = "SoleilLever" local VGCoucherSoleil = "SoleilCoucher" -- Minutes de décalages par rapport au lever du soleil local TLever = {-60, -15, 30, 60, 50, 124} -- Minutes de décalages par rapport au Coucher du soleil local TCoucher = {-5, 30, 0, -30} -- Id du téléphone local IdTel = 181 Pour notre ami JoJo ainsi qu'a tout ceux qui sont en V3.60 il faudra crées les variables manuellement et désactivé ces trois lignes VerifVG(VGJourNuit, "Jour", {"Jour", "Nuit"}) VerifVG(VGLeverSoleil, 0) VerifVG(VGCoucherSoleil, 0) ----------------------------- Il faut renseigner IdTel avec l'id de votre téléphone cela va servir a vous envoyez une notification lorsque la box démarre ou lorsqu il y a modification de la scène. Une notification est aussi possible si il y a un probléme de variable globale. Le programme est optimisez pour que le sleep passe automatiquement de 1 mn à 30 mn en fonction des valeurs des tables coucher et lever Exemple d'utilisation : Scène bloc : Scène LUA je veux un déclenchement de scène (Il n'y a aucun ordre a respecter) 45 minutes avant le lever = -45 15 minutes avant le lever = -15 23 minutes apres le lever = 20 1h20 minutes apres le lever = 80 0 minutes = Jour dans la tables TLever il est donc inutile de mettre 0, il sera ajouter automatiquement a la table Je renseigne donc ma table TLever comme ceci local TLever = {-45, 20, 80, -15} Je fais de même avec la table TCoucher local TCoucher = {-5, 30, -30} Récupération des triggers dans une scène Utilisation de la variables globales Jour_Nuit comme trigger --[[ %% globals Jour_Nuit --]] local JourNuit = fibaro:getGlobalValue("Jour_Nuit") if JourNuit == "Jour" then fibaro:debug("Il fait "..JourNuit) end if JourNuit == "Nuit" then fibaro:debug("Il fait "..JourNuit) end Utilisation de ou des variables globales SoleilLever et SoleilCoucher comme trigger --[[ %% globals SoleilLever SoleilCoucher --]] local trigger = fibaro:getSourceTrigger() if (trigger['type'] == 'global') then LeverCoucher = trigger['name'] valeur = tonumber(fibaro:getGlobalValue(LeverCoucher)) print(nom, valeur) end -- le code dans ce test sera déclencher 15 mn aprés le coucher if LeverCoucher == "SoleilCoucher" and valeur == 15 then fibaro:call(7, "close") --Fermeture volet 15 mn après le coucher end -- le code dans ce test sera déclancher 30 mn avant le coucher if nom == "SoleilLever" and valeur == -30 then fibaro:call(7, "close") --Fermeture volet 30 mn avant le lever du soleil end Merci a STEVEN pour m'avoir aider a optimisez ce code Voici le code a copier dans une scène Version 3.00b --[[ %% autostart --]] -- Nom des Variables Globales local VGJourNuit = "Jour_Nuit" local VGLeverSoleil = "SoleilLever" local VGCoucherSoleil = "SoleilCoucher" -- Minutes de décalages par rapport au lever du soleil local TLever = {-60, -15, 30, 60, 50, 124} -- Minutes de décalages par rapport au Coucher du soleil local TCoucher = {-5, 30, 0, -30} -- Id du téléphone local IdTel = 181 --************ Ne rien modifier en dessous de cette ligne ************ ---------------------------------------------------------------------- -- Envoi d'un Push pour avertir que le box à démarrer ou redémarrer -- ---------------------------------------------------------------------- function EnvoiPush(Message) fibaro:debug(Message) fibaro:call(IdTel, "sendPush", Message) end -- ----------------------------------------------------------------- -- Vérification Variable Globale et création si besoin -- -- ----------------------------------------------------------------- function VerifVG(nom, valeur, choix) if (fibaro:getGlobalValue(nom) == nil) then local enum = 0 if (type(choix) ~= "nil") then enum = 1 end api.post("/globalVariables", {name=nom, isEnum=enum}) if enum == 1 then local variable = {} variable.value = tostring(valeur) variable.isEnum = false if (type(choix) ~= "nil") then variable.isEnum = true variable.enumValues = choix end api.put("/globalVariables/" .. nom, variable) end end end ---------------------------------------------------------------------- -- Mise a jour d'une variable global -- ---------------------------------------------------------------------- function UpdateVG(NomVG, Valeurs) if (fibaro:getGlobalValue(NomVG) == nil) then fibaro:debug("il faut cree la variable "..NomVG) EnvoiPush(string.format("La variable Globale %s n'existe pas ou a ete supprimer", NomVG)) fibaro:abort() -- fin du programme end fibaro:debug("Mise a jour de la Variable Globale : "..NomVG.." = "..Valeurs) fibaro:setGlobal(NomVG, Valeurs); end ---------------------------------------------------------------------- -- Vérification de l'heure et mise à jour -- -- de la variable si nécessaire -- ---------------------------------------------------------------------- function UpdateJourNuit(NomVG, heure) local valeurs = "Nuit" -- test si on est le jour ou la nuit if (heure >= leverSoleil) and (heure < coucherSoleil) then valeurs = "Jour" end fibaro:debug(string.format("Lever Soleil : %s - Coucher Soleil : %s", leverSoleil, coucherSoleil)) UpdateVG(NomVG, valeurs) -- mise a jour de la VG Jour_Nuit end ---------------------------------------------------------------------- -- Compare les tables Lever et coucher du soleil -- -- avec sunrisehour et sunsethour -- ---------------------------------------------------------------------- function LeverCoucher(NomVG, TableNom, SunRiseSet, JourNuit) for index, v in ipairs(TableNom) do if (os.date("%H:%M", os.time()+v*-60)) == SunRiseSet then UpdateVG(NomVG, v) if v == 0 then fibaro:debug("il fait : "..JourNuit) UpdateVG(VGJourNuit, JourNuit) end end end end ---------------------------------------------------------------------- -- Conversion Date format texte en format Date -- ---------------------------------------------------------------------- function ConvertionDate(NomDate) -- on extrait l'heure et minute (%d+) est un digit local heure, minute = string.match(NomDate, "(%d+):(%d+)") -- On récupère l'heure et date actuelle sous forme de tableau local TableDate = os.date("*t") -- On modifie l'heure et les minutes TableDate.hour = heure TableDate.min = minute -- Nous pouvons maintenant exploiter "MonHeure" comme une vrai date local MonHeure = os.time(TableDate) return (MonHeure) end ---------------------------------------------------------------------------- -- Calcul la valeur du Sleep en fonction des Max et Mini -- -- des Tables Lever et Coucher -- ---------------------------------------------------------------------------- function calculPause(j, heure, minilever, maxilever, minicoucher, maxicoucher) fibaro:debug("Heure Actuelle : "..heure) -- mini et max lever local heurelever = ConvertionDate(leverSoleil) local heureleverMini = (os.date("%X", heurelever+(minilever*60))) local heureleverMaxi = (os.date("%X", heurelever+(maxilever*60))) fibaro:debug("heure Lever Soleil Mini : "..heureleverMini.." - Maxi : "..heureleverMaxi) -- mini et max coucher local heurecoucher = ConvertionDate(coucherSoleil) local heurecoucherMini = (os.date("%X", heurecoucher+(minicoucher*60))) local heurecoucherMaxi = (os.date("%X", heurecoucher+(maxicoucher*60))) fibaro:debug("heure Coucher Soleil Mini : "..heurecoucherMini.." - Maxi : "..heurecoucherMaxi) if heure >= heureleverMini and heure < heureleverMaxi or heure >= heurecoucherMini and heure < heurecoucherMaxi then j=1 end return (j) end -- =================================================================== -- == Nous avons fini la préparation de notre code == -- == Nous pouvons Exécuter le programme == -- == Script réaliser par MPRINFO Version 3.00B == -- == Grand Merci à STEVEN pour son aide == -- =================================================================== ---------------------------------------------------------------------- -- Envoi d'un Push pour donner la date et l'heure de démarrage -- ---------------------------------------------------------------------- EnvoiPush(string.format("La box a démarré le %s a %s", os.date("%d/%m/%Y"), os.date("%R"))) ---------------------------------------------------------------------- -- Contrôle si 1 Scène et déjà en cours -- ---------------------------------------------------------------------- local NbreScene = fibaro:countScenes() if NbreScene ~= 1 then; fibaro:debug("Il y a déjà une instance en cours... ") fibaro:abort(); end ---------------------------------------------------------------------- -- Vérification si les variables globales existe -- -- et Création ou Modification si Besoin -- ---------------------------------------------------------------------- VerifVG(VGJourNuit, "Jour", {"Jour", "Nuit"}) VerifVG(VGLeverSoleil, 0) VerifVG(VGCoucherSoleil, 0) ---------------------------------------------------------------------- -- Mise a jour de la variable VG Jour_Nuit au Démarrage de la Box -- -- Ou lors de la sauvegarde de la scène -- ---------------------------------------------------------------------- leverSoleil = fibaro:getValue(1, "sunriseHour") coucherSoleil = fibaro:getValue(1, "sunsetHour") UpdateJourNuit(VGJourNuit, os.date("%H:%M", os.time())) --------------------------------------------------------------------- -- Trie des Tables et récupération des valeurs min et maximum -- --------------------------------------------------------------------- -- Traitement de la Table TLever table.insert(TLever, 1, 0) -- ajout de 0 mn dans la table table.sort(TLever) local MiniLever = ((TLever[1]-30)) local MaxiLever = ((TLever[#TLever]+1)) -- Traitement de la Table TChoucher table.insert(TCoucher, 1, 0) -- ajout de 0 mn dans la table table.sort(TCoucher) local MiniCoucher = ((TCoucher[1]-30)) local MaxiCoucher = ((TCoucher[#TCoucher]+1)) --------------------------------------------------------------------- -- Test toute les minutes pour savoir si c'est jour ou nuit -- --------------------------------------------------------------------- while true do local j = 30 local osHeure = os.date("%H:%M", os.time()) leverSoleil = fibaro:getValue(1, "sunriseHour") coucherSoleil = fibaro:getValue(1, "sunsetHour") LeverCoucher(VGLeverSoleil, TLever, leverSoleil, "Jour") LeverCoucher(VGCoucherSoleil, TCoucher, coucherSoleil, "Nuit") j = calculPause(j, osHeure, MiniLever, MaxiLever, MiniCoucher, MaxiCoucher) fibaro:debug(string.format("Valeur du Sleep %s mn",j)) fibaro:sleep(j*60*1000); -- Pause en fonction de la valeur de J end A ceux qui vont utiliser cette scène, Merci de me faire un retour sur ce code...
  8. jjacques68

    Récupérer l'ID de la scène en cours

    hello ! existe-il une commande qui permette de récupérer l'ID de la scène en cours ? Par exemple si je suis dans la scène avec comme ID 50, il faudrait une commande qui me retourne ce 50 ! genre "fibaro.getCurrentSceneID()" par exemple dans un QA c'est la commande : plugin.mainDeviceId mais dans une scène ??
  9. jjacques68

    instance de scènes

    hello ! on en a déjà parlé, il me semble. sur le HC3 il n'y a plus la notion d'instance de scène. On peut grâce aux options de la scène, définir si la prochaine exécution annule et remplace la précédente, ou pas. EDIT : dans ce dernier cas, la prochaine exécution sera tout simplement ignorée. je rencontre certain cas bien précis où j'aurai bien aimé avoir la possibilité d'avoir plusieurs instances simultanément... n'y a - t - il pas un moyen de pouvoir le faire ? ou peut être d'une autre façon ? Une autre approche ? bien à vous !
  10. Hello ! Je me rends compte que de temps en temps, j'ai une scène qui génère une erreur... Sans aucunes indications !! Dans le debug, j'ai juste le type "error", le tag "scene65" , mais rien dans le message !! Donc pas moyen de savoir ce qu'il se passe... La scène permet de gérer l'allumage quand on passe devant un PIR... Elle fonctionne à 99.999999 % Mais cette semaine j'ai eut ces 3 erreurs sans indications... et je sais pas pourquoi. ça fais des heures que je m'arrache les cheveux et je tourne en rond... alors j'ai réussi à reproduire ce type d'affichage d'erreur dans le debug en créant une scène avec : (rien à voir avec ma scène...) print("start") fibaro.sleep(10000) print("end") Il apparait clairement qu'il y a un lien avec la gestion du "multi-instance" (si on peut encore appeler ça comme ça...) En lançant 2 fois la scène dans les 10 secondes. Visiblement, lors de l'exécution de la deuxième instance de scène, ça plante et le message "error" apparaît. Normalement, si une 2ème instance est lancée, elle annule la précédente !!!! Je précise que l'option dans "Allow to restart a running scene: "est par défaut sur "YES". Si le mets sur "NO", il n'y a plus d'erreur, mais la deuxième instance de scène n'est pas prise en compte (logique...) Pour info si on remplace le "sleep" par un setTimeout(), il n'y a plus ce soucis... Pour en revenir à ma scène, elle ne possède pas de sleep ou de setTimeout !!! Mais d'après ce que j'observe dans le debug, cette erreur apparaît quand je passe d'une pièce à l'autre et que donc potentiellement, 2 instances (ou plus) de la scène peuvent être démarrées. alors bug utilisateur ou bug système ??? voici son code : (désolé, ce sera peut être pas évident...) Elle permet d'allumer/éteindre les lumières d'une pièce quand un PIR trigge la scène. J'ai cette scène unique pour toute la maison. Donc dans les conditions, tous les PIR sont présent avec comme valeur de déclenchement : "anyValue". Les lumières de la pièces restent allumer tant que le PIR ne repasse pas à FALSE. Donc... le temps d'allumage est géré par les paramètres des capteurs PIR. Je tiens compte également du niveau de LUX (pour les PIR qui me fournissant cette option) Pour chaque pièce ou un PIR est présent pour l'allumage, j'ai un QA qui me permet de choisir si je veux que l'éclairage soit en mode auto ou manu. Il est nommé avec l'ID de la pièce pour plus de facilité de programmation. Il existe quelques subtilités (VMC salle de bain (avec leur "delay" sur le OFF) et éclairage extérieur (suivant des conditions horaires)) local NameScene = "Lights on PIR" local IDPirZoneEntree = 169 local IDPirZoneGarage = 459 local ListeDelay = {} --récupère l'ID du trigger (PIR) local TriggerID = sourceTrigger.id --Trouve la pièce liée au PIR local RoomID = api.get("/devices/"..TriggerID).roomID --Trouve l'ID du QA qui gére la marche forcée de la pièce local PIRAutoID = api.get("/devices/?name=PIR_Room_"..RoomID)[1].id --si QA en mode auto if fibaro.getValue(PIRAutoID, "value") == true then --Trouve le capteur de LUX de la pièce local LuxID = api.get("/rooms/"..RoomID).defaultSensors["light"] --Trouve le niveu jour/Nuit du capteur si existant et si la propriété existe (donc en gros que pour les FGMS) local LuxLevel = 0 if LuxID ~= 0 and api.get("/devices/"..LuxID).properties.parameters[7].value then LuxLevel = api.get("/devices/"..LuxID).properties.parameters[7].value end --liste les lumières de la pièce local ListeLightsInRoom = api.get("/devices/?roomID="..RoomID.."&property=[isLight,true]") --pour tout les lumières de la pièces for k,v in pairs(ListeLightsInRoom) do ---------------------------------------------- --si PIR = true ---------------------------------------------- if fibaro.getValue(TriggerID, "value") == true then ---------------------------------------------- --pour les VMC : supprime les éventuelles delay OFF if v.id == 69 or v.id == 226 then --recupère la liste de la VG ListeDelay = fibaro.getGlobalVariable("DelayVmc") ListeDelay = json.decode(ListeDelay) --parcours tous les delay OFF existant (max 2) for index,value in pairs(ListeDelay) do --si trouve l'ID du trigger correspondant if value.VMC == v.id then --on le surppime dans l'API (passe par un QA) fibaro.call(490, "Delete", value.API.timestamp,value.API.id) --on le supprime de la liste table.remove(ListeDelay, index) end end --mémorise la VG ListeDelay = json.encode(ListeDelay) fibaro.setGlobalVariable("DelayVmc", ListeDelay) end --END VMC--------------------------------------------- --si on a un capteur Lux et un seuil jour/nuit if LuxID ~= 0 and LuxLevel ~= 0 then --si Lux < LuxLevel if fibaro.getValue(LuxID, "value") <= LuxLevel then fibaro.call(v.id, "turnOn") end --si pas de capteurs de LUX else fibaro.call(v.id, "turnOn") end ---------------------------------------------- --si PIR = false ---------------------------------------------- else -->> PIR = FALSE ---------------------------------------------- --pour les VMC : retarde le OFF avec le delay if v.id == 69 or v.id == 226 then res = api.post("/devices/"..v.id.."/action/turnOff", {delay = 60}) --enregistre dans une VG, le timestamp et l'id de l'API ainsi que l'ID du PIR trigger ListeDelay = fibaro.getGlobalVariable("DelayVmc") ListeDelay = json.decode(ListeDelay) table.insert(ListeDelay, {VMC = v.id, API = res}) ListeDelay = json.encode(ListeDelay) fibaro.setGlobalVariable("DelayVmc", ListeDelay) --END VMC -------------------------------------------- else fibaro.call(v.id, "turnOff") end end -->>PIR = TRUE/FALSE end -->> boucle pour chaque lumière end -->> QA en mode auto -------------------------------------------------------------------------------------------------------- --[[ CAS PENDANT LA NUIT : QUE si c'est le PIR de la porte d'entrée ou de garage remarque : dans le cas où l'extérieur s'allume juste qqu secondes avant sunriseHour, cette scène n'éteindra pas. Ce sera la scène Sun Set/Rise - Lights qui s'en occupera ]] -------------------------------------------------------------------------------------------------------- if TriggerID == IDPirZoneEntree or TriggerID == IDPirZoneGarage then -- si on est après 01:05 et avant 14 minute avant SunRise on allume tout le jardin if os.date("%H:%M",os.time()) > "01:05" and os.date("%H:%M",os.time()+14*60) < api.get('/settings/info').sunriseHour and os.date("%H:%M",os.time()) < api.get('/settings/info').sunriseHour --à cause des 14 min avant 00:00 then fibaro.trace(NameScene,os.date("%H:%M",os.time()), os.date("%H:%M",os.time()+14*60), api.get('/settings/info').sunriseHour) --si PIR = true if fibaro.getValue(TriggerID, "value") == true then fibaro.call({166,278,279,280}, "turnOn") --PIR = false else fibaro.call({166,278,279,280}, "turnOff") end end end Voilà, si vous avez un peu de temps et encore des cheveux !!!! c'est avec plaisir que je prends vos idées !
  11. DECLARATIONS (Conditions/Triggers) { operator = "any", conditions = { -- tamper { id = 000, isTrigger = true, operator = "anyValue", property = "tamper", type = "device" } } } ACTIONS local trigger = sourceTrigger print("property:"..trigger.property) print("id:"..trigger.id) print("type:"..trigger.type) print("value:"..tostring(trigger.value))
  12. DECLARATIONS (Conditions/Triggers) { operator = "any", conditions = { -- proxymityStateChanged { id = 000, isTrigger = true, operator = "anyValue", property = "proxymityStateChanged", type = "device" } } } ACTIONS local trigger = sourceTrigger print("property:"..trigger.property) print("id:"..trigger.id) print("type:"..trigger.type) print("value:"..tostring(trigger.value)) Et pourquoi pas l'utilisation d'un quick app de type binary sensor en complément fibaro.call(0000,"breached", trigger.value)
  13. DECLARATIONS (Conditions/Triggers) { operator = "any", conditions = { -- buttonOneIsPressed { id = 000, isTrigger = true, operator = "anyValue", property = "buttonOneIsPressed", type = "device" }, -- buttonTwoIsPressed { id = 000, isTrigger = true, operator = "anyValue", property = "buttonTwoIsPressed", type = "device" }, -- buttonThreeIsPressed { id = 000, isTrigger = true, operator = "anyValue", property = "buttonThreeIsPressed", type = "device" } } } ACTIONS -- buttonOneIsPressed -- buttonTwoIsPressed -- buttonThreeIsPressed local trigger = sourceTrigger print("property:"..trigger.property) print("id:"..trigger.id) print("type:"..trigger.type) print("value:"..tostring(trigger.value))
  14. DECLARATIONS (Conditions/Triggers) { operator = "any", conditions = { -- input1 { id = 000, isTrigger = true, operator = "anyValue", property = "input1", type = "device" }, -- input2 { id = 000, isTrigger = true, operator = "anyValue", property = "input2", type = "device" } } } ACTIONS -- input1 -- input2 local trigger = sourceTrigger print("property:"..trigger.property) print("id:"..trigger.id) print("type:"..trigger.type) print("value:"..tostring(trigger.value))
  15. DECLARATIONS (Conditions/Triggers) { operator = "any", conditions = { -- firstRelayIsOpen { id = 000, isTrigger = true, operator = "anyValue", property = "firstRelayIsOpen", type = "device" }, -- secondRelayIsOpen { id = 000, isTrigger = true, operator = "anyValue", property = "secondRelayIsOpen", type = "device" } } } ACTIONS -- firstRelayIsOpen -- secondRelayIsOpen local trigger = sourceTrigger print("property:"..trigger.property) print("id:"..trigger.id) print("type:"..trigger.type) print("value:"..tostring(trigger.value))
  16. jjacques68

    CRON

    Hello, alors là !!!!!! ????? je perds la boule !!!!!!! en photos, comme d'habitude, ce sera plus parlant : Trouvez l'erreur !!
  17. jjacques68

    Scène avec setTimeout qui s’arrête

    Bon voilà, j’avance avec cette box... petit à petit... Il y aurait des chose à redire... mais on va être patient et faire avec... la j’ai eu un cas étrange : J’ai une scène qui tourne (devrai tourner) H24 7/7 grâce à une boucle d’un setTimeout. Et visiblement elle s’est arrêtée pour une raison inconnue et rien dans le debug. Il ‘n’y avait aucune raison (par code) que celle-ci s’arrête ! ! ! ! d’où ma question : est - il possible qu’ils aient limité, dans le temps, le fonctionnement des scènes ?
  18. Nilmoty

    identifier dans une scène le user appelant

    Bonjour, Je souhaiterai pouvoir identifier dans une scène le nom de l'utilisateur qui s'est connecté à l'API qui a appelé cette même scène. Merci Nilmoty
  19. Scène pour afficher l'utilisation des variables globales Références croisées (xref) Lorsque les développements prennent une certaine ampleur, et en absence d'atelier de développement logiciel, il est utile de de pouvoir rapidement identifier quel morceau de code utilise telle variable (globale dans le cas de la HC2). Ce sujet avait déjà été abordé il y a maintenant quelque temps : Je vous en propose une nouvelle version qui permet : D'obtenir pour chaque variable globale les scènes et VD qui en font usage ; Pour chaque scène et pour chaque VD d'avoir la liste des variables globales utilisées (c'est cela qui est nouveau). Voici un exemple des résultats affichés dans le fenêtre de debug : La scène est un peu longue lors de son exécution, je suis preneur d'idées d'algorithmes plus optimisés. Le code de la scène : --[[ This scene is used to list all the global variables and where they are used. It's a kind of xref. -- 07/02/2017: creation -- 24/10/2019: add scene and virtual devices --]] local startTime = os.time(); local globalVariables = api.get("/globalVariables"); -- Get all globals variables local scenes = api.get("/scenes?type=com.fibaro.luaScene&isLua=true"); -- all the scenes local devices = api.get("/devices?type=virtual_device"); -- and all the virtual devices since for others types there is no lua code function round(num, numDecimalPlaces) return tonumber(string.format("%." .. (numDecimalPlaces or 0) .. "f", num)); end -- round function progressBar(progressPct, length) if length ~= nil or length == 0 then length = 20; end progressPct = math.abs(progressPct); progressPct = math.min(progressPct, length); return ' [' .. string.rep("*", progressPct) .. string.rep("_", length - progressPct) .. '] '; end -- progressBar fibaro:debug('<font color="Gold">Analyzing lua code for ' .. #globalVariables .. ' global variables, ' .. #scenes .. ' scenes, ' .. #devices .. ' virtual devices, this may take a while.</font>'); -- Where each global variable is used local txt = '<BR><font color="yellow">'.. string.rep('=', 80) .. '<BR>Globals variables ' .. os.date("%d/%m/%y %X") .. '</font><BR>'; local cnt = 0; for _, glob in pairs(globalVariables) do -- For each global variable txt = txt .. '<BR><font color="Orange">Global variable "' .. glob.name .. '":</font>'; cnt = cnt + 1; local used = false; for _, s in pairs(scenes) do -- For each scene local scene = api.get("/scenes/" .. s.id); if scene.triggers.globals ~= nil then for _, g in pairs(scene.triggers.globals) do -- We look each trigger if (g ~= nil) and (g == glob.name) then txt = txt .. '<BR><font color="lightgreen">&nbsp&nbsp&nbsp- trigger in scene "' .. scene.name .. '" (id:' .. scene.id .. ')</font>'; used = true; end end end -- Lua code inspection if (scene.lua ~= nil) and (string.find(scene.lua, glob.name) ~= nil) then txt = txt .. '<BR><font color="Chartreuse">&nbsp&nbsp&nbsp- used in scene "' .. scene.name .. '" (id:' .. scene.id .. ')</font>'; used = true; end end -- for _, s in pairs(scenes) for _,device in pairs(devices) do -- For each virtual device if (device.properties.mainLoop ~= nil) and (string.find(device.properties.mainLoop, glob.name) ~= nil) then -- look in mainloop txt = txt .. '<BR><font color="DeepSkyBlue">&nbsp&nbsp&nbsp- used in VD "' .. device.name .. '" mainloop</font>'; used = true; end local rows = device.properties.rows; -- look in buttons for _, row in pairs(rows) do if (row.type ~= nil) and (row.type == "button") and (row.elements ~= nil) then for _,element in pairs(row.elements) do if (element.lua ~= nil) and (element.lua == true) then if (element.msg ~= nil) and (string.find(element.msg, glob.name) ~= nil) then txt = txt .. '<BR><font color="LightSkyBlue">&nbsp&nbsp&nbsp- used in "' .. element.name .. '" btn (id: ' .. element.id .. ') of "' .. device.name .. '" VD (' .. device.id .. ')</font>'; used = true; end end end end end end -- for _,d in pairs(devices) if not used then txt = txt .. "<font color='Magenta'> unused</font>"; end local progress = round((cnt / #globalVariables) * 100) if (progress % 5) == 0 then fibaro:debug('<font color="gray">working,' .. progressBar(progress/5, 20) .. tostring(progress) .. '% done in ' .. (os.time()-startTime) .. ' secondes.</font>'); end end txt = txt .. '<BR><font color="gray">Total memory in use by Lua (version '.._VERSION..'): ' .. string.format("%.2f", collectgarbage("count")) .. ' KB</font>'; txt = txt .. '<BR><font color="gray">Time for global variables: ' .. (os.time()-startTime) .. ' secondes.</font><BR>'; -- Global variables used by scenes local sceneTime = os.time(); txt = txt .. '<BR><font color="yellow">'.. string.rep('=', 80) .. '<BR>Global variables used by scene ' .. os.date("%d/%m/%y %X") .. '</font><BR>'; for _, s in pairs(scenes) do -- For each scene txt = txt .. '<BR><font color="lightgreen">Scene "' .. s.name .. '" (id:'.. s.id .. '):</font>'; local used = false; local scene = api.get("/scenes/" .. s.id); if scene.triggers.globals ~= nil then for _, g in pairs(scene.triggers.globals) do -- We look each trigger for _, glob in pairs(globalVariables) do -- For each global variable if (g == glob.name) then txt = txt .. '<BR><font color="Orange">&nbsp&nbsp&nbsp- global "' .. glob.name .. ' used as a trigger"</font>'; used = true; end end -- for _, glob end end -- Lua code inspection if (scene.lua ~= nil) then for _, glob in pairs(globalVariables) do -- For each global variable if (string.find(scene.lua, glob.name) ~= nil) then txt = txt .. '<BR><font color="Coral">&nbsp&nbsp&nbsp- global "' .. glob.name .. '" used</font>'; used = true; end end -- for _, glob end if not used then txt = txt .. "<font color='Magenta'> no global variable used</font>"; end end -- for _, s in pairs(scenes) txt = txt .. '<BR><font color="gray">Total memory in use by Lua (version '.._VERSION..'): ' .. string.format("%.2f", collectgarbage("count")) .. ' KB</font>'; txt = txt .. '<BR><font color="gray">Time for scenes: ' .. (os.time()-sceneTime) .. ' secondes.</font><BR>'; -- Global variables used by virtual devices local deviceTime = os.time(); txt = txt .. '<BR><font color="yellow">'.. string.rep('=', 80) .. '<BR>Global variables used by virtual devices ' .. os.date("%d/%m/%y %X") .. '</font><BR>'; for _,device in pairs(devices) do -- For each virtual device txt = txt .. '<BR><font color="DeepSkyBlue">Virtual device "' .. device.name .. '" (id:'.. device.id .. '):</font>'; local used = false; if (device.properties.mainLoop ~= nil) then -- look in mainloop for _, glob in pairs(globalVariables) do -- For each global variable if (string.find(device.properties.mainLoop, glob.name) ~= nil) then txt = txt .. '<BR><font color="Orange">&nbsp&nbsp&nbsp- global "' .. glob.name .. '" used in mainloop</font>'; used = true; end end end local rows = device.properties.rows; -- look in buttons for _, row in pairs(rows) do if (row.type ~= nil) and (row.type == "button") and (row.elements ~= nil) then for _,element in pairs(row.elements) do for _, glob in pairs(globalVariables) do -- For each global variable if (element.lua ~= nil) and (element.lua == true) then if (element.msg ~= nil) and (string.find(element.msg, glob.name) ~= nil) then txt = txt .. '<BR><font color="Coral">&nbsp&nbsp&nbsp- global "' .. glob.name .. '" used in btn "' .. element.name .. '" (id:' .. element.id .. ')</font>'; used = true; end end end end end end if not used then txt = txt .. "<font color='Magenta'> no global variable used</font>"; end end -- for _,device txt = txt .. '<BR><font color="gray">Total memory in use by Lua (version '.._VERSION..'): ' .. string.format("%.2f", collectgarbage("count")) .. ' KB</font>'; txt = txt .. '<BR><font color="gray">Time for virtual devices: ' .. (os.time()-deviceTime) .. ' secondes.</font>'; txt = txt .. '<BR><font color="gray">Total elapsed time: ' .. (os.time()-startTime) .. ' secondes.</font><BR>'; fibaro:debug(txt); Je vous propose l'icône que j'utilise et suis preneur d'une qui serait plus "artistique". A l'approche des frimas, je ne puis que conclure par un... Chaleureusement.
  20. MAM78

    Intercom Manager

    Intercom Manager Préambule : N'ayant rien trouvé sur le site sur l'intégration de l'Intercom Fibaro, j'ai pris l'initiative de créer un Intercom Manager dont l'objectif consiste à : Regrouper dans une seule scène la détection de l'ensemble des événements et actions pouvant ayant pour origine : l'intercom lui-même l'application Intercom Fibaro pour smartphone (iOS et Androïd) le plugin Intercom disponible pour nos Box Home Center le site internet dédié à l'Intercom l'application développée par @Krikroff pour l'Intercom Déclencher des scenarios en fonction des événements et actions Disposer d'un Virtual Device pour visualiser les informations liées aux événements et actions Le Projet : Création d'une scène dédiée : à la détection de l'ensemble des événements et actions à l'exécution des scénarios conditionnés selon les événements et actions à la mise à jour d'un Virtual Device pour visualiser les informations liées aux événements et actions à tracer dans sa log les informations collectées et traitées Création d'un Virtual Device pour : visualiser les informations liées aux événements et actions éventuellement servir de source de données à GEA afin exécuter des scénarios complémentaires en les combinant aux autres données et conditions disponibles sous GEA. Pré-requis : disposer d'un Intercom Fibaro installer le plugin Intercom Fibaro Installation : Télécharger et installer le Virtual Device ci-dessous (dans sa dernière version) Télécharger et installer la Scène ci-dessous (dans sa dernière version) Télécharger l'icône ci-dessous ou fabriquer la votre Configuration : De la scène : 1) Modifier les variables utilisateurs ci-dessous : 2) Associer au VD l'icône ci-dessous ou la votre 3) Programmer la scène avec un Run Scene = Automatic avec un Max. running instances = 10 4) Modifier éventuellement les variables contenant les Smileys & textes qui sont remontés dans les labels du Virtual Device -- 464 is Device ID of the Intercom Plugin local Intercom_Device_ID = 464 -- 468 is the number of the Intercom Manager Virtual Device local VD_ID = 468 -- List of users (email and name) local UsersList = { {email= "xxxx.yyyy@zzzz.com", name = "Xxxx"}, {email= "aaaa.bbbb@cccc.com", name = "Aaaa"} } -- Number of seconds of the recording local NbRecordSec = 30 -- Debug mode local debug = false Du Virtual Device : 1) Personnaliser éventuellement les labels (Smileys & désignation) 2) Associer au VD l'icône ci-dessous ou la votre Programmer des scénarios dans la Scène : 1) Dans les parties réservées à cet effet : --[[ -- insert your code to execute --]] Programmer des scénarios dans GEA (optionnel) : 1) En utilisant les labels du VD comme déclencheur et/ou en les intégrant dans vos options GEA, comme par exemple : Détection de mouvement par l'intercom. Exemple lancer l'enregistrement de toutes les caméras y compris l'intercom sur Surveillance Station Détection de l'appui sur le bouton de sonnerie. Exemple faire sonner ma Sonos au cas ou mon téléphone est en mode avion ou mute. Déclenchement d'une action suite à la saisie d'un code valide. Exemple faire clignoter mes lampes extérieur Philipps Hue en vert Déclenchement d'une action suite à la saisie d'un code en erreur. Exemple faire clignoter mes lampes extérieur Philipps Hue en rouge et lancer l'enregistrement de toutes les caméras Détection d'une activation par bluetooth. Pour identifier l'arrivée ou le départ d'un membre de la famille. 2) Vloici quelques exemples que j'ai intégrés dans mon GEA : -- Déclaration des changements de valeurs des labals du VD Intercom Manager dans la partie %% properties 468 ui.lblLastPinError.value 468 ui.lblOpenRelay1.value 468 ui.lblMove.value -- Contrôle de la saisie des codes PIN sur l'Intercom ------------------------------------------------------- -- Eclairage de la terrasse pendant 15 secondes en rouge clignotant si erreur de saisie du code PIN GEA.add({{"!Label", id["VD_INTERCOM_MANAGER"], "lblLastPinError", ""}, {"Trigger", "lblLastPinError"}}, -1, "", {{"Label", id["VD_HUE_MANAGER_TERRASSE"], "lblTimer", "00:15"}, {"VirtualDevice", id["VD_HUE_MANAGER_TERRASSE"], 25}}, "Erreur saisie code Intercom, activation lumières terrasse en rouge clignotant") -- Eclairage de la terrasse pendant 15 secondes en vert clignotant si bonne de saisie du code PIN GEA.add({{"Label", id["VD_INTERCOM_MANAGER"], "lblOpenRelay1", "#r#Ouvert"}, {"Trigger", "lblOpenRelay1"}}, -1, "", {{"Label", id["VD_HUE_MANAGER_TERRASSE"], "lblTimer", "00:15"}, {"VirtualDevice", id["VD_HUE_MANAGER_TERRASSE"], 24}}, "Bonne saisie code Intercom, activation lumières terrasse en vert clignotant") -- Activation sur mon Synology (Serveillance Station) de l'enregistrement du flux vidéo de l'intercom ---------------------------------------- -- si détection devant la porte le portail GEA.add({{"Label", id["VD_INTERCOM_MANAGER"], "lblMove", "#r#Alerte"} ,{"Label", id["VD_CAM_GLOBAL"], "lblPresence", "#r#Absence"} ,{"Or", {"Label", id["VD_CAM_EXT_PORTAIL"], "lblCamState", "#r#Marche"}, {"Label", id["VD_CAM_EXT_PORTAIL"], "lblCamState", "#r#Partiel"} } ,{"Or", {"Label", id["VD_CAM_EXT_PORTAIL"], "lblCamRecord", "#r#Arrêt"}, {"Label", id["VD_CAM_EXT_PORTAIL"], "lblCamRecord", "#r#Partiel"} } }, -1, "Mouvement devant la caméra du portail le #date# à #time# enregistrement caméra", {{"VirtualDevice", id["VD_CAM_GLOBAL"], 10}, {"VirtualDevice", id["VD_CAM_GLOBAL"], 13} }, "Mouvement devant la caméra du portail le #date# à #time# enregistrement caméra") Pour la partie clignotement des lumières de la terrasse, j'utilise mon mes VD Philipps Hue Manager Pour la partie enregistrement du flux vidéo de l'intercom sur mon NAS Synology, j'utilise mon VD Surveillance Station Manager qui elle-même utilise mon VD HomeMode (GeoFence) Si vous souhaitez également les utiliser, vous les trouverez mes VD dans ma signature de Post. Sinon à vous d'adapter ces scénarios. Attention la fonction "Trigger" que j'utilise est une version améliorée de celle de base de GEA afin de bien vérifier quel est le label qui a provoqué le déclenchement de GEA. Vous trouverez ci-dessous le code correspondant à intégrer dans votre partie function config() de GEA. J'ai pas vérifié si dans la dernière version de GEA cette demande de correction avait été prise en compte. Je vous laisse regarder. GEA.options.trigger = { name = "Trigger", getValue=function(value) if (not value)then if (GEA.source.type == "autostart") then return "autostart" elseif (GEA.source.type == "global") then return "Global["..GEA.source.name.."]" elseif (GEA.source.type == "property") then return "Property[" ..GEA.source.deviceID .."]" elseif (GEA.source.type == "event") then return "Event["..GEA.source.event.data.deviceId.."]" end elseif (value) then if (GEA.source.type == "property") then return GEA.source.propertyName:gsub("ui.", ""):gsub(".value", "") == value end end return "other" end } Versions : V1.0 : du 16/10/2019 -> Intialisation du projet Evolutions à venir : Fournir quelques exemples de Lignes GEA utilisant le VD comme source de déclenchement des options A voir selon vos suggestions Dernière version du VD : VD : V1.0 : Intercom_Manager.vfib V1.0.json Scène : V1.0 : Intercom Manager V1.0.lua Icône :
  21. ebtjjn

    Aide en LUA (basique)

    Hello, pouvez-vous me dire pourquoi cela ne se déclenche pas à l'heure souhaitée svp ? Pour faire simple : je veux le matin déclencher une info SONOS (le bouton 5 du VD 117) et ensuite le code est commenté, vous comprendrez...!! Je sais, le code n'est pas joli mais je ne sais faire que comme ça... et même pas puisque ça ne marche pas... ;-) mais je veux bien apprendre onc toutes vos remarques constructives sont les bienvenues!! :-) Merci de votre aide. EDIT : en fait, je comprends que je n'ai pas de dédélcencheur (trigger) masi comment le mettre simplement en focntion de l'heure que je souhaite? en passant par les blocs il y a de variables locales qui sont définies puis cela passe par la fonction tempFunc()... et je ne trouve pas cela très évident et pas simple surtout...
  22. Bonjour, Qu'est ce que je fais de mal, je ne comprends pas pour quoi cela ne marche pas, la variable n'est pas crée donc le debug renvoie nil et les debug de http n'apparaissent pas ! Dans un VD avec les Net.FHttp je n'ai pas de problème ! Merci d'avance. function createGlobalIfNotExists(varName, defaultValue) if (fibaro:getGlobal(varName) == nil) then fibaro:debug("Création de la variable "..varName.." avec comme valeur par défaut "..defaultValue) newVar = {} newVar.name = varName newVar.isEnum = 0 newVar.value = defaultValue local http = net.HTTPClient() http:request("http://127.0.0.1:11111/api/globalVariables", { options = { method = 'POST', data = json.encode(newVar)}, success = function(response) fibaro:debug(varName .. " création avec succès") end, error = function(response) fibaro:debug(varName .. " ERROR !!!") end }) end fibaro:debug(varName .. " valeur "..fibaro:getGlobal(varName)) return true end
  23. SimonT

    Bug lancement scène journalière

    Bonjour Depuis quelque mois je me suis rendu compte que mes scènes qui doivent se lancer en fonction du jour de la semaine et à une heure précise ne se lance pas tout le temps, genre cela marche 1 fois sur 10 (pendant plus de 2ans cela marchait nikel) Voici ma scène: Je ne vois vraiment pas pourquoi des fois ça se lance et des fois ça ne se lance pas du tout Merci d'avance pour votre aide
  24. yoim

    Scene / Traitement Json

    Je veux tout simplement recuperer une valeur dans un decode json en Lua. C'est possible de recuperer une valeur en Lua / Json comme ceci : fibaro:debug(jsonTable.zip) Pour recuperer tout simplement le zip de mon json ? Ma valeur récupoéré est toujour nill. Merci pour votre aide. local url = 'http://ip-api.com/json',80 fibaro:debug("oki") http = net.HTTPClient() http:request(url, { options = { method = 'GET' }, success = function(p) fibaro:debug(p.status) --fibaro:debug(p.data) jsonString = json.encode(p.data) jsonTable = json.decode(jsonString) fibaro:debug(jsonTable) if(jsonTable.zip == tonumber("75000") then fibaro:debug('CP value successfully decoded') end end, error = function(err) fibaro:debug(err) end })
  25. Bonjour la communauté! Cela fait plusieurs mois que je cherche une solution...en vain. En résumé, lorsque je lance mes scènes (dodo, dehors, etc.) qui gèrent les vannes mais aussi les lumières, prises, etc.; la durée pour atteindre la température souhaitée est de 2h, ce qui est beaucoup trop long. Quand je pars de chez moi, j'aimerais par exemple que les vannes puissent s'éteindre en 15 minutes. Ce qui est étrange, c'est que lorsque je décide de lancer une vanne (sans passer par une scène), la température est atteinte en 15 minutes (900 secondes). Quelqu'un sait où je peux changer ce paramètre qui semble spécifique aux scènes? Merci beaucoup
×