Persistance valeur Alti

Bonsoir


Je me suis fais une page télémétrie en LUA.

D'abord pour planter le décors, sur le planeur (grafas maxi), il y un recepteur x8r avec module arduino (vario alti) avec openxsensor.

je récupère bien toutes les données sur la taranis(opentx 2.1.6), que j'utilisent dans un programme LUA.

La question j'ai beau activer la fonction persistant sur la variable Alt, dés que je met hors tension la radio la valeur alt+ est remise à 0.

Il y a t'il une subtilité que je ne connais pas?

La fonction "persistant" sur les variables ne fait que conserver leur valeurs quand on éteint le récepteur mais pas quand on éteint l'émetteur.

Complètement faux, persistant sert bien à sauver les valeurs à la mise hors tension de la radio (toutes les valeurs restent de toute manière si le récepteur est éteint).

Par contre les + et - ne sont pas sauvegardés, seulement la valeur "courante".

bonsoir Sacre100,
Donc la seul solution pour conserver la valeur altitude maxi est de la sauvegarder sur SD en faisant un log

Pas très pratique pour avoir une rémanence de la valeur d'un vol a l'autre.

Si tu fouilles sur les IO possibles avec Lua sur firmware 2.1.x, tu peux stocker cette valeur sur la SD et faire en sorte qu'elle soit rappelée à la prochaine mise sous tension de la radio.

Si tu passes par cette voie, je te serais reconnaissant de nous poster les lignes du code qui correspond, je n'ai pas exploré cette voie là encore mais c'est dans mes futures études.

Sinon, les variables globales mais c'est moins élégant.

bonsoir Heisenberg,

Je vais donc creuser dans ce sens, j'y avais vaguement penser mais si il y avait plus simple ... enfin
Oui pas de problème pour les lignes de code a suivre donc

Ben est ce qu'il ne peut pas tout simplement créer un nouveau capteur caculé avec le max alt et le mettre persistant ?

G

Kilrah a écrit:Complètement faux, persistant sert bien à sauver les valeurs à la mise hors tension de la radio (toutes les valeurs restent de toute manière si le récepteur est éteint).

Par contre les + et - ne sont pas sauvegardés, seulement la valeur "courante".

Je n'avais pas vu la réponse de Kilrah, dans ce cas, oui.

Kilrah a écrit:Complètement faux, persistant sert bien à sauver les valeurs à la mise hors tension de la radio (toutes les valeurs restent de toute manière si le récepteur est éteint).

Par contre les + et - ne sont pas sauvegardés, seulement la valeur "courante".

OK, je découvre, ce n'est pas ce que j'avais constaté lors de mes essais avec la 2.1 mais je te crois volontiers.
Vu la météo, je vais de tout façon faire la migration en 2.1 tout bientôt.

Gandalf a écrit:Ben est ce qu'il ne peut pas tout simplement créer un nouveau capteur caculé avec le max alt et le mettre persistant ?

G

bonsoir Gandalf,
déjà essayer marche pas non plus

merci pour vos reponses

Bonsoir

La persistance sur la variable Alt n'a pas d'intérêt, car quand on éteint la radio c'est que le modèle est au sol donc valeur Alt environ 0 .
J'ai donc creuser vers la programmation LUA pour mémorisé l'altitude maxi sur SD, j'ai trouver sur le net cette fonction.
Elle est disponible sur nos radio depuis la version 2.1.5.
Le hic c'est pour l'instant je n'arrive à la faire fonctionner qu'en lançant l’application manuellement.
C'est à dire via carte SD fichier puis exécuter.
Impossible de la lancer directement comme un fichier télémétrie (appuis long sur page) message d'erreur "Script syntax error bad argument #1 to 'read' (FILE* expect)",ceci que se soit de la radio ou compagnon.

cette fonction pour lire et écrire sur SD est io library.

La syntaxe est :

Code:


file = io.open(...)
io.read(file, ...)


Si tu utilise la syntaxe :  

Code:


file = io.open(...)
file.read(...)


ça ne marche pas car la métatable qui le permettrait n'est pas mise en oeuvre dans OpenTx.

Je prends l'info si tu vas jusqu'au bout et que tu trouves Gvin, ça va me faire gagner du temps car j'aurais bientôt besoin de cette fonction.

ce code marche très bien en le lançant depuis la SD (2/9) sur la radio
Seulement quand je l’intègre dans un code télémétrie activer par appui long sur page, le code tombe en défaut .
Si je l'active depuis SD que je referme et que je le réactive par la page télémétrie ça fonction bien

Code:

local function run(event)

 
 local Sb =         getValue(93)


  local f = io.open("test.txt")
  local str = io.read(f, 20)
  lcd.clear()
  lcd.drawText  (1,42,str , SMLSIZE)
  io.close(f)
   if Sb<0 then
   lcd.drawText(100,30, "efface",0)
   local f = io.open("test.txt", "w")
    io.write(f, "","\r")
   end
   if Sb>0   then
    lcd.drawText(100,30, "ecrire",0)
   local f = io.open("test.txt", "w")
   local foo = 1889
   io.write(f, foo,"\r")
    io.close(f)
   end
return 0
end

return { run=run }

Gvin a écrit:
bonsoir Gandalf,
déjà essayer marche pas non plus

Pourtant en théorie ça devrait. J'ai pas (encore) vérifié.

tous simplement que la max est la valeur max des capteurs pris en compte dans le calcul.
le max dans télémétrie c'est bon pour la mesure d’élément lipo .

Gvin a écrit:ce code marche très bien en le lançant depuis la SD (2/9) sur la radio
Seulement quand je l’intègre dans un code télémétrie activer par appui long sur page, le code tombe en défaut .
Si je l'active depuis SD que je referme et que je le réactive par la page télémétrie ça fonction bien
...

Ton problème est tout bête, tu ne testes pas si l'ouverture du fichier en lecture s'est bien passée ou pas :

Code:

...
  local f = io.open("test.txt")
  local str = io.read(f, 20)
...

Si l'ouverture ne se fait pas bien (fichier pas trouvé ou autre), f est nil et le io.read(f, 20) qui suit se passe mal.

Tu peux écrire quelque chose du genre :

Code:

...
  local f, str = io.open("test.txt")
  if f then
     str = io.read(f, 20)
     io.close(f)
  end
...

Ainsi, str contient soit l'erreur si l'ouverture s'est mal passée, soit le résultat de la lecture si l'ouverture s'est bien passée.

Autre chose, comme tu ne donnes pas le chemin complet du fichier lors de son ouverture, io.open cherche un fichier dans le même répertoire que le script.

LUA n'offre pas de fonction en standard de sérialisation pour conserver dans un fichier des données et pouvoir les relire facilement. Il exxiste bien une librairie json pour LUA mais elle n'est pas mise en oeuvre dans OpenTx.

Ce qu'il serait bien de faire, c'est une fonction save(...) qui crée un fichier LUA que l'on puisse relire facilement par un dofile(...).

Pour sauver les données, il pourrait suffir d'écrire un truc comme ça  :

Code:

local a = 1
local b = "string"
local c = nil
local d = true
local f = {1, 2, 3}

save("mes-data.dat", a, b, c, d, f)


Cela génèrerait le fichier suivant :

Code:

return 1, "string", nil, true, {1, 2, 3}

Et la lecture de ce fichier serait tout simplement ça:

Code:

local a, b, c, d, f = dofile("mes-data.dat")

En procédant ainsi, on profite du parser de LUA pour la lecture et on n'a qu'à écrire la fonction save d'écriture.

Quoi qu'en pensez-vous donc ?

Bon, j'ai pondu une petite fonction save(file_name, ...) qui sans être parfaite peut déjà rendre service :

Code:

