Projet

Général

Profil

« Précédent | Suivant » 

Révision 340

Ajouté par Clara SOULARD il y a presque 3 ans

avance sur decode_trame, problème de conversion avec pointeurs

Voir les différences:

main.c
#include <stdlib.h>
#include <strings.h>
#include "trame.h"
typedef struct {
float latitude;
float longitude;
} Position ;
//Trames de tests ? modifier si n?cessaire.
char * trames[]= {"$GPGSV,3,2,10,15,03,077,,18,04,041,42,19,85,271,,20,08,214,*7C",
"$GPGSV,3,3,10,22,39,053,50,28,15,320,*7E",
......
a=decode_int(ch[i]);
c=c*10+a;
}
printf("%d",c);
return c;
}
float convertisseur_latitude (char *ch)
/*float convertisseur_latitude (char *ch)
{
float lat;
......
decimal=(float)((decimal1 + ((float)(decimal2)/10000))/60);
lat=degres+decimal;
return lat;
}*/
float convertisseur_latitude (char *ch)
{
float lat=0.0;
float degre=(float)decode_nombre(ch,2);
float decim1=(float)decode_nombre(ch,4)-degre*pow(10,2);
char chaine[50];
int i;
for (i=5; i<9; i++)
{
chaine[i-5]=ch[i];
}
float decim2=(float)decode_nombre(chaine, 4); //ok
decim1=decim1/60.0;
decim2=decim2/600000.0;
lat=degre+decim1+decim2;
return lat;
}
float convertisseur_longitude (char *ch)
{
float longi=0.0;
float degre=(float)decode_nombre(ch,3);
float decim1=(float)decode_nombre(ch,5)-degre*pow(10,2);
char chaine[50];
int i;
for (i=6; i<10; i++)
{
chaine[i-6]=ch[i];
}
float decim2=(float)decode_nombre(chaine, 4); //ok
decim1=decim1/60.0;
decim2=decim2/600000.0;
longi=degre+decim1+decim2;
return longi;
}
float latoulong (char *ch)
{
int i;
i=strlen(ch);
if (i==9)
{
return convertisseur_latitude(ch);
}
else
{
return convertisseur_longitude(ch);
}
}
int decode_trame(char *trame, Position *p)
{
char latit[10]; //chaine de caract?res qui vont servir ? copier les latitudes et les longitudes pour les convertir en flottants
char longit[15];
char *lat;
lat=&latit;
int k;
int i=0;
int j;
int ok;
float longitude=0.0;
float latitude=0.0;
if (trame_cmp(trame, "GPGGA")!=1) //on utilise la fonction d?j? cr?e au tp1 pour comparer le debut de la trame et voir si elle est correcte
{
return 0;
}
else
{ ok=1;
int cptvir=0; //on compte les virgules dans la trame pour se reperer et savoir ou sont la latitude et la longitude
while (trame[i]!='\0')
{
i=i+1;
if (trame[i]==',') //on detecte les virgules
{
cptvir=cptvir+1;
if (cptvir==2) //la deuxi?me virgule marque le debut des coordonn?es de la latitude
{
for(k=i+1; k<i+10; k++)
{
latit[k-i]=trame[k]; //debugger ici ok fonctionne
}
printf("%f :", latitude=convertisseur_latitude(latit));
}
if (cptvir==4)
{
for(j=i+1; j<i+11; j++)
{
longit[j-i]=trame[j];
}
longitude=convertisseur_longitude(longit);
}
}
}
}
return ok;
}
//Fonction ? modifier !!!!!
void traitement(char * trame)
{
......
}
//Ajouter vos tests unitaires dans cette fonction.
void tests_unitaires(void){
void tests_unitaires(void){
Position a={0.0, 1.0};
Position *p;
p=&a;
if (5!=5){
printf ("Erreur Test unitaire basique.\n");
exit(-1);
}
if (trame_cmp("$GPGGA suite chaine","GPGGA")!=1){
if (trame_cmp("$GPGGA,141922.00,4545.1810,N,00306.6046,E,1,05,3.4,500.6,M,,M,,*74","GPGGA")!=1){
printf ("Erreur 1 Test unitaire trame_cmp.\n");
exit(-1);
}
......
if(decode_int('4')!=4){
printf("Erreur 4 test unitaire decode_int.\n");
}
/*if(decode_nombre("789654",3)!=789){
if(decode_nombre("789654",3)!=789){
printf("Erreur sur decode_nombre.\n");
}
if(decode_nombre("789654",4)!=7896){
printf("Erreur sur decode_nombre.\n");
}*/
printf(" ?a donne : %f\n",convertisseur_latitude("3723.2475"));
}
if(convertisseur_latitude("4545.1810")<45.7000 || convertisseur_latitude("4545.1810")>45.8000 ) //comme c'est des float on ne peut que encadrer la valeur
{
printf("Erreur sur le convertisseur latitude");
}
if(convertisseur_longitude("00306.6046")<03.0000 || convertisseur_latitude("00306.6046")>03.4000 )
{
printf("Erreur sur le convertisseur longitude");
}
if (decode_trame("$GPGGA,141922.00,4545.1810,N,00306.6046,E,1,05,3.4,500.6,M,,M,,*74",p)!=1) {
printf("Erreur sur decode_trame");
}
printf("le resultat est : %i", decode_trame("$GPGGA,141922.00,4545.1810,N,00306.6046,E,1,05,3.4,500.6,M,,M,,*74", p));
}

Formats disponibles : Unified diff