Printf variable float avec caractère degré

[RATAXES64]

Bonjour à toutes et tous,
Je suis nouveau, et me suis mis au C tout récemment après 40 ans de VB... Merci de votre indulgence

Je veux afficher une variable float qui n'a qu'une seule décimale, en remplaçant la virgule par le caractère degré (°).
Par exemple : 16,4 par 16°4.
Le caractère degré n'existant pas en code acii j'utilise le caractère ascii étendu 167.
J'utilise CodeBlock sur la console de Windows

float U ;
int D ;
U = 16.4 ; // Valeur de température au dixième de degré
D = (U*10) - ((int) U*10) ; // Extraction de la décimale
printf("%.0f%c%d", U, 167, D) ; // Affichage en console Windows

Avec la valeur 16.4, le résultat affiché est correct
MAIS...
Il est faux pour U<0 et si la décimale est >=5 en valeur absolue...

J'ai donc "bidouillé" un peu ...

float U ;
int D ;
U = -0.6 ;
D = (U*10) - ((int) U*10) ;
printf("%.0f%c%d \n", U, 167, D) ;

if (U == 0)                                     // Si Valeur Nulle...'
{
    D = (U*10) -((int)U * 10) ;                 // Reprise de la valeur decimale pour mesure nulle
    printf("%d%c%d \n", (int)U, 167, D) ;       // Tp = 0 degre (1 decimale)
}
else  if (U >0)                                 // Si Valeur Positive...
{
    D = (U*10) -((int)U * 10) ;                 // Reprise de la valeur decimale pour mesure Positive
    if (U != 0 && U >=1)                        // CONDITION 1 : valeur Tp positive > 1 degre
    {
        if (D>4)                                // Si Valeur Decimale > 4 ...
        {
            U = U - 1 ;                         // Corrige d'une unite...!
        }
        printf("%.0f%c%d n", U, 167, D) ;       // Tp Positive > 1 degre (1 decimale)
    }
    else                                        // CONDITION 2 : valeur Tp positive < 1
    {
        printf("%d%c%d \n", (int)U, 167, D) ;   // Tp Positive  < 1 degre (1 decimale)

    }
}
else if (U <0)                                  // Si valeur Negative
{
    D = -((U*10) -((int)U * 10)) ;              // Reprise de la valeur decimale pour Tp Negative
    if (U != 0 && U <=-1)                       // CONDITION 1 : Valeur négative < -1  degre
    {
        if (D>4)                                // Si Valeur Decimale > 4 ...
        {
            U = U + 1 ;                         // Corrige d'une unite...!
        }
        printf("%.0f%c%d \n", U, 167, D) ;      // Tp Negative < -1 degre (1 decimale)
    }
    else
    {
        printf("-0%c%d \n", 167, D) ;           // Tp Négative > - 1 degre (1 decimale)
    }
}

Là, ça fonctionne... mais ça n'est pas très beau comme code !
Une idée pour le simplifier , voire l'améliorer ?

Commentaires et aide bienvenus.
Merci
-----

[Ikhar84]

Plusieurs remarques :

Pourquoi tu recalcules systématiquement la partie décimale D ?
Surtout dans le cas U == 0...

Tu peux utiliser sprintf au lieu de printf pour envoyer la sortie formatée dans une variable...

Il te suffira de rechercher dans la variable le point décimal et le remplacer par le caractère de ton choix, non ?

On ne connais pas le contexte et les spécificité à garantir pour ton code ?

[RATAXES64]

Merci Ikhar84,

Ooops : Oui pour la décimale pour 0... j'ai pas fait gaffe.

rechercher dans la variable le point décimal et le remplacer par le caractère de ton choix

Malheureusement, ça, je ne sais pas (encore) faire...

On ne connais pas le contexte et les spécificité à garantir pour ton code ?

Désolé, je ne comprends pas ce que tu veux dire...

A+

[MissJenny]

Je veux afficher une variable float qui n'a qu'une seule décimale

les variables de type float n'ont pas "qu'une seule décimale". C'est quand on les imprime qu'on peut décider de n'imprimer qu'une décimale.

[A voir en vidéo sur Futura]

[Ikhar84]

Quelques exemples de questions liées au contexte :

C'est pour un objet connecté ?
De l'embarqué ?
De l'arduino ?
Pourquoi C et pas C++ ?

[RATAXES64]

Il s'agit de la réalisation d'une carte de régulation climatique, basée sur un PIC programmé en C. L'affichage est choisi sur LCD 20x4.

