Anthias
mail

arduino

Rolex calculée par Nextion

Nextion


Introduction
L'absence des fonctions trigonométriques
Première méthode : 60 positions
Deuxième méthode : 0 ... 360 degrés
Aiguille simpliste
Aiguille complexe

Rolex calculée par Arduino arduino

Retour page principale Nextion arduino

Maj : 24/06/19

Abstract :
How to use trigonometric functions on a device with this implementation missing.
Is it a good idea to try making complex calculations on a Nextion?
Other solution, Arduino does the job, and Nextion only displays results.

Résumé :
Comment utiliser des fonctions trigonométriques sur un appareil sans cette implémentation ?
Est-ce une bonne idée que d'essayer de faire des calculs complexes sur un Nextion ?

Autre solution, Arduino fait le travail et Nextion n’affiche que les résultats.

arduino  Introduction

Cette application est une démonstration d’affichage complexe sans Arduino, tous les calculs étant faits par le Nextion, montrant comment contourner les limites du système et calculer des aiguilles évoluées, copie la plus exacte possible des vraies. Cela montre les diverses méthodes pour remplacer laborieusement les fonctions trigonométriques absentes.
Le principe est d’afficher un fond d’écran (c’est extrêmement rapide) sur lequel se posent les couches d’aiguilles calculées. Un éclaté permet de comprendre la construction des aiguilles.
Mon fond d’écran est une image bricolée sous Photoshop, s’inspirant des nombreuses photos du Net (un artiste ferait bien mieux, je suis preneur…).
Toutefois, la lourdeur de ces méthodes montre que ce n’est pas la bonne solution pour résoudre les problèmes d’affichage graphique, il est considérablement plus facile de tout calculer avec l’Arduino et d’envoyer une série d’une centaine de lignes et de cercles, mais cela prend beaucoup de temps à 115 kb.
Le Nextion possède une commande pour rafraîchir la page, mais malheureusement pas de commande pour bloquer l’affichage pendant l’écriture dans un tampon, ce qui provoque des scintillements.

D’autres afficheurs permettent d’écrire dans une page tout en en affichant une autre et de commuter instantanément quand la page est terminée, mais pas le Nextion.
Vous pouvez faire tourner ces exemples sur le simulateur seul.

baro

 Haut de page

arduino  L'absence des fonctions trigonométriques

Dans toutes les applications graphiques, vous trouverez le même principe :
Afficher instantanément (temps négligeable !) une image incluse dans le <.HMI>, élaborée sous Photoshop comme fond d’écran.
Poser par-dessus les couches d’objets calculés.

Créer une aiguille réduite à un pixel d’épaisseur est simple, mais ce n’est pas très joli :
La fonction line suffit en lui indiquant coordonnées de départ, d’arrivée, et la couleur.
Les coordonnées se calculent par les fonctions sinus alpha et cosinus alpha (voir plus loin).

Pour épaissir l’aiguille c’est un peu plus compliqué :
Il faut calculer les coordonnées des extrémités des vecteurs perpendiculaires à l’axe initial, de longueur « d », distance du nouveau segment parallèle à l’initial.
On utilisera pour cela sinus (alpha + 90°) et cosinus (alpha + 90°), pour chaque « d » nécessaire.
Exemple pour une épaisseur de 5 (valeur toujours impaire car on ajoute des segments de part et d’autre de l’initial) : d = 2 , 1, -1 ,-2
Pour la pointe triangulaire, vous verrez que c’est un peu plus compliqué, car les segments ne convergent pas sur la pointe mais en décalé pour éviter les effets de moirage (l’éclaté le montre bien, en espaçant les segments ajoutés). Cela est expliqué dans un chapitre suivant "aiguille complexe".

Le cœur des programmes est dans l’onglet timer qui lance le calcul de chaque nouvelle page au changement de condition angulaire.
J’utilise les diverses méthodes possibles pour calculer les indispensables sinus et cosinus absents.
Cela impose d’utiliser l’EEPROM car il est impossible d’exploiter la RAM de l’ESP32, ce qui impose la version enhanced, la basique ne disposant pas de mémoire.

Le principe général est de calculer des tables (voir les exemples sur Arduino) et de récupérer le résultat sur le terminal, puis de faire un copier-coller dans la page d’appel du Nextion.
Exemple de création de la table :
wepo  « valeur 0 calculée », 0 // 0 = première adresse
wepo  « valeur 1 calculée », 4 // 4 = deuxième adresse
etc.
La lecture et l’écriture sur le Nextion se fait par bloc de quatre octets (64 bits), il faut exploiter au maximum cet espace pout l’efficacité maximale.