local function save(file, ...)
  local f, e = io.open(file, "w")
  if not f then error(e) end
  local function lsave(sep, item, ...)
    if item == nil then return end
    t = type(item)
    if t == "number" or t == "boolean" then
      io.write(f, sep, tostring(item))
    elseif t == "string" then
      io.write(f, sep, '"', item, '"')
    elseif t == "table" then
      io.write(f, sep, "{\n")
      local tsep = ""
      for k, v in pairs(item) do
        if type(k) == "number" then
          io.write(f, tsep, "[", k, "] = ")
        else
          io.write(f, tsep, '["', k, '"] = ')
        end
        lsave("", v)
        tsep = ",\n"
      end
      io.write(f, "\n}")
    else
      error("Unsupported type " .. t)
    end
    lsave(", ", ...)
  end
  io.write(f, tostring("return "))
  lsave("", ...)
  io.write(f, "\n")
  io.close(f)
end

Le premier paramètre est le nom du fichier et les suivant (1 à n) sont les données à sauver, par exemple :

Code:

save("mydata.dat", 1, "string", true, {1, 2, 3, b = "OK", c = {0, 0, 0}}, "good")

Qui génère le fichier avec ceci dedans :

Code:

return 1, "string", true, {
[1] = 1,
[2] = 2,
[3] = 3,
["c"] = {
[1] = 0,
[2] = 0,
[3] = 0
},
["b"] = "OK"
}, "good"

Je n'ai pas mis de tabulation pour simplifier le code mais cela pourrait être ajouté moyennant quelques complications.

On peut sauver des number, des boolean, des string et des table. Les tables imbriquées sont possible. Les autres types (nil, function, userdata) ne sont pas acceptés et provoquent une erreur.

Pour la lecture, il faut simplement faire un local x, y, ... = dofile(file_name) et les données sauvées sont rechargés dans les variables, exemple :

Code:

local a, b, c, d, f = dofile("mydata.dat")

Ca fonctionne dans le simulateur, ça devrait fonctionner sur la radio, néanmoins, je ne suis pas sûr que ce soit une bonne idée de relire les données à chaque exécution de la fonction run(event) car lire le fichier prend quand même du temps.

============================================================================

En écrivant ce code, j'ai constaté deux bizarreries dans la mise en oeuvre de LUA dans OpenTx :
- la variable "arg" qui est une variable disponible quand une fonction a un nombre variable d'argument, ne l'est pas dans OpenTx
- io.write(...) et io.read(...) ne se comporte pas du tout de manière standard et le code écrit pour OpenTx ne fonctionne pas sous LUA 5.2

En ce qui concerne la variable arg, le code suivant devrait fonctionner :

Code:

function myVarargs(...)
   for k, v in pairs(arg) do
      ...
   end
endFunction

Sous OpenTx, ça ne fonctionne pas c'est pour cela que l'on ne peut pas sauver une valeur nil car j'ai dû faire un appel récursif de la fonction lsave(...) et utiliser nil comme condition terminale. Ce problème vient probablement de table.pack(...) qui n'est pas mise en oeuvre dans OpenTx, c'est dommage.

En ce qui concerne io.write(...), cela devrait correspondre à io.output():write(···), c'est à dire à écrire sur la sortie standard alors que dans OpenTx, cela correspond à la sortie sur le fichier en premier paramètre. Pour avoir du code compatible avec la plateforme LUA, il faudrait que l'on puisse écrire la chose suivante :

Code:

f = io.open("monFichier.txt", "w")
f.write(f, ...)
io.close(f)

f = io.open("monFichier.txt",)
f.read(f, ...)
io.close(f)


Voilà, voilà pour mes élucubration et découvertes de ce soir.

Sacre100 a écrit:
Ca fonctionne dans le simulateur, ça devrait fonctionner sur la radio, néanmoins, je ne suis pas sûr que ce soit une bonne idée de relire les données à chaque exécution de la fonction.../...
Voilà, voilà pour mes élucubration et découvertes de ce soir.

Je suis impatient d'essayer !!
Ça me paraît parfait pour stocker des minimas et maximas, une seule lecture au démarrage du script et une écriture quand le minima ou le maxima est dépassé.

Petit update de la fonction avec trois changements pour que ça me plaise plus.