les variables de type float n'ont pas "qu'une seule décimale". C'est quand on les imprime qu'on peut décider de n'imprimer qu'une décimale.

Certes... mais les données qui seront utilisées n'en comporte bien qu'une seule : La relève des températures ou leurs consignes étant toujours arrondies au dixième de degré dans les calculs.

Ce que je ne sais pas faire "proprement", c'est remplacer la virgule par "°" à l'affichage ; ce d'autant que la virgule en question est positionnée dans un rang différent selon la valeur...

    
float U ;
int main()
{
    U = 0 ;
    printf("RESULTAT  1 ',' en position 2 : %0.1f \n",U) ;
    U = 0.2 ;
    printf("RESULTAT  2 ',' en position 2 : %0.1f \n",U) ;
    U = 0.5 ;
    printf("RESULTAT  3 ',' en position 2 : %0.1f \n",U) ;
    U = 1 ;
    printf("RESULTAT  4 ',' en position 2 : %0.1f \n",U) ;
    U = 1.2 ;
    printf("RESULTAT  5 ',' en position 2 : %0.1f \n",U) ;
    U = 1.5 ;
    printf("RESULTAT  6 ',' en position 2 : %0.1f \n",U) ;
    U = 15.5 ;
    printf("RESULTAT  7 ',' en position 3 : %0.1f \n",U) ;
    U = -0.2 ;
    printf("RESULTAT  8 ',' en position 3 : %0.1f \n",U) ;
    U = -0.5 ;
    printf("RESULTAT  9 ',' en position 3 : %0.1f \n",U) ;
    U = -1.2 ;
    printf("RESULTAT 10 ',' en position 3 : %0.1f \n",U) ;
    U = -1.5 ;
    printf("RESULTAT 11 ',' en position 3 : %0.1f \n",U) ;
    U = -15.5 ;
    printf("RESULTAT 12 ',' en position 4 : %0.1f \n",U) ;
}

A+

[pm42]

Remplacer la virgule n'est sans doute pas la bonne solution d'autant que cela peut être un point si le système est en anglais.
La solution propre est de prendre la partie entière du nombre, l'afficher puis le caractère degré puis la partie fractionnaire multipliée par 10 à la puissance du nombre de décimales voulues et convertie en entier.

Il est peut être nécessaire de traiter les nombres négatifs différemment des positifs mais la aussi le plus simple est est détecter si c'est négatif, afficher le '-' puis faire le même traitement que plus haut sur l'opposé du nombre.

[RATAXES64]

J'avance un peu avec mes maigres connaissances ..

int Test_Degre()
{
    float Val ; // Valeur standard
    int Dec ;   // Decimale
    int Unt ;   // Unites

    //=====VALEUR A TESTER================================
    Val = -0.9 ;                // SAISIE VALEUR A TESTER
    //====================================================

    Unt = (int)Val ;            // Extraction Unites
    Dec =(Val*10)-(Unt*10) ;    // Extraction Decimale (et PAS (Val-Unt)*10 !!!)

    //=====AFFICHAGE=====Standard suivi de avec sigle degre====================
    if (Unt==0 && Val<0 )       // CAS SPECIAL pour Valeur Negative + Unite = 0
    {
        printf("RESULT : Value:%0.1f => -0%c%d", Val, 167, -Dec) ;
    }
    else                        // CAS GENERAL
    {
        printf("RESULT : Value:%0.1f => %d%c%d", Val, Unt, 167, (Dec>0)?Dec:-Dec) ;
    }
}

