[Jérémy]

Bonjour à tous,

Je me lance tranquillement dans les test de la fonction read_adc . Permettant de lire une valeur analogiques sur une broches et de la convertir en numérique.
Jusque la c'est pas trop dur. Tout ce corse quand j'affiche ma valeur sur un LCD.

Bien évidemment pour coller au mieux à la réalité, je travaille avec des float, me permettant d'avoir la virgule.

Maintenant sur mon LCD je me retrouve avec 6 chiffres après la virgule. Je n'ai pas trouve de fonctions faisant les arrondis ou la mise en forme des chiffres ?

[Guest]

AH BON regarde PRINTF MDR
tient par exemple 1s sur mon moteur favori http://www.codingunit.com/printf-format ... ted-output

[Claudius]

Bonsoir,

Pour les arrondis et autres manipulations / conversions des flottants cf. math.h et effectivement la méthode printf pour tout ce qui est formatage

[Guest]

salut clauduis fait conversion flotant->hexa en asm 16bits un régal

a + pour pas polluer le post

[paulfjujo]

Bonsoir,


printf est effectivement la methode la plus FACILE et evidente à mettre en oeuvre.
mais utilise beaucoup de ressource , et peut etre meme impossible à utiliser sur des PIC ayant peu de RAM et ROM.
J'utilise cette fonction qui passe partout, meme sur les 16F8xx

Code : Tout sélectionner




void fltToa (double x, unsigned char *str,char precision)
{
/* converts a floating point number to an ascii string */
/* x is stored into str, which should be at least 30 chars long */
int ie, i, k, ndig;
double y;
ndig = ( precision<=0) ? 7 : (precision > 22 ? 23 : precision+1);
ie = 0;
/* if x negative, write minus and reverse */
if ( x < 0)
  {
  *str++ = '-';
  x = -x;
  }
/* put x in range 1 <= x < 10 */
if (x > 0.0) while (x < 1.0)
  {
  x *= 10.0;                // a la place de =*
  ie--;
  }
while (x >= 10.0)
  {
  x = x/10.0;
  ie++;
 }
 ndig += ie;                                // a la place de =+
//round. x is between 1 and 10 and ndig will be printed to
// right of decimal point so rounding is ...
for (y = i = 1; i < ndig; i++)
  y = y/10.;
x += y/2.;
if (x >= 10.0) {x = 1.0; ie++;}
if (ie<0)
  {
   *str++ = '0'; *str++ = '.';
   if (ndig < 0) ie = ie-ndig;
   for (i = -1; i > ie; i--)  *str++ = '0';
  }
for (i=0; i < ndig; i++)
  {
  k = x;
  *str++ = k + '0';
  if (i ==  ie ) *str++ = '.';
  x -= (y=k);
  x *= 10.0;
  }
*str = '\0';
}


// variables
char TEXTE[20];
char *txt;
unsigned int EA0;
float f1;

// utilisation 

txt=&TEXTE[0];  // un pointeur sur une table de caracteres
EA0=ADC_Read(0); // lecture ADC 
f1=(float)EA0 * 0,0048828;   // *5.0/1024.0
fltToa (f1,txt,2); // resultat flotant dans le texte pointé par txt , avec 2 centiemes 
UART1_Write_Text(txt);
 

[Jérémy]

Bonjour ,

Merci pour vos réponses, effectivement avec un sprintf ça fonctionne bien. Je trouve la syntaxe est peu bizarre mais bon , ceci reste un point de vue .

@Paulfjujo : Très jolie fonction . Mais toujours au dessus de mon niveau. Je me contenterai d'un sprintf pour le moment lol .

J'ai bien essayé de ruser mais sans succès. Je voulais relève la tension avec un float , puis multiplié par 100 le chiffre a virgule pour le tronquer . ensuite affiché les chiffres les uns après les autres en intercalant un point pour la virgule.

je travaille encore dessus avant de vous demandez un coup de main . Surtout que je ne sais pas me servir du debbug , pour voir mes valeurs changées en direct.

[Guest]

Une étude plus pousser du fonctionnement du C.A.N avec l'utilisation de Vref+ et Vref- pourrait être judicieuse.Dans le programme de paul il y a

Code : Tout sélectionner

f1=(float)EA0 * 0,0048828;   // *5.0/1024.0

.

Pour éviter ce chiffre à virgule, il suffit de mettre Vref+ a 5.12V cela nous donne 0.005 plus facile a multiplier ou a diviser par des rotations.
Je sais que je ramènes toujours a l'ASM mais c'est comme cela que je pratique en portant le VCC du PIC a 5.12v et garde les broches VREF, ou si utilisation de VCC 3.3V passer vref+ a 2.56 cela nous donne un pas 0.0025 de quantification . Donc toujours possibilité utiliser des rotations. gauche ou droite bien plus rapide qu'une multiplication ou division avec float surtout si fréquence d’échantillonnage et rapide cas par exemple: lecture de plusieurs mesures a rafraîchir

allez c'est dimanche je rigole.....

ma fonction conversion perso, le tableau retourne les chiffres pour le LCD

