[LUA / DOWNLOAD] Un testeur de batterie sur la radio.

Un bel exemple d'un travail collaboratif dans le plus pur esprit d'un forum.
Un outil de Dev.Fred qui me donne une idée qui se concrétise et devient fonctionnelle grâce à une cure d'amaigrissement concoctée par Sacre100 et l'implémentation de la routine de courbe de décharge par Dev.Fred.

Compatible OpenTx 2.1.x
Nécessite un capteur FLVSS
Testé sur Taranis+ / Firmware 2.1.7
MàJ du 01 fév. 2016 : v3.30

Changelog :
[v1.14] :
 Jauges(%) et tensions(V) instantanée de chaque élément.
 Jauge(%), tension(V) et tension(%) instantanées du pack.
 Nombre d'éléments.
 Tension moyenne instantanée d'un élément.
 Écart(mV) entre l'élément le plus haut et le plus bas.
 Balance(%) moyenne.

[v2.0] :
 Correction des jauges indexée sur une table générique de décharge Li-Po (précision à 5%).

[v2.10] :
 Correction des jauges indexée sur une table générique de décharge Li-Po (précision à 1%).

[v3.10] :
 Indicateurs minima de chaque élément.

[v3.20] :
 Correction des jauges indexée sur la table de décharge Li-Po du fabricant ROBBE.
 indicateurs maxima de chaque élément.
 Indicateur minima & maxima du pack total.

[v4.00] :
Identique en tout points dans les fonctionnalités à la version 3.20
Version modulaire, scindée en 2 scripts par Dev.Fred pour pouvoir récupérer les valeurs Cels dans d'autres scripts.
Cette version est à privilégier si vous êtes à l'aise avec la manipulation des scripts Lua, elle est disponible ici : [Version en 2 parties]
Sinon, il est préférable de garder la version 3.21 tout en un, plus facile à installer.

[v3.21] :
Amélioration du contraste des jauges pour Taranis non-plus, incompatible avec les versions inférieures d'OpenTX 2.1.7

[v3.30] :
Identique à la v3.21 mais compatible OpenTX 2.1.7

[v3.31] :
Identique à la v3.30 mais compatible OpenTX 2.2.0

Les copies écran sont présentées sous Companion mais tout peut évidemment être configuré directement sur la radio.
Le code est documenté pour bien comprendre quoi fait quoi et vous permettre de créer vos propres scripts aussi si vous n'avez jamais touché à la programmation Lua (Comme moi il y-a encore 2 mois).

---

1) Vérifiez que votre capteur FLVSS est correctement déclaré.
Si ce n'est pas le cas, il suffit de supprimer les capteurs de la radio et refaire une auto-détection.
Nb: A moins que vous ne l'ayez créé manuellement plutôt que de passer par une auto-détection, il est normalement correctement déclaré.

Pour le vérifier, la ligne qui nous intéresse est "Cels" et dans Companion, ça ne doit pas ressembler à ceci :


... Mais plutôt à cela :


2) Placez le script "BattChec.lua" dans le répertoire "TELEMETRY" de la radio.



3) Renseignez la page de télémétrie du modèle concerné par lequel vous souhaitez appeler ce script.



Et c'est tout, l'installation est terminée.

Pour afficher cet écran, il suffit d'être sur le bon modèle sur lequel vous avez paramétré l'écran Lua (Point N°3) et d'un appui long sur la touche page de la radio.



Ça fonctionne du 1er coup !!

---

Note 1) La télémétrie FrSky garde en mémoire sur votre écran le dernier état des cellules mesurées même si le capteur est déconnecté de la prise d'équilibrage mais reste alimenté.
Si vous débranchez une batterie 5S et rebranchez une batterie 3S au capteur sans couper l'alimentation du FLVSS, l'écran continuera d'afficher l'élément 4 et 5 par rémanence, et lecture sera faussée.
Il faut donc couper l'alimentation du FLVSS pour réinitialiser.

Note 2) La mesure du pack est une tension suivant le même procédé que les testeurs d'accu, il ne s'agit pas stricto-sensu d'une capacité (Fuel).

Note 3) Affichage et explications.

