Questions de débutant en Quick Apps sur HC3

[Lazer]

c'est différent, mais pas tant que ça. Il n'y a pas de meilleur choix, tout dépend de ce que tu veux faire.

 

Si tu la déclares en local, elle ne sera accessible que :

- après la déclaration (je veux dire, linéairement dans le sens de la lecture du code, au moment de la précompilation avant exécution)

- uniquement dans le même fichier

 

Si tu la déclares dans quickApp, alors elle sera accessible... de partout ! Et oui :

- depuis une fonction membre de QuickApp : self.myVar

- depuis n'importe où : quickApp.myVar

 

Car en fait, quickApp, qui est l'objet instancié à partir de la classe QuickApp (notez la majuscule), est global, donc accessible de partout. Ses membres (fonctions comme variables... les fonctions étant en réalité des variables) ne sont pas privés, ils sont publics, donc accessibles de partout.

 

Quand je dis partout, je parle du QA.

Un autre QA, une scène, etc, n'y ont évidemment pas accès.

Ils peuvent juste appeler l'éxécution d'une fonction membre de QuickApp (via le mécanisme fibaro.call)

[henri-allauch]

 

il y a 14 minutes, Lazer a dit :

Quand je dis partout, je parle du QA.

Un autre QA, une scène, etc, n'y ont évidemment pas accès.

Donc qu'elle que soit le mode de déclaration : myVar ou local myVar ou self.myVar celle ci ne sera pas utilisable depuis un autre QA et donc pas de conflit avec un autre QA.

Seules les fonctions Quickapp:myFonc () sont accessibles par fibaro.call..... 

 

[Lazer]

Oui voilà

[Fredmas]

Il y a 18 heures, Fredmas a dit :

Maybe I missed something, but what is the advantage of writting the content you put in local rules table (condition='condition1',action='action1'), instead of listing this same content directly in the mainCode(self) without using a function ipairs?

 

Il y a 20 heures, jang a dit :

P.S I probably wouldn't declare conditions/actions as QuickApp methods.

Il y a 18 heures, Fredmas a dit :

Thanks for the advise. I don't know. I don't care to do it as QuickApp methods (or not) if it is a better way to code and to work, I can  But I feel it a little bit heavy...

Each new step is pushing me to do in a different better way, and this is good

 

But for this reason, I wonder why not put all conditions as a list in mainCode(), only calling QuickApp:function() for actions... (able to be called from another QA if needed).

 

I need to think more about it to clean my mind  

 

Hello @jang, I am curious, how should you do it in regards of your advise not declaring all as QuickApp methods?

From my side, as a first step of improvement (except if it is a bad idea from code and architecture point of view), after have thought about it since yesterday, I am still on listing each condition in mainCode and calling function() for each action needed.

 

[jang]

Well, all QuickApp functions declared are callable from other QAs or through the web interface as has been discussed in other posts previously.

Functions that are local to the QA I believe should be declared as just local functions.

The problem is that you don't have access to 'self' in local functions, for calling ex. self:updateProperty() self:debug() etc.

However, there is a global Lua variable that fibaro sets for us 'quickApp' that gets the value of 'self' - or the QuickApp object.

The problem with 'quickApp' is that it's not set until we exit the QuickApp:onInit() function.

 

So I use something like this.

local function foo()
   quickApp:debug("Foo")
end

function QuickApp:onInit()
   quickApp = self
   foo()
end

 

The reason they set 'quickApp' after we exit :onInit() is that the object is not considered initialised until :onInit() has run. So just be careful that you don't access self variables that you initialise in :onInit() from, in this case, 'foo'.

A purist would say we shouldn't use global variables like 'quickApp' but pass around the self value - however it tends to be a bit tedious if we only have one QuickApp object.

 

However, there is an exception (or rule). If you have QuickAppChild objects too in your QA, then you in effect have several 'QuickApps' and need to pass around the right self to your local functions. 

local function foo(self)
   self:debug("Foo")
end

class 'Child'(QuickAppChild)
function Child:onInit()
   foo(self) -- Child's self
end

function QuickApp:onInit()
   foo(self) -- QuickApp's self
end

Remember to declare 'local foo' before it's referenced in the Child:onInit() function. 

[jang]

So the example becomes

local function condition1(self) return true end
local function condition2(self) return math.random(1,3) > 1 end
local function condition3(self) return false end
local function action1(self) fibaro.call(...) end
local function action2(self) fibaro.call(...) end

local rules = {
  {condition=condition1,action=action1},
  {condition=condition2,action=action2},
  {condition=condition3,action=action2}
}