D'une part, j'ai trouvé comment palier à l'absence de la fonction table.pack(...), c'est tout simple, il suffit d'écrire x = {...} et ça fait le boulot. Ainsi, je peux utiliser une boucle à la place de l'appel récursif de la fonction lsave et ça me plait beaucoup plus même si je n'arrive toujours pas à sauver des valeurs nil.

D'autre part, j'ai trouvé comment rendre compatible des lectures et des écritures avec OpenTx et LUA. Il suffit d'écrire faire ainsi :

Code:

local file, err = io.open("monFichier")
 if file then
   local out = lcd and io or file -- patch to make OpenTx read, write and flush compliant with "standard" LUA.
   out.read(file, 20)
   ...
   out.close(file)
 else
  -- process io.open error
 end

Finalement, j'ai fait en sorte que les string puissent contenir des " et des ', la seul limite pour les chaines, c'est qu'elles ne doivent pas contenir la séquence ]] sinon cela provoque une erreur de syntaxe à la relecture des données.

Au final, la fonction save(...) donne ça :

Code:

local function save(file, ...)
  local f, e = io.open(file, "w")
  if not f then error(e) end
  local out = lcd and io or f -- patch to make OpenTx read, write and flush compliant with "standard" LUA.
  local function lsave(item, tab)
    local t = type(item)
    if t == "number" or t == "boolean" then
      out.write(f, tostring(item))
    elseif t == "string" then
      out.write(f, "[[", item, "]]")
    elseif t == "table" then
      out.write(f, "{\n")
      local ttab =  tab .. "\t"
      local tsep = ""
      for k, v in pairs(item) do
        if type(k) == "number" then
          out.write(f, tsep, ttab, "[", k, "] = ")
        else
          out.write(f, tsep, ttab, '["', k, '"] = ')
        end
        lsave(v, ttab)
        tsep = ",\n"
      end
      out.write(f, "\n", tab, "}")
    else
      error('Unsupported type "' .. t ..'" by save(..)')
    end
  end
  out.write(f, "return ")
  local sep = ""
  for _, v in pairs({...}) do -- {...} convert varargs ... into a table (lol, so easy)
    out.write(f, sep)
    lsave(v, "")
    sep = ", "
  end
  out.write(f, "\n")
  out.close(f)
end

Voilà, voilà, à user parcimonieusement sans modération tout en sachant les limites de cette fonction (uniquement des number, des string et des table, et pas de ]] dans les string)

[EDIT] J'ai ajouté les tabulations pour avoir un fichier indenté plus facile à lire, c'est quand même plus pratique.

bonsoir

Je viens de finir ma télémesure, j'ai persister avec io library, il faut déclarer la variable au départ
et vérifier que le fichier c'est bien ouvert, bon a savoir en écriture si le fichier n’existe pas, il est créé automatiquement sous la racine de la SD.
Pour la lecture la valeur est un string, LUA a la capacité de convertir un string en nombre facilement
plus tot que des mot un exemple

Code:

local function run(event)

 local str =0
 local Sb =        getValue(93)


  local f = io.open("test.txt")
  if f then
      str = io.read(f, 20)
      lcd.clear()
  lcd.drawText  (1,42,str , SMLSIZE)
  io.close(f)
end

  if Sb<0 then
  lcd.drawText(100,30, "efface",0)
 
  local f = io.open("test.txt", "w")
    if f then
    io.write(f, "","\r")
    io.close(f)
    end
  end
  if Sb>0  then
    lcd.drawText(100,30, "ecrire",0)
  local f = io.open("test.txt", "w")--  "w" efface et écrit par dessus, "a" écrit
  if f then
  local foo = 1889
  io.write(f, foo,"\r") -- \r écrit à la suite \r\n écrit et retour à la ligne
--  io.write(f, foo, "\r\n")
    io.close(f)
  end
  end
return 0
str= str+0 --solution rapide de passer de string en nombre si la valeur str de départ est un nombre


end

return { run=run }

Ceci pour répondre a mon problème de départ la persistance de l'altitude