A : Marquage du minima du pack après utilisation.
B : Jauge(%) instantanée de la capacité restante du pack.
C : Jauge(%) la capacité maximum du pack détectée au branchement.
D : Pourcentage restant du pack (~Fuel restant).
E : Moyenne(V) donnée pour 1 élément.
F : Jauge(%) la capacité maximum détectée au branchement, par élément.
G : Jauge(%) instantanée de la capacité restante par élément.
H : Jauge(%) du minimum atteint par élément. (Dans cet exemple, l'élément N°4 est passé en dessous de 3V !!).
I : Écart maxi entre l'élément le plus haut et l'élément le plus bas.
J : Indication de balance globale.
K : Tensions instantanées de chaque élément.



Le script à télécharger : [BattCheck 3.30]

Le code :

Code:



---- ###############################################################
---- #                                                             #
---- #        Telemetry Lua Script for FrSky RC Taranis TX         #
---- #     LI-xx BATTCHECK v3.30 // Use it with OpenTX 2.1.7       #
---- #      Version avec table de décharge ACCU LIPO               #
---- #                                                             #
---- #                                                             #
---- #  License: Share alike                                       #
---- #  Can be used and changed non commercial                     #
---- #                                                             #
---- #  Developped by Heisenberg.                                  #
---- #  Debugged by Sacre100 (the hardest job) who succeeded       #
---- #  decreasing GC and memory use for Taranis compatibility.    #
---- #  Improved by Dev.Fred to get correct percent li-po values   #
---- #                                                             #
---- #  Credits to Dev.Fred, Kilrah, and some of other members     #
---- #  from the french forum frskytaranis.forumactif.org/         #
---- #  And especially more to Sacre100 for his patience and       #
---- #  knowledge shares.                                          #
---- #                                                             #
---- ###############################################################

---- ###############################################################
---- ################ Changer si nécessaire FR ou EN ###############
---- ################ Choose your language FR or EN  ###############
---- ###############################################################

local language = "FR"    --## (FR or EN) Nothing else


---- ###############################################################
---- ################  NE RIEN MODIFIER CI-DESSOUS  ################
---- ################ DO NOT CHANGE ANYTHING BELOW  ################
---- ###############################################################

---- ###############################################################
---- Variables
---- ###############################################################
local cellfull, cellempty = 4.2, 3.00                                      --## Cellule Li-Po considérée pleine et vide sans charge appliquée.

local voltageword, averageword = "VOLTAGE", "AVERAGE"
if language ~= "EN" then
  voltageword, averageword = "TENSION", "MOYENNE"
end

local cell = {0, 0, 0, 0, 0 ,0}                                                  --## Table des 6 éléments initialisés à 0
local cellminima = {cellfull, cellfull, cellfull, cellfull, cellfull, cellfull}  --## Table des 6 minimas initialisés au maxima (en V)
local cellmaxima = {0, 0, 0, 0, 0 ,0}                                            --## Table des 6 maximas initialisés à 0
local cellsumfull, cellsumempty, cellsumtype, cellsum = 0, 0, 0, 0               --## Déclarations & inits simples
local echX, ech100Y, ech0Y = 155, 2, 61                                          --## Position des axes X & Y de l'échelle de jauges
local echH = (ech0Y-ech100Y)                                                     --## Longueur de l'axe Y
local gaugeW, gaugeGap = 8, 1                                                    --## Largeur des jauges de cells et espacements
local i, cellmin, cellmax, cellresult = 0, cellfull, 0, 0                        --## Déclarations & inits simples
local version = "3.30"                                                           --## Version du script
local cellsumpercent, precision, blink = 0, 0, 0                                 --## Déclarations & inits simples
local cellsumpercentminima, cellsumpercentmaxima = 100, 0                        --## En %
local percentDelta                                                               --## Déclaration simples
local positions = {{3,36}, {3, 46}, {3, 56}, {44,36}, {44, 46}, {44, 56}}        --## Positionnement des icônes cels

local myArrayPercentList =                                                       --## Tableau de decharge LIPO
--{{3.000, 0}, {3.053, 1}, {3.113, 2}, {3.174, 3}, {3.237, 4}, {3.300, 5}, {3.364, 6}, {3.427, 7}, {3.488, 8}, {3.547, 9}, {3.600, 10}, {3.621, 11}, {3.637, 12}, {3.649, 13}, {3.659, 14}, {3.668, 15}, {3.676, 16}, {3.683, 17}, {3.689, 18}, {3.695, 19}, {3.700, 20}, {3.706, 21}, {3.712, 22}, {3.717, 23}, {3.723, 24}, {3.728, 25}, {3.732, 26}, {3.737, 27}, {3.741, 28}, {3.746, 29}, {3.750, 30}, {3.754, 31}, {3.759, 32}, {3.763, 33}, {3.767, 34}, {3.771, 35}, {3.775, 36}, {3.779, 37}, {3.782, 38}, {3.786, 39}, {3.790, 40}, {3.794, 41}, {3.798, 42}, {3.802, 43}, {3.806, 44}, {3.810, 45}, {3.814, 46}, {3.818, 47}, {3.822, 48}, {3.826, 49}, {3.830, 50}, {3.834, 51}, {3.838, 52}, {3.842, 53}, {3.846, 54}, {3.850, 55}, {3.854, 56}, {3.858, 57}, {3.862, 58}, {3.866, 59}, {3.870, 60}, {3.875, 61}, {3.880, 62}, {3.885, 63}, {3.890, 64}, {3.895, 65}, {3.900, 66}, {3.905, 67}, {3.910, 68}, {3.915, 69}, {3.920, 70}, {3.924, 71}, {3.929, 72}, {3.933, 73}, {3.938, 74}, {3.942, 75}, {3.947, 76}, {3.952, 77}, {3.958, 78}, {3.963, 79}, {3.970, 80}, {3.982, 81}, {3.994, 82}, {4.007, 83}, {4.020, 84}, {4.033, 85}, {4.047, 86}, {4.060, 87}, {4.074, 88}, {4.087, 89}, {4.100, 90}, {4.111, 91}, {4.122, 92}, {4.132, 93}, {4.143, 94}, {4.153, 95}, {4.163, 96}, {4.173, 97}, {4.182, 98}, {4.191, 99}, {4.200, 100}} --## Table standard (Empirique & théorique)
--{{2.8, 0}, {2.942, 1}, {3.1, 2}, {3.258, 3}, {3.401, 4}, {3.485, 5}, {3.549, 6}, {3.601, 7}, {3.637, 8}, {3.664, 9}, {3.679, 10}, {3.683, 11}, {3.689, 12}, {3.692, 13}, {3.705, 14}, {3.71, 15}, {3.713, 16}, {3.715, 17}, {3.72, 18}, {3.731, 19}, {3.735, 20}, {3.744, 21}, {3.753, 22}, {3.756, 23}, {3.758, 24}, {3.762, 25}, {3.767, 26}, {3.774, 27}, {3.78, 28}, {3.783, 29}, {3.786, 30}, {3.789, 31}, {3.794, 32}, {3.797, 33}, {3.8, 34}, {3.802, 35}, {3.805, 36}, {3.808, 37}, {3.811, 38}, {3.815, 39}, {3.818, 40}, {3.822, 41}, {3.826, 42}, {3.829, 43}, {3.833, 44}, {3.837, 45}, {3.84, 46}, {3.844, 47}, {3.847, 48}, {3.85, 49}, {3.854, 50}, {3.857, 51}, {3.86, 52}, {3.863, 53}, {3.866, 54}, {3.87, 55}, {3.874, 56}, {3.879, 57}, {3.888, 58}, {3.893, 59}, {3.897, 60}, {3.902, 61}, {3.906, 62}, {3.911, 63}, {3.918, 64}, {3.923, 65}, {3.928, 66}, {3.939, 67}, {3.943, 68}, {3.949, 69}, {3.955, 70}, {3.961, 71}, {3.968, 72}, {3.974, 73}, {3.981, 74}, {3.987, 75}, {3.994, 76}, {4.001, 77}, {4.008, 78}, {4.014, 79}, {4.021, 80}, {4.029, 81}, {4.036, 82}, {4.044, 83}, {4.052, 84}, {4.062, 85}, {4.074, 86}, {4.085, 87}, {4.095, 88}, {4.105, 89}, {4.111, 90}, {4.116, 91}, {4.12, 92}, {4.125, 93}, {4.129, 94}, {4.135, 95}, {4.145, 96}, {4.176, 97}, {4.179, 98}, {4.193, 99}, {4.2, 100}}                 --## Table Robbe originale fiable (Départ à 2.8V
{{3, 0}, {3.093, 1}, {3.196, 2}, {3.301, 3}, {3.401, 4}, {3.477, 5}, {3.544, 6}, {3.601, 7}, {3.637, 8}, {3.664, 9}, {3.679, 10}, {3.683, 11}, {3.689, 12}, {3.692, 13}, {3.705, 14}, {3.71, 15}, {3.713, 16}, {3.715, 17}, {3.72, 18}, {3.731, 19}, {3.735, 20}, {3.744, 21}, {3.753, 22}, {3.756, 23}, {3.758, 24}, {3.762, 25}, {3.767, 26}, {3.774, 27}, {3.78, 28}, {3.783, 29}, {3.786, 30}, {3.789, 31}, {3.794, 32}, {3.797, 33}, {3.8, 34}, {3.802, 35}, {3.805, 36}, {3.808, 37}, {3.811, 38}, {3.815, 39}, {3.818, 40}, {3.822, 41}, {3.825, 42}, {3.829, 43}, {3.833, 44}, {3.836, 45}, {3.84, 46}, {3.843, 47}, {3.847, 48}, {3.85, 49}, {3.854, 50}, {3.857, 51}, {3.86, 52}, {3.863, 53}, {3.866, 54}, {3.87, 55}, {3.874, 56}, {3.879, 57}, {3.888, 58}, {3.893, 59}, {3.897, 60}, {3.902, 61}, {3.906, 62}, {3.911, 63}, {3.918, 64}, {3.923, 65}, {3.928, 66}, {3.939, 67}, {3.943, 68}, {3.949, 69}, {3.955, 70}, {3.961, 71}, {3.968, 72}, {3.974, 73}, {3.981, 74}, {3.987, 75}, {3.994, 76}, {4.001, 77}, {4.007, 78}, {4.014, 79}, {4.021, 80}, {4.029, 81}, {4.036, 82}, {4.044, 83}, {4.052, 84}, {4.062, 85}, {4.074, 86}, {4.085, 87}, {4.095, 88}, {4.105, 89}, {4.111, 90}, {4.116, 91}, {4.12, 92}, {4.125, 93}, {4.129, 94}, {4.135, 95}, {4.145, 96}, {4.176, 97}, {4.179, 98}, {4.193, 99}, {4.2, 100}}                 --## Table Robbe fiable modifiée pour départ à 3.0V
---- ###############################################################
---- Calcul du pourcentage de chaque élément ; Pas de virgule
---- ###############################################################
function percentcell(targetVoltage)
  local result = 0
  if targetVoltage > cellfull or targetVoltage < cellempty then
    if  targetVoltage > cellfull then                                            --## trap for odd values not in array
      result = 100
    end
    if  targetVoltage < cellempty then
      result = 0
    end
  else
    for i, v in ipairs( myArrayPercentList ) do                                  --## method of finding percent in my array provided by on4mh (Mike)
      if v[ 1 ] >= targetVoltage then
        result =  v[ 2 ]
        break
      end
    end --for
  end --if
 return result
end


---- ###############################################################
---- #####################BOUCLE PRINCIPALE#########################
---- ###############################################################

---- ###############################################################
---- Récupération et calculs des valeurs
---- ###############################################################
local function run(event)
  lcd.lock()
  lcd.clear()

  cellmin = cellfull
  cellmax = 0

  cellResult = getValue("Cels")                          --## Appel du tableau retourné par le capteur FLVSS
  if type(cellResult) == "table" then                    --## Vérif du format de valeur retournée (Table)
    cellsum = 0                                          --## Raz cellsum (évite addition infinie)
    for i = 1, #cell do cell[i] = 0 end                  --## Réinitialisation des 6 éléments à 0
    cellsumtype = #cellResult                            --## Nombre d'éléments détectés
    for i, v in pairs(cellResult) do                     --## Boucle for qui isole chaque valeurs de la table
      cellsum = cellsum + v                              --## Addition de chaque éléments pour valeur totale du pack
      cell[i] = v                                        --## Application des valeurs de 1 à x à chaque élément de 1 à x
      if cellmaxima[i] < v then                          --## On jette les 9 1eres mesures le temps que ça se stabilise
        cellmaxima[i] = v
      end
      if cellminima[i] > v then
        cellminima[i] = v
      end
      if cellmin > v then                                --## Valeur cellmin
        cellmin = v
      end
      if cellmax < v then                                --## Valeur cellmax
        cellmax = v
      end
    end -- end for
  end -- end if

                  
  cellsumpercent = percentcell(cellsum/cellsumtype)      --## Pourcentage du pack
  if cellsumpercentmaxima < cellsumpercent then
    cellsumpercentmaxima = cellsumpercent
  end
  if cell[1]>0 then                                      --## évite un minima à 0 si la télémétrie est branchée après lancement du script
    if cellsumpercentminima > cellsumpercent then
      cellsumpercentminima = cellsumpercent
    end
  end

---- ###############################################################
---- Affichage du titre
---- ###############################################################
  lcd.drawText(24, 2, "[LI-PO BATTCHECK V", SMLSIZE)
  lcd.drawText(lcd.getLastPos(), 2, version ,SMLSIZE)                       --## Titre
  lcd.drawText(lcd.getLastPos(), 2, "]" ,SMLSIZE)                           --## Titre
  lcd.drawLine(2, 5, 21, 5, SOLID, 0)                                       --## Ligne 1 de titre
  lcd.drawLine(130, 5, 149, 5, SOLID, 0)                                    --## Ligne 2 de titre


---- ###############################################################
---- Affichage de la jauge horizontale du pack
---- Sans utiliser drawGauge pour l'ésthétique.
---- ###############################################################
  lcd.drawFilledRectangle(3, 11, cellsumpercentmaxima*44/100, 18, GREY_DEFAULT + FILL_WHITE )         --## Jauge maxima
  lcd.drawFilledRectangle(3, 11, cellsumpercent*44/100, 18,  GREY(7) )                                --## Jauge instantanée
  if cellsumpercentminima < cellsumpercent and cellsumpercentminima > 0 then                          --## Evite une surimpression qui fausserait le visuel
    lcd.drawLine(3+(cellsumpercentminima*44/100), 11, 3+(cellsumpercentminima*44/100), 28, SOLID, 0 ) --## Jauge Minima
  end

  lcd.drawRectangle(2, 10, 46, 20)                                          --## Contour de jauge (x, y, width, height)
  lcd.drawFilledRectangle (48,15,2,10)                                      --## Nez de batterie


---- ###############################################################
---- Affichage du pourcentage restant du pack
---- ###############################################################
  lcd.drawText(55,14,cellsumpercent,MIDSIZE)
  lcd.drawText(lcd.getLastPos(),16,"%",0)


---- ###############################################################
---- Affichage du tableau bas gauche des valeurs de chaque élément
---- et affichage des jauges de chaque élément
---- ###############################################################
  lcd.drawLine(38, 33, 38, 61, SOLID, GREY_DEFAULT)                                         --## Affiche le séparateur vertical

  for i = 1, 6 do                                                                           --## Aff d'un tiret pour l'illusion d'icônes de batteries
    lcd.drawLine(positions[i][1] + 1, positions[i][2] - 3, positions[i][1] + 2, positions[i][2] - 3, SOLID, 0)
    lcd.drawNumber(positions[i][1], positions[i][2]-1, i, LEFT + SMLSIZE + INVERS)          --## Aff du numéro de l'élément

    if cell[i] ~= 0 then
      blink = cell[i] < cellempty and BLINK or 0                                            --## Aff de la valeur de l'élément
      lcd.drawNumber(lcd.getLastPos() + 3, positions[i][2], cell[i]*100, PREC2 + LEFT + SMLSIZE + blink)
      lcd.drawText(lcd.getLastPos(), positions[i][2],"V",SMLSIZE + blink)
      percent       = math.floor(percentcell(cell[i]) * (echH/100))                         --## Hauteur de la jauge de l'élément
      percentminima = math.floor(percentcell(cellminima[i]) * (echH/100))                   --## Hauteur de la surjauge du minima de l'élément
      percentmaxima = math.floor(percentcell(cellmaxima[i]) * (echH/100))                   --## Hauteur du marquage du maxima

  lcd.drawFilledRectangle(echX + 2 + (i - 1) * (gaugeW + gaugeGap), (ech100Y + echH - percentmaxima), gaugeW, percentmaxima, GREY_DEFAULT + FILL_WHITE )                                     --## Jauges maxima
  lcd.drawFilledRectangle(echX + 2 + (i - 1) * (gaugeW + gaugeGap), (ech100Y + echH - percent), gaugeW, percent, GREY(7))                                                                    --## Jauges instantanées
  if percentminima < percent and percentminima > 0 then                                                                                                                                      --## Evite une surimpression qui fausserait le visuel
    lcd.drawLine(echX + 2 + (i - 1) * (gaugeW + gaugeGap), ech100Y + echH - percentminima, (echX + 2 + (i - 1) * (gaugeW + gaugeGap)) + gaugeW-1,  ech100Y + echH - percentminima, SOLID, 0) --## Jauges minima
  end
  
    else
      lcd.drawText(lcd.getLastPos() + 3, positions[i][2],"****",SMLSIZE)                    --## Ou aff * si élément absent
      lcd.drawText (echX + 5 + (i - 1)*(gaugeW + gaugeGap), ech0Y-7, "*", SMLSIZE)
    end
  end


---- ###############################################################
---- Echelle
---- ###############################################################
  lcd.drawLine(echX, ech100Y, echX, ech0Y, SOLID, GREY_DEFAULT)                                                   --## Axe Y
  lcd.drawLine(echX+1, ech0Y, echX + gaugeGap + 5*(gaugeW + gaugeGap) + gaugeW, ech0Y, SOLID, GREY_DEFAULT)       --## Axe X

  i = 10                                                                                                          --## 10 divisions d'échelle
  while (i >= 0) do
    lcd.drawLine(echX-2, (ech100Y+echH)-((echH/10)*i), echX-1, (ech100Y+echH)-((echH/10)*i), SOLID, GREY_DEFAULT) --## Traçage des divisions
    i= i-1
  end


---- ###############################################################
---- Barre de séparation verticale 2
---- ###############################################################
  lcd.drawLine(79, 10, 79, 61, SOLID, GREY_DEFAULT)


---- ###############################################################
---- Milieu d'écran
---- ###############################################################
  lcd.drawText (83,14, "PACK : ", SMLSIZE)
  lcd.drawText (lcd.getLastPos(),14, cellsumtype, SMLSIZE)
  lcd.drawText (lcd.getLastPos(),14, "S", SMLSIZE)

  lcd.drawText (83,24, voltageword, SMLSIZE)
  lcd.drawText (lcd.getLastPos(),24, " : ", SMLSIZE)
  if cellsum > 10 then
    lcd.drawNumber (lcd.getLastPos()-1,24, cellsum*10, PREC1 + LEFT + SMLSIZE)
  else
    lcd.drawNumber (lcd.getLastPos()-1,24, cellsum*100, PREC2 + LEFT + SMLSIZE)
  end
  lcd.drawText (lcd.getLastPos(),24, "V", SMLSIZE)

  lcd.drawText (83,36, averageword, SMLSIZE)
  lcd.drawText (lcd.getLastPos(),36, " : ", SMLSIZE)
  if cellsum > 0 then
    lcd.drawNumber (lcd.getLastPos()-1,36, (cellsum / cellsumtype)*100, LEFT + PREC2 + SMLSIZE)
  else
    lcd.drawNumber (lcd.getLastPos()-1,36, "0", LEFT + SMLSIZE)
  end
  lcd.drawText (lcd.getLastPos(),36, "V", SMLSIZE)

  lcd.drawText (83,46, "DELTA : ", SMLSIZE)
  lcd.drawNumber (lcd.getLastPos()-1,46, (cell[1] > 0 and (cellmax * 1000) - (cellmin * 1000) or 0), LEFT + SMLSIZE)
  lcd.drawText (lcd.getLastPos(),46, "mV", SMLSIZE)

  lcd.drawText (83,56, "BALANCE : ", SMLSIZE)
  if cell[1] > 0 then
    percentDelta = math.floor(100 - (percentcell(cellmax) - percentcell(cellmin)))
    blink = percentDelta < 90 and BLINK or 0
    lcd.drawNumber (lcd.getLastPos()-1,56, percentDelta, SMLSIZE + LEFT + blink)
    lcd.drawText (lcd.getLastPos(),56, "%", SMLSIZE + blink)
  else
    lcd.drawText (lcd.getLastPos(),56, "N/A", SMLSIZE)
  end


  if (type(cellResult) ~= "table") then
    lcd.clear()
    lcd.drawText(53,1,"TARANIS BATTCHECK V",SMLSIZE + INVERS)
    lcd.drawText(lcd.getLastPos(),1,version,SMLSIZE + INVERS)
    
    if language ~= "EN" then
      lcd.drawText(42,15,"TELEMETRIE INDISPONIBLE", BLINK + 0)
      lcd.drawText(3,30,"VERIFIEZ LA CONNECTION DU PERIPH. FLVSS",0)
      lcd.drawText(29,40,"OU EFFACEZ LE CAPTEUR [Cels]",0)
      lcd.drawText(22,50,"ET REFAITES UNE AUTO-DETECTION",0)
    else
      lcd.drawText(47,15,"TELEMETRY UNAVAILABLE", BLINK + 0)
      lcd.drawText(61,30,"CHECK FLVSS LINK",0)
      lcd.drawText(47,40,"OR ERASE [Cels] SENSOR",0)
      lcd.drawText(10,50,"AND TRY ANOTHER SENSORS AUTODETECT",0)
    end
  end


end --End local function principale
return { run = run } --Retour au départ de boucle principale


Trop fort !!!
Il faut que j'essaye !

Toi qui es assez technique, tu risques d'aimer si tu t'y colles sérieusement LapinFou.
C'est extra tout ce qu'on peut faire avec ça, dommage qu'on soit assez peu à s'y intéresser.

Mais attention, ça devient addictif quand tu es sur un projet et ça mange une partie des nuits

Bravo pour la réalisation
Bravo pour les explications
Bravo pour le partage

Je vais moi aussi l'essayer ! (et surement l'adopter !)

