Enlever les 0 après le dernier entier après la virgule

International Français
1

Bonjour,

J'aimerais enlever les 0 inutiles après la virgule dans un float et je ne sais pas trop sous quel angle approcher ça.

int inputPin_IR = A5;
int inputPin_PHOTO = A6;

long IR = 0;
long PHOTO = 0;

float IR_moyenne = 0.0000;
float PHOTO_moyenne = 0.0000;

long nombre_de_mesure = 0;

void setup() {
  Serial.begin(9600);
    IR = analogRead(inputPin_IR);
  PHOTO = analogRead(inputPin_PHOTO);


}

void loop() {

  IR = analogRead(inputPin_IR)+IR;
  PHOTO = analogRead(inputPin_PHOTO)+PHOTO;
  
  nombre_de_mesure++;

      IR_moyenne = IR/nombre_de_mesure;
      PHOTO_moyenne = PHOTO/nombre_de_mesure;
      Serial.print("I");
      Serial.print(IR_moyenne);
      Serial.print(";");
      Serial.print("P");
      Serial.print(PHOTO_moyenne/400,4); // pour 0.0025 m2
      IR = IR_moyenne ;
      PHOTO = PHOTO_moyenne ;
      nombre_de_mesure = 0 ;
      }
    }
}

J'aimerais pouvoir afficher 'PHOTO_moyenne/400' 0.0780 >>> 0.078

Sans trop faire un usine à gaz comment serait ce possible à faire ?

C'est ensuite pour envoyer ça en paramètre dans une url.... et si on peut économiser quelques octets à envoyer c'est pas trop mal :smiley:

2

salut jfs,
tu peux multiplier par 10000 ta valeur

PHOTO_moyenne_multiplie = int(PHOTO_moyenne*10000)
3

Merci Coinc ( :smiley: ),

Je voulais éviter de le faire de cette façon, mais finalement ce ne sont que 4 lignes de plus....

      int (IR_moyenne*10000);
      int (PHOTO_moyenne*10000);
      float(IR_moyenne/10000);
      float(PHOTO_moyenne/10000);
4

:grin:

5

En multipliant par 10000 et en tronquant 0.0780 = 780 - ça change quoi à l’affaire? Il y a toujours le zéro au bout, c’est pareil... ce zéro est significatif, il dit que vous savez que les prochaines décimales sont nulles et que ce n’est pas juste tronqué

Si vous ne voulez pas montrer les dernières décimales significatives qui sont nulles lors de l’impression il faut convertir le float en c-string et analyser la c-string pour virer les ‘0’

6

Effectivement les 0 ne disparaissent pas, ça permet simplement de tronquer le chiffre des valeurs au delà de la 4ème décimales sans enlever les 0....

ce 0 n'est pas spécifiquement significatif, il serait possible d'avoir 0,07801 ramené à 0,0780, la valeur est tronquée et pourtant le dernier 0 subsiste.

Bref.... je vais faire un fonction pour tester et supprimer ces 0 :grin:

7

Voilà.... on part dans les usines à gazzzzzz :grin:

Merci pepe pour cet exemple que je ne vais pas manquer de scruter.

Je pensais à tort qu'une fonction de formatage de nombre existait à l'exemple de Java ou il semblerait pour supprimer les 0 "inutiles" de faire simplement

System.out.println( df.format(1.53000) );
8

Non - on est plus proche du hard

Je ferai un dtostrf() dans un buffer puis en partant de la fin du buffer (obtenu par strlen()) je remonterais tant que je trouve un zéro je le remplace par ‘\0’ (fin de chaine), en prenant soin de ne pas toucher au premier caractère pour ne pas que 0 soit transformé en chaîne vide)

Mais en pratique je ferai simplement un Serial.print(monFloat,4); en me souciant pas de 0 à la fin :slight_smile:

9

Merci J-M-L,

J-M-L:
Non - on est plus proche du hard

Je ferai un dtostrf() dans un buffer puis en partant de la fin du buffer (obtenu par strlen()) je remonterais tant que je trouve un zéro je le remplace par ‘\0’ (fin de chaine), en prenant soin de ne pas toucher au premier caractère pour ne pas que 0 soit transformé en chaîne vide)

C'est ce que j'ai fait.... :wink:

J-M-L:
Mais en pratique je ferai simplement un Serial.print(monFloat,4); en me souciant pas de 0 à la fin :slight_smile:

Et c'est la solution que j'emploie actuellement :smiley:

10

un truc du genre fera l'affaire

float IR_moyenne = 0.078;

void printFloat(float f, byte precision)
{
  const byte tailleMax = 30;
  char buffer[tailleMax + 1];

  Serial.print("Avant: ");
  Serial.println(f, precision);

  dtostrf(f, -tailleMax, precision, buffer);

  for (byte i = strlen(buffer) - 1; i >= 1; --i)
    if (buffer[i] == '0' || buffer[i] == ' ') buffer[i] = '\0';
    else break;

  Serial.print("Apres: ");
  Serial.println(buffer);
}

void setup() {
  Serial.begin(115200);
  printFloat(IR_moyenne, 6);
}

void loop() {}

la console affichera:

[sub][color=blue]Avant: 0.078000
Apres: 0.078
[/color][/sub]
11

Wow.... nickel, merci

12

et sans embarquer la fonction dtostrf :

http://forum.arduino.cc/index.php?topic=174743.0#msg2165576

Je sais bien que tu es nouveau dans le coin, mais il y a une fonction "rechercher" sur le forum :smiling_imp:

13

Je pense que le problème devrait être vu sous un autre angle. Supprimer les zéros terminaux n'apporte pas forcément de la cohérence dans le résultat affiché. Exemple :

0.0780 --> 0.078 OK
0.07800100 --> 0.078001 Bof !

Pour moi, ce qui a du sens est la précision que l'on s'accorde à donner à la valeur. En l’occurrence, si on veut une précision de l'ordre du %, 0.078001 et 0.078, c'est la même chose.

Donc, à mon sens, ce qu'il faut rechercher, c'est l'algorithme qui ne laisse que les chiffres ayant une signification au vu de la précision demandée.

Cordialement.

Pierre

14

Oui, Pierre, ta remarque est judicieuse.

15

bricoleau:
et sans embarquer la fonction dtostrf :

How to NOT print the ending zeros of a float - Project Guidance - Arduino Forum

Je sais bien que tu es nouveau dans le coin, mais il y a une fonction "rechercher" sur le forum :smiling_imp:

Sauf que la fonction recherche ne comporte pas de module "translate" et que maintenant ce sujet existe en Français.... Voilà voilà....

Dans le même ordre d'idée que la remarque de Pierre.

Je viens de regarder le gain sur le nombre d'octets gagné sur une Url en supprimant le dernier 0 de chacune de mes valeurs .... dans la pire des hypothèses en une année je pourrais gagner 500ko :grin:

En modifiant les noms des variables que je passe dans l'Url et en les raccourcissant je pourrais gagner environ 10 fois plus.... et ce dans n'importe quel cas :smiley:

Je ferai cette modifs sur mes variables... mais pas dans l'immédiat :wink: