Programmation servo pour une gauge non linéaire

Questions de programmation / Offset FSUIPC et IOCP

Re: Programmation servo pour une gauge non linéaire

Messagede FiX » Mer 2 Juil 2014 17:43

Bon, je me suis un peu aéré l'esprit avec la gauge RPM.
Finalement c'était pas complètement linéaire (juste 2 segments), mais là, bizarrement, c'est passé comme une lettre à la poste, et la gauge est bien fluide.

https://vimeo.com/99709219



Code: Tout sélectionner

Var 0000, name init, Value 0
{
  &rpm_servo = 240   
}

Var 0020, name rpm_servo, Link USB_SERVOS, Output 4, PosL 210, PosC 600, PosR 1000     // servo gauge RPM
{
  IF &rpm_servo < 240
  {
    &rpm_servo = 240   
  }
  IF &rpm_servo > 925
  {
    &rpm_servo = 925   
  }
}

Var 0021, name rpm_scaler, Link FSUIPC_INOUT, Offset $08C8, Length 2

Var 0022, name prop_rpm, Link FSUIPC_INOUT, Offset $0898, Length 2     // 0-16384 (100%) x rpm scaler/65536
{
  L0 = &prop_rpm * &rpm_scaler     // calcul pour rpm
  &rpm = L0 / 65536     // calcul pour rpm
  IF &rpm < 2000
  {
    L1 = &rpm * 0.2
    &rpm_servo = 210 + L1
  }
  IF &rpm >= 2000
  {
    L1 = &rpm * 0.23
    &rpm_servo = 150 + L1
  }
}

Var 0023, name rpm     // calcul pour rpm
{
  L0 = &prop_rpm * &rpm_scaler
  &rpm = L0 / 65536
}




Allez, je me remet sur l'anémo...
i7 2600k/P8P67pro/16Go PC3 17000/RX 580/SSD 250 Go et 120Go/W10x64
https://www.facebook.com/cessna150.sim
Avatar de l’utilisateur
FiX
 
Messages: 4664
Inscription: 8/01/10
Localisation: Reims/Maubeuge

Re: Programmation servo pour une gauge non linéaire

Messagede FiX » Mer 2 Juil 2014 19:09

Bon, cette petite pause a fait du bien, ça va tout de suite mieux avec l'anémo!

Code: Tout sélectionner
Var 0000, name init, Value 0
{
  &servo_ias = 990   
}

Var 0015, name servo_ias, Link USB_SERVOS, Output 6, PosL 190, PosC 515, PosR 990     // servo air speed
{
  IF &servo_ias < 190
  {
    &servo_ias = 190   
  }
  IF &servo_ias > 990
  {
    &servo_ias = 990   
  }
}

Var 0016, name ias_fs, Link FSUIPC_INOUT, Offset $02BC, Length 4     // offset IAS x128
{
  &IAS_conv = &ias_fs / 128
  IF &IAS_conv <= 40
  {
    L0 = &IAS_conv * 2.05
    &servo_ias = 980 - L0
  }
  IF &IAS_conv > 40
  {
    IF &IAS_conv <= 50
    {
      L0 = &IAS_conv * 4.6
      &servo_ias = 1058 - L0
    }
  }
  IF &IAS_conv > 50
  {
    IF &IAS_conv <= 70
    {
      L0 = &IAS_conv * 5.8
      &servo_ias = 1142 - L0
    }
  }
  IF &IAS_conv > 70
  {
    IF &IAS_conv <= 90
    {
      L0 = &IAS_conv * 7.35
      &servo_ias = 1250.5 - L0
    }
  }
  IF &IAS_conv > 90
  {
    IF &IAS_conv <= 120
    {
      L0 = &IAS_conv * 7.73
      &servo_ias = 1285 - L0
    }
  }
  IF &IAS_conv > 120
  {
    L0 = &IAS_conv * 8.4
    &servo_ias = 1365 - L0
  }
}

Var 0017, name IAS_conv     // IAS en knots


C'était pourtant pas plus compliqué que le compte tour (juste plus de segments), je ne sais pas pourquoi je me suis galéré comme ça avec le badin.
Donc là, j'ai juste découpé en 6 tronçons avec la bonne équation cette fois-ci, mais toujours en utilisant la valeur IAS convertie (donc divisée par 128 par rapport à l'offset de FS).
Je n'ai plus les soucis de passage d'un segment à l'autre comme hier, par contre on a toujours le manque de fluidité d'un noeud à l'autre.
Donc maintenant, je vais recommencer sans utiliser l'IAS convertie en noeud, on va voir ce que ça donne.

L'étape suivante ça sera d'essayer de faire un rattrapage de jeu, je perds effectivement 4 pas de servo (environ 1 noeud sur la gauge) quand on va dans un sens puis dans le sens opposé.
Et ensuite voir comment fonctionne le timer et si ça peut servir.