Heisenberg a écrit:Toi qui es assez technique, tu risques d'aimer si tu t'y colles sérieusement LapinFou.
C'est extra tout ce qu'on peut faire avec ça, dommage qu'on soit assez peu à s'y intéresser.

Mais attention, ça devient addictif quand tu es sur un projet et ça mange une partie des nuits

Je me réserve le décryptage des scripts LUA pour les longues nuits d'hiver !!

La présentation est très chouette, mais malheureusement la courbe de décharge, et donc le % de charge restante d'une Lipo, n'est pas linéaire; tu approcherais la perfection en passant par une table. 

Tu en as un exemple ici , la table de conversion est utilisable dans ton script de télémétrie et des explications sur les courbes de décharge ici.

L'idée était de faire le calcule du % restant dans un script dit model sous SCRIPTS\MIXES car la valeur retournée en output est vue comme un capteur (je n'ai pas testé ce que cela donne avec le nouveau mode de découverte). Il peut donc être utilisé ensuite pour générer une alarme.
De +, une variable globale peut être récupéré par un script de télémétrie pour l'affichage comme tu l'as fait.

Merci pour ce script qui constitue une bonne base pour ceux
qui veulent se mettre aux LUA.

J'ai intégré dans ton script la table de décharge d'une LIPO qui peut être ajusté si nécessaire.