Haut de page

arduino Première méthode : 60 positions

Première méthode, pour des aiguilles d’horloge, il suffit de 60 positions.
Chaque valeur stockée contiendra sinus et cosinus ainsi :
(30000 * sinus Alpha) + 65536 * (30000 * cosinus Alpha)
Ce facteur 30000 permet d’exploiter au mieux la dynamique pour contourner l’absence de valeurs flottantes, en faisant les calculs en entier pour diviser au dernier moment et récupérer des positions avec le meilleur arrondi 0 < X < 800  et 0 < Y < 480.
Dans 2 octets l’espace est de +/- 32768, la valeur +/- 30000 est le compromis le plus pratique.
Pour récupérer les valeurs utiles, il suffira de faire :

Ne pas confondre < % > = modulo, et < / > = divise.
C’est tout simple, il ne reste ensuite qu’à bricoler les valeurs.
var.val =  repo minute *4
X.val = var.val%65536  (ou %0x10000 en hexa)
Y.val = var.val/65536 (ou /0x10000)

Haut de page

arduino Deuxième méthode : 0 ... 360 degrés

Deuxième méthode plus générale pour calcul 0 ... 360 degrés.
Il n’est évidemment pas possible d’utiliser 360*4 octets alors que le Nextion n’en offre chichement que 1024…
Il faudra donc ruser en n’utilisant que 90 valeurs (donc 360 octets), le plus astucieux étant de ne stocker que les sinus multipliés par un énorme coefficient.
Voici le programme minimal de calcul de la table sur Arduino :
 

for ( sec=0; sec<91; sec++)
    {
    Int x0 = 1000000 * (sin (k*(sec))) ;
    Serial.print ("wepo ") ;
    Serial.print (x0) ;
    Serial.print (",") ;
    Serial.println (4*sec) ;
    }

 

Tous les sinus et cosinus d’un angle quelconque peuvent être déduits de cette table.
Pour cela, il faut commencer par faire un modulo 360, puis choisir l’un des quatre quadrants pour déterminer le signe et calculer la valeur des sinus et cosinus (avec une deuxième lecture décalée)
[0 .. 90], ou [90 .. 180], ou [180 .. 270],  ou [270 .. 360]


C’est très simple, mais l’absence de fonction est très lourde, il faut répéter ce gros bloc de code à chaque appel d'une fonction trigonométrique !
Voici la mise en place pour un seul angle :

On commence toujours par multiplier avant de diviser pour ne pas perdre en résolution (pour simplifier, je n’ai pas fait d’arrondi), le Nextion utilisant 32 bits pour un entier étant de +/- 2 147 483 648, il y a de la place.
Il n’y aurait rien à gagner à stocker sinus et cosinus à la même adresse (comme pour la pendule) car de toute manière, il faudra passer par le choix du cadran, et que la lecture en EEPROM est très rapide.

 

Il n’existe pas de méthode plus simple et efficace à ma connaissance.

if(angle.val<90)
{
  angS.val=angle.val
  ks.val=1000000
  angC.val=90-angle.val
  kc.val=-1000000
}else if(angle.val<180)
{
  angS.val=180-angle.val
  ks.val=1000000
  angC.val=angle.val-90
  kc.val=1000000
}else if(angle.val<270)
{
  angS.val=angle.val-180
  ks.val=-1000000
  angC.val=270-angle.val
  kc.val=1000000
}else
{
  angS.val=360-angle.val
  ks.val=-1000000
  angC.val=angle.val-270
  kc.val=-1000000
}
///
repo sin.val,4*angS.val
sin.val*=230
sin.val/=ks.val
sin.val+=400
//
repo cos.val,4*angC.val
cos.val*=230
cos.val/=kc.val

cos.val+=240

Haut de page

arduino Exemple : Aiguille simpliste

Pour illustrer l’intérêt d’utiliser les fonctions sinusoïdales en graphisme, nous allons montrer comment créer des aiguilles complexes sur un cadran de montre ou de galvanomètre.
Il est très facile de dessiner une aiguille simplifiée, limitée à un simple segment d’un pixel :