C'est déjà un peu mieux ; mais je pense qu'il y a plus "élégant" (mon scipt, c'est plutôt et_les_mouffles...)

[umfred]

Qu'est-ce qui justifie de traiter une valeur de -0.X différemment d'une valeur -1.X ?

[RATAXES64]

Qu'est-ce qui justifie de traiter une valeur de -0.X différemment d'une valeur -1.X ?

C'est pour le cas particulier où on est en présence d'une valeur négative ET dont l'unité = 0.
Dans un tel cas, on a "besoin" d'afficher '-0' suivi de la décimale (avec la virgule remplacée par le caractère ascii étendu 167).
Je ne sais d'ailleurs pas "pourquoi" on obtient un résultat faux, mais je subodore de belles galères avec les "float"...
Perso, je ne vois pas comment faire autrement pour contourner ce traquenard

Pour info, voilà ce que ça donne avec ce script pour différentes valeurs :
Indice "a" : printf avec -0%c%d (valeurs comprises > -1 et <=0)
Indice "b" : printf avec %d%c%d (toutes autres valeurs)


A+

[Ikhar84]

Pourquoi ne pas juste "ajouter" le symbole "degré" à la suite du float, c'est la notation habituelle (13.7°, par exemple) ?

[umfred]

Ok je n'avais vu/pensé que int(-0.9) renvoyait juste 0 en effet
Mais on peut alors faire cette affichage là (ce n'est pas top, peut-être utiliser la fonction abs de stdlib.h pour s'éviter les conditions ternaires sur Unt et Dec

printf("RESULT : Value:%0.1f => %c%d%c%d", Val, Val>0?'\0':'-',Unt>0?Unt:-Unt, 167, (Dec>0)?Dec:-Dec) ;

#include <stdlib.h>

int Test_Degre()
{
    float Val ; // Valeur standard
    int Dec ;   // Decimale
    int Unt ;   // Unites

    //=====VALEUR A TESTER================================
    Val = -0.9 ;                // SAISIE VALEUR A TESTER
    //====================================================

    Unt = abs((int)Val) ;            // Extraction Unites
    Dec =abs((Val*10)-(Unt*10)) ;    // Extraction Decimale (et PAS (Val-Unt)*10 !!!)

    //=====AFFICHAGE=====Standard suivi de avec sigle degre====================
    printf("RESULT : Value:%0.1f => %c%d%c%d", Val>0?'\0':'-', Unt, 167, Dec) ;

}

[pm42]

Pourquoi ne pas juste "ajouter" le symbole "degré" à la suite du float, c'est la notation habituelle (13.7°, par exemple) ?

C'est la notation si on affiche en degrés décimaux en effet. Si on veut afficher en degrés/minutes/secondes par exemple, on met le °, ', '' après chaque nombre.

[MissJenny]

La relève des températures ou leurs consignes étant toujours arrondies au dixième de degré dans les calculs.

dans ce cas pourquoi ne pas utiliser une variable de type entier qui contiendrait la température en dixièmes de degrés?

[RATAXES64]

Bonsoir à toutes et tous,
Merci de vos réponses.

=> umfred : Un 'Val' était manquant dans le code proposé avec abs, corrigé ci-dessous :

#include <stdlib.h>

int Test_Degre()
{
    float Val ; // Valeur standard
    int Dec ;   // Decimale
    int Unt ;   // Unites

    //=====VALEUR A TESTER================================
    Val = -0.9 ;                // SAISIE VALEUR A TESTER
    //====================================================

    Unt = abs((int)Val) ;            // Extraction Unites
    Dec =abs((Val*10)-(Unt*10)) ;    // Extraction Decimale (et PAS (Val-Unt)*10 !!!)

    //=====AFFICHAGE=====Standard suivi de avec sigle degre====================
    printf("RESULT : Value:%0.1f => %c%d%c%d", Val, Val>0?'\0':'-', Unt, 167, Dec) ;

}

Mais , ça ne fonctionne pas correctement selon les valeurs de Val...
Test printf 2.jpg

=> pm42 et MissJenny : La raison pour laquelle je veux afficher les valeurs de température de cette façon est pour gagner de la place sur le LCD.
Bien sûr ceci ne concerne pas les calculs! Un image sera plus parlante :
Afficheur LCD.jpg

A+

[umfred]

Je suis un idiot
En prenant la valeur absolue pour Unt, je fausse le calcul de Dec ....
Ce n'est que pour l'affichage que j'utilise sa valeur absolue.

#include <stdlib.h>

int Test_Degre()
{
    float Val ; // Valeur standard
    int Dec ;   // Decimale
    int Unt ;   // Unites

    //=====VALEUR A TESTER================================
    Val = -0.9 ;                // SAISIE VALEUR A TESTER
    //====================================================

    Unt = (int)Val ;            // Extraction Unites
    Dec =abs((Val*10)-(Unt*10)) ;    // Extraction Decimale (et PAS (Val-Unt)*10 !!!)

    //=====AFFICHAGE=====Standard suivi de avec sigle degre====================
    printf("RESULT : Value:%0.1f => %c%d%c%d", Val, Val>0?'\0':'-', abs(Unt), 167, Dec) ;

}

[RATAXES64]

Bonjour à toutes et tous,
-> umfred : Non! distrait... comme tout un chacun.
C'est bon, et on peut même faire ça sur une ligne et une déclaration :

    
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

int Test Degre()
{
   float Val;

   //=====VALEUR A SAISIR=====
   Val = 0.9 ;
   //=====================

   printf("RESULT  -> Value:%3.1f => %c%d%c%d \n", Val, Val>0?'\0':'-', abs((int)Val), 167, abs((Val*10)-((int)Val*10)));
}

C'est Résolu : Merci à toutes et tous.

[RATAXES64]

Add On...
Petit détail : Le bon caractère '°' en ASCII étendu, c'est 248 (et pas 167)

[Jack]

Vu qu'à terme, c'est pour afficher sur un afficheur LCD, ce n'est pas très grave.
Au pire, si le caractère n'existe pas, il est possible de le créer dans la CGRAM.

[Forhorse]

D'ailleurs si c'est destiné à un afficheur LCD, je doute que l'instruction "printf" fonctionne tel quel, il va sans doute falloir adapter...

[Jack]

En principe, on pourrait utiliser sprintf et balancer la chaine obtenue au LCD.

Mais, avec des "petits" PIC, il est probable que sprintf ne soit pas implémentée en raison de son cout en mémoire. Si c'est le cas, il va falloir revoir tout l'algorithme, d'où l'importance de communiquer un cahier des charges exhaustif.

[polo974]

Si c'est un "petit pic", ça va aussi tousser pour les calculs flottants...

[Jack]

En effet.
L'idée de MissJenny de traiter la température en dixième de degré dans un entier me semble la plus intéressante. En tout cas, c'est comme ça que j'ai procédé lorsque j'ai eu ce problème à régler.

[RATAXES64]

Bonjour à toutes et tous,

Comme je l'ai dit en en tête, je "découvre" le C.
Je me suis donné cet exercice via printf et un affichage sur console Windows, sachant que bien sûr un tel code ne conviendra pas tel quel pour la réalisation...

Merci encore.
A+

[Jack]

Je comprends. Ca fait toujours un bon exercice.

Mais ton problème n'est peut-être pas solutionné du coup.
On ne sait toujours pas quel type de PIC sera utilisé.

[RATAXES64]

Pour info : PIC 18F27K42-I-SP (schéma, cahier des charges et carte prototype terminés)
On est en phase d'essais finaux, le soft en C écrit par paulfjujo est pratiquement "au bout" (relevés de mesures, consignes, calcul de la courbe de chauffe et T° cible, Commandes, Menus...)
Totalement novice en C, j'essaye de bien comprendre certains points, notamment ici au niveau des contraintes d'affichage au LCD.

Si cette réalisation d'un régulateur climatique intéresse certains, je reviendrai vous en faire part une fois conduite à terme.
A+

[Jack]

128K de ROM, ça devrait passer (à vérifier)
Je connais peu MPLABX, mais dans tous les bons compilateurs pour embarqué, on peut rediriger la sortie standard vers tout type de flux. Dans les compilateurs que je connais le principe consiste à redéfinir la fonction de base permettant l'envoi d'un caractère vers le flux de sortie. De mémoire, il devrait s'agir de la fonction putc.

[umfred]

Add On...
Petit détail : Le bon caractère '°' en ASCII étendu, c'est 248 (et pas 167)

Juste pour préciser que ça dépend du jeu de caractères utilisé https://www.ascii-code.com/248

[polo974]

Add On...
Petit détail : Le bon caractère '°' en ASCII étendu, c'est 248 (et pas 167)

ça dépend de ce que le fabriquant a mis dans la police de caractère du contrôleur lcd.
ça varie d'un fabriquant à l'autre sans parler des versions européennes ou asiatiques...

bref, prévoir un truc modifiable facilement, ou mettre juste un point décimal ...

[RATAXES64]

ça dépend de ce que le fabriquant a mis dans la police de caractère du contrôleur lcd.
ça varie d'un fabriquant à l'autre sans parler des versions européennes ou asiatiques...
bref, prévoir un truc modifiable facilement, ou mettre juste un point décimal ...

Absolument! Et c'est prévu. On utilise la partie Ascii "de base" (pratiquement toujours présente en ROM!), tandis que des caractères "spéciaux" (comme le '°' à insérer par exemple) sont créés en CGRAM (on dispose de séquences de 8 caractères), sachant qu'une seule séquence à la fois peut être "appelée" en affichage "spécial".
Ce projet de régulateur climatique est déjà très avancé et, comme je l'ai dit, si d'aventure quelqu'un est intéressé, je pourrai donner les liens dans un autre post. Pour moi, je considère celui-ci comme pouvant être clos. Merci encore à toutes et tous de vos remarques pertinentes et constructives. A+