Code:


---- ###############################################################
---- #                                                             #
---- #        Telemetry Lua Script for FrSky RC Taranis TX         #
---- #      LI-xx BATTCHECK V2 // Use it with OpenTX 2.1.x         #
---- #      Version avec table de décharge ACCU LIPO               #
---- #                                                             #
---- #                                                             #
---- #  License: Share alike                                       #
---- #  Can be used and changed non commercial                     #
---- #                                                             #
---- #  Developped by Heisenberg.                                  #
---- #  Debugged by Sacre100 (the hardest job) who succeeded to    #
---- #  decreasing GC and memory use for Taranis compatibility.    #
---- #                                                             #
---- #  Credits to Dev.Fred, Kilrah, and some of other members     #
---- #  from the french forum frskytaranis.forumactif.org/         #
---- #  And especially more to Sacre100 for his patience and       #
---- #  knowledge shares.                                          #
---- #                                                             #
---- ###############################################################

---- ###############################################################
---- ####### Changer si nécessaire LI-PO ou LI-FE & FR ou EN #######
---- ####### Change your batt. technology and your language  #######
---- ###############################################################

local battech =  "LI-PO" --## (LI-PO)
local language = "FR"    --## (FR or EN) Nothing else


---- ###############################################################
---- ################  NE RIEN MODIFIER CI-DESSOUS  ################
---- ################ DO NOT CHANGE ANYTHING BELOW  ################
---- ###############################################################