Il faut d’abord définir les diverses grandeurs.
° Le centre, l’axe de l’aiguille, de coordonnées Xc, Yc
° La longueur de l’aiguille R1 (en nombre de pixels, toujours positif)
° La base de l’aiguille R0.
°° Si R0 = 0, l’aiguille part du centre.
°° Si R0 > 0 (avec R0<R1) aiguille décalée du centre.
°° Si R0 < 0, l’aiguille dépasse vers l’arrière comme la trotteuse de la Rolex.
° Il ne reste plus qu’à fixer l’angle Alpha (en choisissant ce que l’on veut comme angle 0 degré) et nous avons tout pour calculer le segment minimaliste de notre aiguille de 1 pixel d’épaisseur, de coordonnées X0, Y0 et X1,Y1.
Le calcul des coordonnées est élémentaire :

X0= Xc + R0 * sin (Alpha) Y0= Xc + R0 * cos (Alpha) X1= Xc + R1 * sin (Alpha) Y1= Xc + R1 * cos (Alpha)

Une seule instruction crée ce segment sur le Nextion : line X0, Y0, X1,Y1, color

Haut de page

arduino Aiguille complexe

L’opération se complique maintenant pour créer une aiguille épaisse.

Cette application est une démonstration d’affichage complexe sans Arduino, tous les calculs étant faits par le Nextion, montrant comment contourner les limites du système et réaliser des calculs basés sur des sinus cosinus qui n’existent pas dans le Nextion.
Le principe est d’afficher un fond d’écran (c’est extrêmement rapide) sur lequel se superposent les couches d’aiguilles calculées. Un éclaté permet de comprendre la construction des aiguilles.

Pour tracer des segments parallèles au segment de l'aiguille de base, le principe sera toujours le même :
Une fois que les extrémités de l'aiguille de base auront été calculés, on va tracer des segments perpendiculaires à cette aiguille de base de longueur égale à la distance que l'on veut fixer.
Si par exemple on veut faire une aiguille pleine, la distance des diverses parallèles sera de 1 pixel.
Dans l'exemple donné qui montre les aiguilles éclatées, le curseur permettra de faire varier l'espace entre les parallèles.
Pour calculer ces segments perpendiculaires, il suffit de prendre l'angle du segment de base et de lui rajouter 90 degrés. Les mêmes fonctions sinusoïdales que pour le calcul des aiguilles de base donneront les extrémités de ce segment.
Par ces deux extrémités, on fera passer la parallèle choisie. Si par exemple on veut des aiguilles de 11 pixels d'épaisseur, on fera une boucle pour les distances de la parallèle à l'aiguille de base entre + 5 et - 5 , et on obtiendra ainsi les 10 parallèles qui entourent l'aiguille de base.

SinCos

Avec cette méthode il est possible de créer n’importe quelle aiguille tarabiscotée.

Haut de page

arduino Le programme de démonstration des aiguilles complexes

Voici un logiciel de démonstration qui montre en pratique comment se construisent les aiguilles, en mode très ralenti et éclaté.
Le curseur de droite permet de régler l’espacement de l’éclatement, au minimum la distance est de 1 pixel correspondant à une aiguille normale.
Le cœur des pages et dans le timer tm0 qui contient le plus gros du logiciel qu’il faudra comprendre.

Après installation du logiciel Nextion Editor v0.53 (mai 2109, ou plus récent), vous pouvez le tester sans avoir un vrai Nextion en utilisant le mode simulateur incorporé.
Ce logiciel fonctionne bien, le seul reproche lors de la compilation ou debug est que les messages d’erreur sont trop peu explicites et parfois confus.
Il faut développer par petites étapes, tester et en cas d’erreur repartir de la dernière version sans bug pour avancer.
Les warnings sont souvent peu clairs, mais il faut essayer de tous les éliminer.

Dans l'éditeur, il faut d’abord déclarer le hardware, 7 pouces enhanced, horizontal. (La version "basic" non enhanced ne peut absolument pas fonctionner par manque de mémoire.)

Une fois le programme chargé, lancez Debug et testez toutes les possibilités avant de décortiquer le logiciel.

Focalisez-vous d’abord sur le timer tm0 qui contient le cœur du logiciel et fixe le temps entre les actions.

Tous les détails sont dans les logiciels joints.

Vous trouverez tous les logiciels à jour dans cette page :

eclate

Haut de page

© Christian Couderc 1999-2019     Toute reproduction interdite sans mon autorisation


* Page vue   104   fois       IP : 100.24.122.228

 Haut de page         Dernière retouche le 27 Juin 2019 à 15 h         Retour page précédente

   Collector