Au fait, petite question: on est bien d'accord que pour ce type de gauge, la valeur déclarée "posC" dans la variable link USB_SERVO ne sert à rien?
i7 2600k/P8P67pro/16Go PC3 17000/RX 580/SSD 250 Go et 120Go/W10x64
https://www.facebook.com/cessna150.sim
Avatar de l’utilisateur
FiX
 
Messages: 4664
Inscription: 8/01/10
Localisation: Reims/Maubeuge

Re: Programmation servo pour une gauge non linéaire

Messagede FiX » Mer 2 Juil 2014 19:46

Bon par contre, si je ne veux pas utiliser la vitesse convertie en neoud, que je garde l'offset IAS (*128), lorsque je fais le calcul de ma fonction y=ax+b, je me retrouve avec mon facteur de multiplication "a" beaucoup trop faible (0.016 par exemple).
Je ne sais pas jusqu'à combien après la virgule, le SIOC tient compte?

Edit:
Bon, du coup, j'ai divisé la valeur IAS par 20, comme ça je garde une bonne précision tout en ayant un facteur de multiplication pas trop faible.
Je viens de tester:

Code: Tout sélectionner
Var 0000, name init, Value 0
{
  &servo_ias = 990   
}

Var 0015, name servo_ias, Link USB_SERVOS, Output 6, PosL 190, PosC 515, PosR 990     // servo air speed
{
  IF &servo_ias < 190
  {
    &servo_ias = 190   
  }
  IF &servo_ias > 990
  {
    &servo_ias = 990   
  }
}

Var 0016, name ias_fs, Link FSUIPC_INOUT, Offset $02BC, Length 4     // offset IAS x128
{
  &IAS_conv = &ias_fs / 20
  IF &IAS_conv <= 256
  {
    L0 = &IAS_conv * 0.32
    &servo_ias = 980 - L0
  }
  IF &IAS_conv > 256
  {
    IF &IAS_conv <= 320
    {
      L0 = &IAS_conv * 0.72
      &servo_ias = 1058 - L0
    }
  }
  IF &IAS_conv > 320
  {
    IF &IAS_conv <= 448
    {
      L0 = &IAS_conv * 0.9
      &servo_ias = 1142 - L0
    }
  }
  IF &IAS_conv > 448
  {
    IF &IAS_conv <= 576
    {
      L0 = &IAS_conv * 1.15
      &servo_ias = 1250.5 - L0
    }
  }
  IF &IAS_conv > 576
  {
    IF &IAS_conv <= 768
    {
      L0 = &IAS_conv * 1.21
      &servo_ias = 1285 - L0
    }
  }
  IF &IAS_conv > 768
  {
    L0 = &IAS_conv * 1.31
    &servo_ias = 1365 - L0
  }
}

Var 0017, name IAS_conv     // IAS /20


Niveau précision, c'est bien mieux que lorsque je divisais par 128!! ca y est, la gauge est bien fluide et précise, le servo avance pas à pas et on a plusieurs pas d'un noeud à l'autre.
Donc là, c'est tout bon.
Sauf que... du coup maintenant le jeu se fait beaucoup plus sentir.
Quand la vitesse accélère, l'indication de l'aiguille est parfaite, mais si on décélère, on est mauvais de 5nds!
Avec ce nouveau code, on a donc 5nds de jeu à rattraper quand on est décélération. murrouge
i7 2600k/P8P67pro/16Go PC3 17000/RX 580/SSD 250 Go et 120Go/W10x64
https://www.facebook.com/cessna150.sim
Avatar de l’utilisateur
FiX
 
Messages: 4664
Inscription: 8/01/10
Localisation: Reims/Maubeuge

Re: Programmation servo pour une gauge non linéaire

Messagede A320 hérétique » Jeu 3 Juil 2014 00:31

Fix,
A ttes fins utiles, si tu ne veux pas multiplier par 0.016, divises par son inverse ; mais c'est peut être déjà bien comme ça ...

Pour le rattrapage de jeu, le jeu est tellement important que l'application de la correction à chaque retour arrière devrait marcher.

Michel
http://www.myA320sim.com
Simu mixte P3D/FS2020, serveur P3Dv4/A320 FMGS (7700k et GTX 1070 sous W10 64), client P3Dv4/FS2020 (i9-12900K et RTX 3080 Ti sous W10 64), 3 vdp Optoma GT1080E, client A320 FMGS (2600k sous W10 64).
Avatar de l’utilisateur
A320 hérétique
 
Messages: 3355
Inscription: 2/09/12
Localisation: Pornic

Re: Programmation servo pour une gauge non linéaire

Messagede FiX » Jeu 3 Juil 2014 18:32