---- ###############################################################
---- Variables
---- ###############################################################
local cellfull, cellempty = 4.2, 3.00                                      --## Cellule Li-Po considérée pleine et vide sans charge appliquée.

local voltageword, averageword = "VOLTAGE", "AVERAGE"
if language ~= "EN" then
  voltageword, averageword = "TENSION", "MOYENNE"
end

local cell = {0, 0, 0, 0, 0 ,0}                                           --## Table de 6 éléments initialisé à 0
local cellsumfull, cellsumempty, cellsumtype, cellsum = 0, 0, 0, 0        --## Déclarations & inits simples
local echX, ech100Y, ech0Y = 155, 2, 61                                   --## Position des axes X & Y de l'échelle de jauges
local echH = (ech0Y-ech100Y)                                              --## Longueur de l'axe Y
local gaugeW, gaugeGap = 7, 2                                             --## Largeur des jauges de cells et espacements
local i, cellmin, cellmax, cellresult = 0, cellfull, 0, 0                 --## Déclarations & inits simples
local version = "2"                                                       --## Version du script
local cellsumpercent, precision, blink = 0, 0, 0                          --## Déclarations & inits simples
local percentDelta                                                        --## Déclaration simples
local positions = {{3,36}, {3, 46}, {3, 56}, {44,36}, {44, 46}, {44, 56}} --## Positionnement des icônes cels

local myArrayPercentList =                                                --## Tableau de decharge LIPO
{
{3.000, 0},             --## Cellule Li-Po considérée vide sans charge appliquée
{3.380, 5},
{3.580, 10},
{3.715, 15},
{3.747, 20},
{3.769, 25},
{3.791, 30},
{3.802, 35},
{3.812, 40},
{3.826, 45},
{3.839, 50},
{3.861, 55},
{3.883, 60},
{3.910, 65},
{3.936, 70},
{3.986, 75},
{3.999, 80},
{4.042, 85},
{4.085, 90},
{4.142, 95},
{4.170, 97},
{4.200, 100}            --## Cellule Li-Po considérée pleine sans charge appliquée
}

---- ###############################################################
---- Calcul du pourcentage de chaque élément ; Pas de virgule
---- ###############################################################

function percentcell(targetVoltage)
 
 local result = 5

  if targetVoltage > cellfull or targetVoltage < cellempty
    then
    -- trap for odd values not in array
      if  targetVoltage > cellfull
        then
        result = 100
      end
      if  targetVoltage < cellempty
        then
        result = 0
      end
    else
    -- method of finding percent in my array provided by on4mh (Mike)
    for i, v in ipairs( myArrayPercentList )
      do
        if v[ 1 ] >= targetVoltage
          then
            result =  v[ 2 ]
            break
          end
    end --for
  end --if
 
 return result