Code : Tout sélectionner

char*
near virguleAscii(float chiffreDeci)
{
unsigned int e=0;
unsigned int d=0;
 
char pointeurTab[5];
//char *p=pointeurTab;

e=(int)chiffreDeci;                                 // partie entière
d=(int)((chiffreDeci-(float)e)*100.0);                  // partie décimale(2 chiffres)

//itoa(e,p);,
//*(p+3)=0x2C;                                    // pas bon!
//itoa(d,(p+4));

pointeurTab[0]=(char)((e/100)+0x30);                  // partie entiere de 999 a 0
e=e%100;
pointeurTab[1]=(char)((e/10)+0x30);
pointeurTab[2]=(char)((e%10)+0x30);
pointeurTab[3]=0x2C;                              // j'aime bien la virgule :-)
pointeurTab[4]=(char)((d/10)+0x30);                     // partie decimale de 99 a 0
pointeurTab[5]=(char)((d%10)+0x30);

return pointeurTab;

}


PS pas fait le nettoyage enlever les //. Juste sortie de la bibliothèque du projet

Tient il serait intéressant de voir si la fonction itoa tourne avec ton compil, elle ne tournait pas sous C18
A+

[Jérémy]

???? quelle connerie ?

Je veux bien essayer , mais il me faudrait un programme entier, car je ne comprends pas sa structure, je ne pourrais donc pas l'adapter !
J'ai déjà du mal à afficher une valeur la ou je veux sur mon lcd

[Guest]

???? quelle connerie ?

fait un copier coller dans un nouveau message et oui.... donc si tu pouvez le virer merci

pour ITOA elle fait partie de la lib stdlib.h mais elle n'est pas standard donc pas pris par tout les compli

[Jérémy]

fait un copier coller dans un nouveau message et oui.... donc si tu pouvez le virer merci

Sorry je ne comprends pas !!!!

ITOA

??? kesako ?

Bon j'en suis rendu la . enfin !!!!

Je sais que ce n'est pas top , mais ça fonctionne. Si vous voyez des améliorations . Le but étant seulement de lire la valeur du ADC_read de le convertir en tension avec 2 chiffres après la virgule et de l'affiché sur le LCD . J'affiche le chiffre avec sprintfsur la première ligne, et la conversion pour gagner en mémoire sur la deuxième ligne

C'est histoire de faire un petit tutoriel sur le ADC_read, avec une petite vidéo de démonstration.

Code : Tout sélectionner

// Connections de l'écran LCD
sbit LCD_RS at LATB4_bit;
sbit LCD_EN at LATB5_bit;
sbit LCD_D4 at LATB0_bit;
sbit LCD_D5 at LATB1_bit;
sbit LCD_D6 at LATB2_bit;
sbit LCD_D7 at LATB3_bit;

sbit LCD_RS_Direction at TRISB4_bit;
sbit LCD_EN_Direction at TRISB5_bit;
sbit LCD_D4_Direction at TRISB0_bit;
sbit LCD_D5_Direction at TRISB1_bit;
sbit LCD_D6_Direction at TRISB2_bit;
sbit LCD_D7_Direction at TRISB3_bit;
// Fin connections LCD

 float coef = 0.00488;
 float valeur_lue = 0;   // Initialisation d'une variable avec virgule flottante
 unsigned int  unite, dixieme, centieme ;
 char buffer[16];

void main() {

    ANSELA = 0b00000010;       // Configure la brcohes RA1 en Analogique
    ANSELB = 0;                // Configure le PORTB en digital pour le LCD

    TRISA = 0x02;              // Met RA1 pin en entrée
    TRISB = 0x00;              // PORTB en sortie

    Lcd_Init();                // Initialisation du LCD
    Lcd_Cmd (_LCD_CLEAR);      // On efface l'écran
    Lcd_Cmd (_LCD_CURSOR_OFF); // On arrete le clignotementdu curseur
    delay_ms(500);             // Petite pause

 while (1) {                     // Boucle infinie

  valeur_lue = ADC_Read(1) * coef ;     // On convertis la valeur lue en tension

  sprintf(buffer,"%.2f V",valeur_lue) ; // Avec sprintf on affiche la valeur surla premiere ligne.
  Lcd_Out (1,1, buffer ) ;              // Affichage

  unite = valeur_lue ;                  // On sort les unites de la valeur lue
  Lcd_Chr (2,1, unite+48 ) ;            // On affcihe les unites
  Lcd_Chr (2,2,'.') ;                   // On affiche un point en guise de virgule

  dixieme = valeur_lue*10 ;             // Les décimales ; les dixiemes de Volts
  dixieme = dixieme %10 ;               // conversion
  Lcd_Chr (2,3, dixieme+48 ) ;          // affichage apres la virgule

  centieme = valeur_lue * 100 ;         // Les centiemes de Volts
  centieme = centieme %10 ;             // conversion
  Lcd_Chr (2,4, centieme+48 ) ;         // affcihage

  Lcd_Chr (2,6,'V') ;                   // On ecrit le "V" pour volt .
 }
}