function mainCode(self)
    for _,r in ipairs(rules) do  -- Test conditions and run actions if true
       if r.condition(self) then r.action(self) end
    end
end

with the "passing around self' style.

Modifié le 24 novembre 2021 par jang

[Fredmas]

Thanks a lot for your time @jang , the explanation and the example 

And yes I prefer to keep local function and just real QuickApp when it is needed.

 

 

Today as you understood I am like that:`

function mainCode(self)
--------------------------------------------------
  if condition1 then fibaro.call(...) end
--------------------------------------------------
  if condition2 then fibaro.call(...) end
--------------------------------------------------
  if condition3 then fibaro.call(...) end
--------------------------------------------------
end

 

 

Reading again your example for better understanding, I will think and maybe change the architecture in 2 step.

Step 1 to get out actions from mainCode, and step 2 (time to think about it) to maybe apply something like in your example.

So for step 1, I will probably structure the current code like that:

local function action1(self) fibaro.call(...) end
local function action2(self) fibaro.call(...) end
local function action3(self) fibaro.call(...) end

function mainCode(self)
--------------------------------------------------
  if condition1 then action1(self) end
--------------------------------------------------
  if condition2 then action2(self) end
--------------------------------------------------
  if condition3 then action3(self) end
--------------------------------------------------
end

Thanks to that I believe the code will be easier for maintenance, and it will allow me to call function with parameters.

And in case of (clearly not needed today), I can define and call one action function from another out of this QA.

 

[Fredmas]

So as described in the previous post, I did the first step for my main QA in loop, getting all actions (now by functions with arguments) out of a big main loop keeping in only all conditions to be checked 

From reading point of view (and maintenance) it is so much better 

From performance point of view, I don't know, I am not sure. Everything is still in the same 1 seconde, but a kind of very small feeling (or doubt) that calling several functions with parameters seems to take a little bit more time (some tenth) than executing the code in the main function. Again everything is in the seconde, so it is maybe a bad feeling and not the really 

 

[971jmd]

ha la nous dépassons le stade de QA Débutant   

 

 

[Fredmas]

Non au contraire. Un non débutant ne se poserait pas ces questions. Il ferait bien dès le début 

Je continue d’apprendre et partager mes « réflexions » de jeune…

[971jmd]

j'ai des problèmes avec l'anglais alors ça n'arrange pas les choses 

 

non t'inquiète pas je me débrouille mai c'est pas facile 

 

 

Modifié le 6 décembre 2021 par 971jmd

[971jmd]

salut à tous 

 

Bon, mon petit doigt me dit que j'ai toujours rien compris au QA 

 

Un truc tout simple ouvrir fermer ou STOP rien à faire rien ne fonctionne

 

 

Et mon prochain objectif :

 

Si le volet id_279  se ferme - attendre 3sec avant de mesuré la puissance en W - et si plus de 88W -  Alors  stop -  attendre 2s puis ouverture 

 

 

 

 

Merci pour votre aide

function QuickApp:onInit()
    self:updateProperty("deviceIcon", 36)
    self:debug("onInit")
   
    vl1 = 279

  self:Raf1() 

end

function QuickApp:Raf1()
  self:updateView("power1", "text", "Volet N°1 -  "..fibaro.getValue(vl1, "power").." W")
  setTimeout(function() self:Raf1() end, 4*1000)
end


---ouverture
function QuickApp:open()
fibaro:call(279, "open")
 --- self:updateView("etat", "text", "Uverture")
self:debug("Ouverture")
end


---fermeture
function QuickApp:close()
fibaro:call(279, "close")
 --- self:updateView("etat", "text", "Fermeture")
  self:debug("Fermeture")
end


---STOP
function QuickApp:stop()
fibaro.call(279, 'stop')
self:debug("STOP")
end


function QuickApp:onInit()
    self:debug("onInit")
end

 

 

 

Modifié le 12 décembre 2021 par 971jmd

[Fredmas]

Il y a 3 heures, 971jmd a dit :

Bon, mon petit doigt me dit que j'ai toujours rien compris au QA 

Ca va venir, ça va venir 

 

 

Pour revenir à ton exemple :

- déjà tu as 2 fonctions onInit() ...

- ensuite, je ne sais pas si Raf1 est un bouton ou un label, mais à part mettre à jour son texte toutes les 4s, tu ne fais rien d'autre.

 

Nul part tu traites ton besoin décrit ici :

Il y a 3 heures, 971jmd a dit :

Si le volet id_279  se ferme - attendre 3sec avant de mesuré la puissance en W - et si plus de 88W -  Alors  stop -  attendre 2s puis ouverture  

 

Autre chose, ton QA ne fait pas de trigger ni de surveillance continue et immédiate (voir sujet déjà discuté).

Ici tu fais une boucle pour observer et agir toutes les 4s. Donc si ton volet est commandé par autre chose qu'un des boutons de ton QA (interrupteur, etc.) au milieu de ces 4s, tu ne le verras pas évidemment sauf s'il bouge encore quand ta boucle de 4s passera.

[971jmd]

Déjà je n'arrive même pas à faire la base ouverture fermeture et STOP

---ouverture
function QuickApp:open()
fibaro:call(279, "open")
 --- self:updateView("etat", "text", "Uverture")
self:debug("Ouverture")
end


---fermeture
function QuickApp:close()
fibaro:call(279, "close")
 --- self:updateView("etat", "text", "Fermeture")
  self:debug("Fermeture")
end


---STOP
function QuickApp:stop()
fibaro.call(279, 'stop')
self:debug("STOP")
end

[Fredmas]

Un truc dans le genre par exemple avec des boutons open, close and stop :

 

---ouverture
function QuickApp:open()
  fibaro.call(279, "open")
  self:debug("Ouverture")
end

---fermeture
function QuickApp:close()
  fibaro.call(279, "close")
  self:debug("Fermeture")
end

---STOP
function QuickApp:stop()
  fibaro.call(279, "stop")
  self:debug("STOP")
end

 

[971jmd]

bin c'est ce que j'ai fait mise à part les guillemets  du stop 

bizard

fibaro.call(279, 'stop')

Modifié le 12 décembre 2021 par 971jmd

[Fredmas]

Pas tout à fait non 

Pour open and close tu avais mis :

fibaro:call

et pas

fibaro.call

[971jmd]

Le problème est que la dernière fois tu m'avais aidé dans mon dernier projet, j'aurais dû mettre des commentaires et tout ça m'aurait bien aidé 

 

 

[971jmd]

bon le plus dur arrive pour moi 

 

Je cherche à réaliser une protection  ampèremétrique, choses que j'avais déjà organisé sur ma HC2 

Mais j'avoue que le passage de l'acheter trois est vraiment difficile

 

Comment volet roulant commence à descendre je surveille sa puissance en W et si elle dépasse le seuil déterminer le stop le volet roulant 

 

 

 

 

 

 

 

 

 

 

[971jmd]

en gros voila le début 

 

D'où l'importance de mettre des commentaires, la dernière fois tu m'avais bien expliqué comment mettre une Tampo je suis pas arrivé

 

function QuickApp:protection()
if (fibaro.getValue(279, "value") <= '90') ---- SI volet sous les 90%
tempo de 5s ----- attendre 5s avant de relever le puissance du vl 
 elseif (fibaro.getValue(279, "power") <= '80') --- si sup à 80w alors STOP
fibaro.call(279, "stop") ---- stop 
tempo de 5s ---- attendre 5s avant de remonter 
fibaro.call(279, "open")


end

 

Modifié le 12 décembre 2021 par 971jmd

[couillerot]

il te manque les "then"

 

Stef

[couillerot]

exemple pour la structure :

 

if ...condition1... then... bloc1
elseif ...condition2... then... bloc2
else... bloc3
end

Stef
 

[Fredmas]

il y a une heure, 971jmd a dit :

Comment volet roulant commence à descendre je surveille sa puissance en W et si elle dépasse le seuil déterminer le stop le volet roulant 

il y a une heure, 971jmd a dit :

en gros voila le début

D'où l'importance de mettre des commentaires, la dernière fois tu m'avais bien expliqué comment mettre une Tampo je suis pas arrivé

 

Alors attention, la dernière fois que nous avons discuté, ce n'était pas vraiment une tempo au sens que tu l'entends. C'est un Timeout reportant le lancement d'une fonction soit externe, soit interne à répétition.

 

Là ce que tu veux, c'est mesurer une consommation, puis agir x secondes après la mesure ? Ou attendre x secondes après le mouvement pour vérifier la mesure puis agir immédiatement ?

Bref, précise stp pourquoi faire tu souhaites ce que tu appelles "tempo" 

[971jmd]

Voilà ce que j'ai compris. : setTimeout(function()  if fibaro.getValue(279, "power") >= "80") end, 5*1000)

 

je mesure après 5 secondes 

 

 

[971jmd]

Il y a 6 heures, couillerot a dit :

exemple pour la structure :

 

if ...condition1... then... bloc1
elseif ...condition2... then... bloc2
else... bloc3
end

Stef
 

 

moi mon problème est les parenthèse et guillemet j'ai toujours du mal avec