end


---- ###############################################################
---- #####################BOUCLE PRINCIPALE#########################
---- ###############################################################

---- ###############################################################
---- Récupération et calculs des valeurs
---- ###############################################################
local function run(event)
  lcd.lock()
  lcd.clear()

  cellmin = cellfull
  cellmax = 0

  cellResult = getValue("Cels")                          --## Appel du tableau retourné par le capteur FLVSS
  if type(cellResult) == "table" then                    --## Vérif du format de valeur retournée (Table)
    cellsum = 0                                          --## Raz cellsum (évite addition infinie)
    for i = 1, #cell do cell[i] = 0 end                  --## Réinitialisation des 6 éléments à 0
    cellsumtype = #cellResult                            --## Nombre d'éléments détectés
    for i, v in pairs(cellResult) do                     --## Boucle for qui isole chaque valeurs de la table
      cellsum = cellsum + v                              --## Addition de chaque éléments pour valeur totale du pack
      cell[i] = v                                        --## Application des valeurs de 1 à x à chaque élément de 1 à x
      if cellmin > v then                                --## Valeur cellmin
        cellmin = v
      end
      if cellmax < v then                                --## Valeur cellmax
        cellmax = v
      end
    end -- end for
  end -- end if

                  
  cellsumpercent=percentcell(cellsum/cellsumtype)        --## Pourcentage du pack



---- ###############################################################
---- Affichage du titre
---- ###############################################################
  lcd.drawText(24, 2, "[", SMLSIZE)
  lcd.drawText(lcd.getLastPos(), 2, battech, SMLSIZE)
  lcd.drawText(lcd.getLastPos(), 2, " BATTCHECK V" ,SMLSIZE)                --## Titre
  lcd.drawText(lcd.getLastPos(), 2, version ,SMLSIZE)                       --## Titre
  lcd.drawText(lcd.getLastPos(), 2, "]" ,SMLSIZE)                           --## Titre
  lcd.drawLine(2, 5, 21, 5, SOLID, 0)                                       --## Ligne 1 de titre
  lcd.drawLine(130, 5, 149, 5, SOLID, 0)                                    --## Ligne 2 de titre


---- ###############################################################
---- Affichage de la jauge horizontale du pack
---- Sans utiliser drawGauge pour l'ésthétique.
---- ###############################################################
  lcd.drawFilledRectangle(3, 11, cellsumpercent*44/100, 18, FILL_WHITE )    --## Jauge
  lcd.drawRectangle(2, 10, 46, 20)                                          --## Contour de jauge (x, y, width, height)
  lcd.drawFilledRectangle (48,15,2,10)                                      --## Nez de batterie


---- ###############################################################
---- Affichage du pourcentage restant du pack
---- ###############################################################
  lcd.drawText(55,14,cellsumpercent,MIDSIZE)
  lcd.drawText(lcd.getLastPos(),16,"%",0)


---- ###############################################################
---- Affichage du tableau bas gauche des valeurs de chaque élément
---- et affichage des jauges de chaque élément
---- ###############################################################
  lcd.drawLine(38, 33, 38, 61, SOLID, GREY_DEFAULT)                                   --## Affiche le séparateur vertical

  for i = 1, 6 do                                                                     --## Aff d'un tiret pour l'illusion d'icônes de batteries
    lcd.drawLine(positions[i][1] + 1, positions[i][2] - 3, positions[i][1] + 2, positions[i][2] - 3, SOLID, 0)
    lcd.drawNumber(positions[i][1], positions[i][2]-1, i, LEFT + SMLSIZE + INVERS)    --## Aff du numéro de l'élément

    if cell[i] ~= 0 then
      blink = cell[i] < cellempty and BLINK or 0                                      --## Aff de la valeur de l'élément
      lcd.drawNumber(lcd.getLastPos() + 3, positions[i][2], cell[i], PREC2 + LEFT + SMLSIZE+blink)
      lcd.drawText(lcd.getLastPos(), positions[i][2],"V",SMLSIZE + blink)
      percent = math.floor(percentcell(cell[i]) * (echH/100))                         --## Aff de la jauge de l'élément
      lcd.drawFilledRectangle(echX + 3 + (i - 1) * (gaugeW + gaugeGap), (ech100Y + echH - percent), gaugeW, percent, FILL_WHITE )
    else
      lcd.drawText(lcd.getLastPos() + 3, positions[i][2],"****",SMLSIZE)              --## Ou aff * si élément absent
      lcd.drawText (echX + 5 + (i - 1)*(gaugeW + gaugeGap), ech0Y-7, "*", SMLSIZE)
    end
  end


---- ###############################################################
---- Echelle
---- ###############################################################
  lcd.drawLine(echX, ech100Y, echX, ech0Y, SOLID, GREY_DEFAULT)                                                   --## Axe Y
  lcd.drawLine(echX+1, ech0Y, echX + gaugeGap + 5*(gaugeW + gaugeGap) + gaugeW, ech0Y, SOLID, GREY_DEFAULT)       --## Axe X

  i = 10                                                                                                          --## 10 divisions d'échelle
  while (i >= 0) do
    lcd.drawLine(echX-2, (ech100Y+echH)-((echH/10)*i), echX-1, (ech100Y+echH)-((echH/10)*i), SOLID, GREY_DEFAULT) --## Traçage des divisions
    i= i-1
  end


---- ###############################################################
---- Barre de séparation verticale 2
---- ###############################################################
  lcd.drawLine(79, 10, 79, 61, SOLID, GREY_DEFAULT)