Bon, je sèche encore.
Mes essais ne marchent pas pour le jeu.
Une idée sur la façon de coder ce rattrapage de jeu?
i7 2600k/P8P67pro/16Go PC3 17000/RX 580/SSD 250 Go et 120Go/W10x64
https://www.facebook.com/cessna150.sim
Avatar de l’utilisateur
FiX
 
Messages: 4664
Inscription: 8/01/10
Localisation: Reims/Maubeuge

Re: Programmation servo pour une gauge non linéaire

Messagede A320 hérétique » Jeu 3 Juil 2014 19:53

Au pied levé, qque-chose comme :

Dans l'init :
1) on définit une variable "sens" qui prend la val 1 si "servo_ias" augmente, et -1 si baisse
2) on définit une variable "sens_précédent" : idem, initialisation à -1
3) on augmente "servo_ias" puis on le ramène en arrière, de façon à ce qu'au démarrage il faille rattraper le jeu
4) on évalue la valeur "delta" à rajouter ou soustraire à "servo_ias" quand il y a changement de sens ; initialisation
5) on initialise une variable "servo_ias_précédent" avec la valeur de "servo_ias"

A chaque fois qu'on déroule les calculs, à la fin :
6) on calcule "sens" en comparant la valeur calculée de "servo_ias" avec "servo_ias_précédent"
7) si "sens" > "sens_précédent", on ajoute "delta" à "servo_ias"
8) si "sens" < "sens_précédent", on soustrait "delta" à "servo_ias"
9) on met "servo_ias" dans "servo_ias_précédent"
10) on met "sens" dans "sens_précédent"

Michel
http://www.myA320sim.com
Simu mixte P3D/FS2020, serveur P3Dv4/A320 FMGS (7700k et GTX 1070 sous W10 64), client P3Dv4/FS2020 (i9-12900K et RTX 3080 Ti sous W10 64), 3 vdp Optoma GT1080E, client A320 FMGS (2600k sous W10 64).
Avatar de l’utilisateur
A320 hérétique
 
Messages: 3355
Inscription: 2/09/12
Localisation: Pornic

Re: Programmation servo pour une gauge non linéaire

Messagede FiX » Lun 7 Juil 2014 12:43

Alors là, je suis largué!! gratgrat
J'ai passé le WE là dessus, je n'y comprend rien.
Je me demande si je ne vais pas essayer de refaire toute la mécanique de ma gauge pour essayer de ne pas avoir de jeu!
C'est ma seule gauge qui a du jeu alors que j'utilise exactement le même principe et les mêmes pignons que les autres.
i7 2600k/P8P67pro/16Go PC3 17000/RX 580/SSD 250 Go et 120Go/W10x64
https://www.facebook.com/cessna150.sim
Avatar de l’utilisateur
FiX
 
Messages: 4664
Inscription: 8/01/10
Localisation: Reims/Maubeuge

Re: Programmation servo pour une gauge non linéaire

Messagede A320 hérétique » Lun 7 Juil 2014 14:34

Salut Fix,

l'idée est simplement de rajouter une petite valeur "delta_servo_ias" à servo_ias si la gauge change de sens à la hausse, ou de retrancher cette même valeur si le changement est à la baisse.

J'ai repris ton code, mais je n'ai pas testé ! ça pourrait s'écrire de façon plus concise, mais ce serait moins compréhensible ...