---- ###############################################################
---- Milieu d'écran
---- ###############################################################
  lcd.drawText (83,14, "PACK : ", SMLSIZE)
  lcd.drawText (lcd.getLastPos(),14, cellsumtype, SMLSIZE)
  lcd.drawText (lcd.getLastPos(),14, "S", SMLSIZE)

  lcd.drawText (83,24, voltageword, SMLSIZE)
  lcd.drawText (lcd.getLastPos(),24, " : ", SMLSIZE)
  if cellsum > 10 then
    lcd.drawNumber (lcd.getLastPos()-1,24, cellsum, PREC1 + LEFT + SMLSIZE)
  else
    lcd.drawNumber (lcd.getLastPos()-1,24, cellsum, PREC2 + LEFT + SMLSIZE)
  end
  lcd.drawText (lcd.getLastPos(),24, "V", SMLSIZE)

  lcd.drawText (83,36, averageword, SMLSIZE)
  lcd.drawText (lcd.getLastPos(),36, " : ", SMLSIZE)
  if cellsum > 0 then
    lcd.drawNumber (lcd.getLastPos()-1,36, (cellsum / cellsumtype), LEFT + PREC2 + SMLSIZE)
  else
    lcd.drawNumber (lcd.getLastPos()-1,36, "0", LEFT + SMLSIZE)
  end
  lcd.drawText (lcd.getLastPos(),36, "V", SMLSIZE)

  lcd.drawText (83,46, "DELTA : ", SMLSIZE)
  lcd.drawNumber (lcd.getLastPos()-1,46, (cell[1] > 0 and (cellmax * 1000) - (cellmin * 1000) or 0), LEFT + SMLSIZE)
  lcd.drawText (lcd.getLastPos(),46, "mV", SMLSIZE)

  lcd.drawText (83,56, "BALANCE : ", SMLSIZE)
  if cell[1] > 0 then
    percentDelta = math.floor(100 - (percentcell(cellmax) - percentcell(cellmin)))
    blink = percentDelta < 90 and BLINK or 0
    lcd.drawNumber (lcd.getLastPos()-1,56, percentDelta, SMLSIZE + LEFT + blink)
    lcd.drawText (lcd.getLastPos(),56, "%", SMLSIZE + blink)
  else
    lcd.drawText (lcd.getLastPos(),56, "N/A", SMLSIZE)
  end


  if (type(cellResult) ~= "table") then
    lcd.clear()
    lcd.drawText(53,1,"TARANIS BATTCHECK V",SMLSIZE + INVERS)
    lcd.drawText(lcd.getLastPos(),1,version,SMLSIZE + INVERS)
    
    if language ~= "EN" then
      lcd.drawText(42,15,"TELEMETRIE INDISPONIBLE", BLINK + 0)
      lcd.drawText(3,30,"VERIFIEZ LA CONNECTION DU PERIPH. FLVSS",0)
      lcd.drawText(29,40,"OU EFFACEZ LE CAPTEUR [Cels]",0)
      lcd.drawText(22,50,"ET REFAITES UNE AUTO-DETECTION",0)
    else
      lcd.drawText(47,15,"TELEMETRY UNAVAILABLE", BLINK + 0)
      lcd.drawText(61,30,"CHECK FLVSS LINK",0)
      lcd.drawText(47,40,"OR ERASE [Cels] SENSOR",0)
      lcd.drawText(10,50,"AND TRY ANOTHER SENSORS AUTODETECT",0)
    end
  end


end --End local function principale
return { run = run } --Retour au départ de boucle principale

Edit a écrit:J'ai déclaré la table en dehors de la fonction comme indiqué par Sacre100 + j'ajoute le point {3.380, 5}

Mieux vaut mettre la table myArrayPercentList à l'extérieur de la fonction, cela décharge le Garbage Collector et c'est d'autant mieux avec OpenTx.

Avec OpenTx, mieux vaut avoir un script qui utilise un peu plus de mémoire au chargement que d'avoir un script qui augmente son usage de la mémoire à l'exécution. On contrôle mieux les choses et au final, on a moins de problème d'usage de la mémoire.

Juste une question au sujet de ta recherche dans la table, 3.1v doit te donner 0% ou 10% ?

Bien vu, il manque un point.



J'ajoute {3.380, 5}

Si je fais tourner le script , j'ai maintenant:
3.0->0%
3.3->5%
3.4->10%

Maintenant, descendre en dessous de 30%, ce n'est pas raisonnable il me semble.

Ma question reste la même, 3.1 doit donner 0% ou 5% Avec ta boucle for, 3.1 donne 5%, je voulais être sur que c'est bien ce que tu veux.

Merci Dev.Fred pour la correction.
Je l'ai refait en v2.1 avec tous les % de 0 à 100, ainsi, la question des 3.1 ne se posera plus, ça fera 2%  
J'essaierai demain sur la radio, j'updaterais le 1er message en fonction de si ça passe bien avec une table complète ou ta version de 5 en 5.

Je vais aussi vérifier si ça peut supporter une seconde table spécifique au Li-Fe, voire même une 3eme pour le Li-Ion sans que ce ne soit trop pour la radio capricieuse en mémoire.

Une petite question : Dans la fonction percentcell, tu déclares local result = 5.
Il y'a une bonne raison pour que ce ne soit pas zéro ?

Heisenberg a écrit:... Une petite question : Dans la fonction percentcell, tu déclares local result = 5. ...

Ca, c'est une bonne question, et n'aurait-il pas tout intérêt à être 100 ?.

Ce n'est plus utile, il suffit de simplement déclarer  "local result".
C'est une survivance d'un traitement qui était fait auparavant dans cette fonction.
J'ai reçu ce script de Gandalf que je remercie encore au passage.

Le sujet a déjà été débattu mais la mesure de la tension de la batterie d'un avion en vol est très problématique en raison de la resistance interne de l'accu.
La sonde de mesure voit U-RI alors que l'on veut accéder à U. Il faut couper le moteur pour se rapprocher de la mesure de U.
Je doute que l'écran de testeur puisse être lisible en vol, en tout cas ce n'est pas du tout conseillé de quitter des yeux son modèle, donc on va pourvoir lire U avant et après le vol.
Reste que l'on se base sur une courbe de décharge théorique, qui ne correspond pas à l'accu utilisé, qui de plus s'en éloignera au fur et à mesure de son vieillissement et que cette caractéristique dépend de la température de l'accu.
Je doute, même si c'est satisfaisant pour l'esprit, qu'une courbe même défini avec 100 points, change fondamentalement le problème de précision de cette mesure.
En tout cas rien ne vaut les tests pratiques pour valider, comme tu veux le faire.

N'oubliez pas quand même que nos radios n'ont pas des processeurs dual-core qui tourne à plusieurs Ghz, tout comme elles n'ont pas plusieurs Giga de mémoires, alors on peut se retrouver rapidement avec des scripts qui tournent très bien dans le simulateur mais plus du tout sur la radio. Mais on arrive quand même à s'en sortir si l'on écrit un code concis, peu gourmand en mémoire et qui en fait le moins possible pour le même résultat.

Par exemple, pour cette fonction, on peut se demander si le voltage sera plus souvent haut ou bas.

Si la réponse est généralement bas, on peut écrire la fonction en faisant une boucle ascendante :

Code:

function percentcell(targetVoltage)
  for i, v in ipairs(myArrayPercentList)
  do
    if v[1] >= targetVoltage
    then
      return v[2]
    end
  end
  return 100
end

Au contraire, si l'on pense que le voltage sera généralement élevé, on fera plutôt une boucle descendante :

Code:

function percentcell(targetVoltage)
  for i = #myArrayPercentList - 1, 1, -1
  do
    if myArrayPercentList[i][1] < targetVoltage
    then
      return myArrayPercentList[i + 1][2]
    end
  end
  return 0
end

Je dis ceci juste illustrer le genre de chose que l'on peut faire pour arriver à faire tourner des scripts conséquent sur des systèmes limités comme le sont nos radios.

NB. Cette écriture ne fonctionne correctement que si la table a au moins deux éléments, le minimum et le maximum.

Je suis personnellement passé a une version light en terme de nombre de valeur dans l'array et un test de delta voltage pour ne passer dans la routine que si le voltage a changé.

A coté de ça, je mesure a la fois la valeur instantanée en vol, mais je mémorise aussi la valeur la plus basse. Si l'écart entre les deux valeurs est trop grand, c'est que mes lipos ne sont pas taillée pour la charge réele.

G

Sacre100 a écrit:

Heisenberg a écrit:... Une petite question : Dans la fonction percentcell, tu déclares local result = 5. ...

Ca, c'est une bonne question, et n'aurait-il pas tout intérêt à être 100 ?.

A l'origine, j'avais fait ça pour que le script renvoi une valeur (incorrecte certes, mais connue à l'avance et non nulle) quant aucune lipo n'est connecté, ça me permettait de savoir que tout fonctionne bien niveau script

G

Gandalf a écrit:.../...je mémorise aussi la valeur la plus basse. Si l'écart entre les deux valeurs est trop grand, c'est que mes lipos ne sont pas taillée pour la charge réele.

G

J'aurais bien vu quelque chose de simple et visuellement parlant dans ce genre si la mémoire suit...

J'ai une 6S 30C 5800 sur laquelle 2 éléments chutent à 2,5V quand je tire 100A.
Il m'a fallu du temps pour comprendre pourquoi mes perfs n'étaient pas correcte, avec ce genre de fonctionnalité qui garde un visuel du minima une fois l'avion posé, ça s'éclaircit.

PS : J'ai mis à jour le 1er message de ce fil de discussion avec la table de décharge et le retrait du choix Li-Fe.

Cool!

Pour info:

Heisenberg a écrit:
1) Votre firmware doit être compatible Lua.
Si ce n'est pas le cas, re-téléchargez via Companion, votre firmware avec l'option de compilation Lua cochée :

Faux, l'option lua ne concerne que les mixer scripts. Les scripts one-time, fonction et télémétrie sont toujours dispos même sans l'option.

Heisenberg a écrit:
Note 1) [i]La télémétrie FrSky garde en mémoire sur votre écran le dernier état des cellules mesurées même si le capteur est déconnecté de la prise d'équilibrage.
Si vous débranchez une batterie 5S et rebranchez une batterie 3S au capteur sans couper l'alimentation, l'écran continuera d'afficher l'élément 4 et 5 par rémanence, et lecture sera faussée.
Il faut donc couper l'alimentation pour réinitialiser.

Pour moi à chaque fois que je change de batterie le script passe par la page "télémétrie non disponible" et après quelques secondes affiche la nouvelle batterie correctement. Si ce n'était pas le cas une RAZ de la télémétrie suffirait, pas besoin d'éteindre complètement.

Heisenberg a écrit:...
J'aurais bien vu quelque chose de simple et visuellement parlant dans ce genre si la mémoire suit...

...

Ne t'inquiète pas, il faut batailler un peu mais on arrive à faire tourner des choses assez conséquentes sur la Taranis : https://frskytaranis.forumactif.org/t1154-script-lua-pour-calculer-le-cg-centre-de-gravite

J'ai ajouté la fonctionnalité des minimas pour avoir une indication de la santé des éléments après un vol.
Et ça marche très bien sur la radio



Je voulais en profiter pour tenter un joli gris anthracite et j'ai voulu tester :
local function GREY(x)
 return (x % 16) * 0x1000
end
Que j'ai trouvé dans ce message (comme quoi, même sans réponse, un an après il sert !)
Ça devait aller avec les firmwares précédents mais pas en 2.1.3, le gris reste noir et amer comme la vie
On se contentera donc d'un gris standard.

Heisenberg a écrit:...
Que j'ai trouvé dans ce message (comme quoi, même sans réponse, un an après il sert !)
Ça devait aller avec les firmwares précédents mais pas en 2.1.3, le gris reste noir et amer comme la vie
On se contentera donc d'un gris standard.

Meuh non, tout ce que tu as trouvé à l'adresse que tu indiques, a été rendu disponible dans LUA (par Bertrand sauf erreur). Donc inutile de redéfinir GREY, BOLD, FIXEDWIDTH, FORCE, ERASE, ROUND, il sont là sans avoir besoin de faire quoique ce soit.

Il n'y a que CONDENSED = 0x08 qui n'a pas été rendu dispo, je ne sais plus pourquoi.

Comme dirait un célèbre sportif, l'eau cool a coulé.

Voilà qui change tout !!
Mais alors, une Taranis standard (Non-Plus) qui a un écran de 4 niveaux de gris interprète comment ces 16 nuances ?
Et est-ce implémenté dans la V 2.0.17, histoire de maximiser la compatibilité de la version en cours de prépa ?

Y-a-t'il une doc quelque-part qui indique comment utiliser ces attributs ?

Heisenberg a écrit:Mais alors, une Taranis standard (Non-Plus) qui a un écran de 4 niveaux de gris interprète comment ces 16 nuances ?

Aucune idée, m'en fout, ça marche sur ma pas-plus, j'ai plusieurs niveau de gris (peut-être 4, je ne le savais même pas).

Heisenberg a écrit:Et est-ce implémenté dans la V 2.0.17, histoire de maximiser la compatibilité de la version en cours de prépa ?

Octobre 2014 : https://github.com/opentx/opentx/issues/1805

Heisenberg a écrit:Y-a-t'il une doc quelque-part qui indique comment utiliser ces attributs ?

Pas à ma connaissance sauf ceci : https://frskytaranis.forumactif.org/t1350-lcd-draw-quelques-attributs-caches#12603