Dans var 0015, Il doit falloir écrêter &servo_ias à 990 + &delta_servo_ias, et 190 - &delta_servo_ias (idem à l'init).

Michel

Code: Tout sélectionner
Var 0000, name init, Value 0
{
  &servo_ias = 990   // on amène la gauge à 0 kts "par le haut"
  &servo_ias = 980
  &servo_ias = 990
  &sens_precedent = -1   // et on l'indique à &sens_precedent
  &servo_ias_precedent = &servo_ias // initialisation   
}

Var 0001, name sens
{
// cette variable mémorise le sens dans lequel la gauge a tourné :
//   1 si elle a augmenté
//   -1 si elle a baissé
}

Var 0002, name sens_precedent
{
// cette variable mémorise la valeur précédente de &sens
//  en comparant &sens et &sens_précédent, on détermine
//  si la gauge change de sens
//  et donc s'il faut rattraper le jeu
}

Var 0003, name delta_servo_ias, value 5
{
//  valeur du jeu à rattraper : à ajuster
}

Var 0004, name servo_ias_precedent
{
//  cette variable mémorise la valeur precedente de &servo_ias
}

Var 0015, name servo_ias, Link USB_SERVOS, Output 6, PosL 190, PosC 515,

PosR 990     // servo air speed
{
  IF &servo_ias < 190
  {
    &servo_ias = 190   
  }
  IF &servo_ias > 990
  {
    &servo_ias = 990   
  }
// on détermine le sens dans lequel la jauge a évolué
// on ne change rien si la gauge n'a ni augmenté, ni diminué
// (de toutes les façons, pas d'évènement)
  if &servo_ias > &servo_ias_precedent
  {
    &sens = 1 // la gauge a augmenté
  }
  if &servo_ias < &servo_ias_precedent
  {
    & sens = -1 // la gauge a diminué
  }
// on détermine si le sens a changé
// si oui, on rattrape le jeu
  if &sens > &sens_precedent
  {
    &servo_ias = &servo_ias + &delta_servo_ias
  }
  if &sens < &sens_precedent
  {
    &servo_ias = &servo_ias - &delta_servo_ias
  }
// et on prend note de cette nouvelle situation
  &sens_precedent = &sens
  &servo_ias_precedent = &servo_ias

}

Var 0016, name ias_fs, Link FSUIPC_INOUT, Offset $02BC, Length 4     //

offset IAS x128
{
  &IAS_conv = &ias_fs / 20
  IF &IAS_conv <= 256
  {
    L0 = &IAS_conv * 0.32
    &servo_ias = 980 - L0
  }
  IF &IAS_conv > 256
  {
    IF &IAS_conv <= 320
    {
      L0 = &IAS_conv * 0.72
      &servo_ias = 1058 - L0
    }
  }
  IF &IAS_conv > 320
  {
    IF &IAS_conv <= 448
    {
      L0 = &IAS_conv * 0.9
      &servo_ias = 1142 - L0
    }
  }
  IF &IAS_conv > 448
  {
    IF &IAS_conv <= 576
    {
      L0 = &IAS_conv * 1.15
      &servo_ias = 1250.5 - L0
    }
  }
  IF &IAS_conv > 576
  {
    IF &IAS_conv <= 768
    {
      L0 = &IAS_conv * 1.21
      &servo_ias = 1285 - L0
    }
  }
  IF &IAS_conv > 768
  {
    L0 = &IAS_conv * 1.31
    &servo_ias = 1365 - L0
  }
}

Var 0017, name IAS_conv     // IAS /20
http://www.myA320sim.com
Simu mixte P3D/FS2020, serveur P3Dv4/A320 FMGS (7700k et GTX 1070 sous W10 64), client P3Dv4/FS2020 (i9-12900K et RTX 3080 Ti sous W10 64), 3 vdp Optoma GT1080E, client A320 FMGS (2600k sous W10 64).
Avatar de l’utilisateur
A320 hérétique
 
Messages: 3355
Inscription: 2/09/12
Localisation: Pornic

Re: Programmation servo pour une gauge non linéaire

Messagede FiX » Mar 8 Juil 2014 12:15

Merci Michel, je vois déjà mieux!
Je vais tester ça.

J'ai tout de même repris le mécanisme de la gauge. En fait c'était assez simple, mes 2 pignons était trop éloignés l'un de l'autre et il y avait un peu de jeu.
J'ai modifié la platine pour rapprocher le servo d'1/10ième de mm et il n'y a plus de jeu.
Ca a effectivement pratiquement réglé le problème. Mais il doit y avoir un très léger faux rond sur un axe qui fait que j'ai encore 1 à 2kts de jeu entre 100 et 120kts sur la gauge, je vais donc tester le rattrapage de jeu dans ce segment, "pour la science"...
i7 2600k/P8P67pro/16Go PC3 17000/RX 580/SSD 250 Go et 120Go/W10x64
https://www.facebook.com/cessna150.sim
Avatar de l’utilisateur
FiX
 
Messages: 4664
Inscription: 8/01/10
Localisation: Reims/Maubeuge

Re: Programmation servo pour une gauge non linéaire

Messagede A320 hérétique » Mar 8 Juil 2014 13:09

Oui, arrivé à ce stade ça devient compliqué ! si tu n'as du jeu qu'entre 100 et 120, mets une limitation dans le code pour que ça n'agisse que dans cette plage ...
Sinon, il y a toujours les engrenages à rattrapage de jeu, tu peux même le réaliser toi même facilement (2 engrenages accolés, 2 ou 3 petits trous, un petit élastique ou un tout petit ressort ou même un petit bout de gomme pour imposer la contrainte) , plus simple que de percer des engrenages bien au centre quand on n'a pas de tour.

Michel
http://www.myA320sim.com
Simu mixte P3D/FS2020, serveur P3Dv4/A320 FMGS (7700k et GTX 1070 sous W10 64), client P3Dv4/FS2020 (i9-12900K et RTX 3080 Ti sous W10 64), 3 vdp Optoma GT1080E, client A320 FMGS (2600k sous W10 64).
Avatar de l’utilisateur
A320 hérétique
 
Messages: 3355
Inscription: 2/09/12
Localisation: Pornic

Précédente

Retourner vers Programmation Sioc





Qui est en ligne

Utilisateurs parcourant ce forum: Aucun utilisateur enregistré et 6 invités

cron