Projet

Général

Profil

« Précédent | Suivant » 

Révision 198

Ajouté par mamorales il y a presque 4 ans

Finalisation du TP, modification de la fonction capable de convertir toute latitude/longitude sexagésimal, unification des deux fonction pour récupérer la longitude et la latitude dans les trame en une seule fonction.
Ajout des test unitaires de la question 11.

Voir les différences:

branch/Morales/sp4a12/main.c
"$GPZDA,141914.00,01,02,2006,00,00*69",
0};
// structure pour la longitude et la latitude.
typedef struct {
float latitude;
float longitude;
} Position ;
// initialisation des fonctions.
int trame_cmp(char* trame,char* type);
int decode_int (char c);
int decode_nombre(char * ch,int n);
float sexagesimal_to_float(char* value);
float lat_sexagesimal(char* trame);
float longitude_sexagesimal(char* trame);
int decode_trame (char*trame, Position *p);
//fonction comparant les trames
int trame_cmp(char* trame,char* type)
{
......
}
//fonction covertissant des sexagesimal (latitude ou longitude) en reel
float sexagesimal_to_float(float lat)
float sexagesimal_to_float(char* value)
{
int float_deg=lat/100;
float float_minutes=0;
float value = 0;
float_minutes = (lat-float_deg*100)/60;
value = float_deg + float_minutes;
return value;
}
//fonction convertissant la cha?ne de caract?re contenant la latitude en nombre flottant
float lat_sexagesimal(char* trame)
{
int i=0;
int j=0;
int val_entiere_taille = 0;
int val_decimale_taille = 0;
int nbr_virgule=0;
float lat=0;
char val_entiere[6];
char val_decimal[6];
int val_entiere_taille = 0; // taille de la partie entiere de la valeur
int val_decimale_taille = 0; // taille de la partie decimal de la valeur
char val_entiere[10]={0}; //valeur entiere de la longitude, on reserve 6 cases par s?curite.
char val_decimal[10]={0}; //valeur decimale de la longitude, on reserve 6 cases par s?curite.
float sexages_value=0;
float float_val=0;
while (nbr_virgule<2) // on compte jusqu? la deuxi?me virgule (3?me champs)
{
if (trame[i]==',')
{
nbr_virgule = nbr_virgule+1;
}
i++;
}
// on ne peux pas passer directement d'un caract?re avec des virgule ? un flottant, du coup on passe par deux cha?ne de caract?res
// intermediares pour avoir ce qui correspond ? la partie enti?re et ce qui correspond ? la partie decimale
// on ne peux pas passer directement d'un caract?re avec des virgule ? un flottant, du coup on passe par deux cha?ne de caract?res
// intermediares pour avoir ce qui correspond ? la partie enti?re et ce qui correspond ? la partie decimale
while (trame[i]!='.')
while (value[i]!='.')
{
val_entiere[j]=trame[i];
val_entiere[j]=value[i];
j++; // stock la partie entiere
i++;
}
val_entiere_taille = j;
j=0;
i++; // on ne stock pas le point dans les chaines
while (trame[i]!=',')
j=0; //reinitialise j
i++; // on ne stock pas le point dans les 2 chaines
while (value[i]!='\0')
{
val_decimal[j]=trame[i]; // stock la partie decimale
val_decimal[j]=value[i]; // stock la partie decimale
j++;
i++;
}
val_decimale_taille = j;
// stockage de la valeur sexagesimale
sexages_value = decode_nombre(val_entiere,val_entiere_taille) + 0.0001* decode_nombre(val_decimal,val_decimale_taille);
int float_deg=sexages_value/100;
float float_minutes=0;
lat = decode_nombre(val_entiere,val_entiere_taille) + 0.0001* decode_nombre(val_decimal,val_decimale_taille); //on stock la valeur de la latitude
float_minutes = (sexages_value-float_deg*100)/60;
float_val = float_deg + float_minutes;
lat = sexagesimal_to_float(lat); // transformation en flottant
return lat;
return float_val;
}
//fonction convertissant la cha?ne de caract?re contenant la longitude en nombre flottant
float longitude_sexagesimal(char* trame)
//fonction convertissant la latitude et longitude en reels.
int decode_trame(char* trame,Position *p)
{
int i=0;
int j=0;
int val_entiere_taille = 0; // taille de la partie entiere de la longitude
int val_decimale_taille = 0; // taille de la partie d?cimal de la longitude
int nbr_virgule=0;
float longitude=0;
char val_entiere[6]; //valeur entiere de la longitude, on reserve 6 cases par s?curit?.
char val_decimal[6];
char lat[15]={0};
char longit[15]={0};
if (trame_cmp(trame,"GPGGA")==0)
{
return 0;
}
//calcul latitude
while (nbr_virgule<3) // on compte jusqu'a la troisieme virgule
{
while (nbr_virgule<2) // on compte jusqu'a la deuxieme virugle (troisieme champs)
{
if (trame[i]==',')
{
nbr_virgule = nbr_virgule+1;
}
i++;
}
while (nbr_virgule<4) // on compte jusqu? la quatri?me virgule (5?me champs)
{
lat[j]=trame[i];
j++;
i++;
if (trame[i]==',')
{
nbr_virgule = nbr_virgule+1;
}
i++;
}
// on ne peux pas passer directement d'un caract?re avec des virgule ? un flottant, du coup on passe par deux cha?ne de caract?res
// intermediares pour avoir ce qui correspond ? la partie enti?re et ce qui correspond ? la partie decimale
while (trame[i]!='.')
p->latitude = sexagesimal_to_float(lat); // transformation en flottant
j=0; //reinitialise j
i++; // une it?ration de i pour avoir i!=','
// calcul longitude
while (nbr_virgule<5) // on compte jusqu'a la troisieme virgule
{
val_entiere[j]=trame[i];
j++; // stock la partie entiere
i++;
}
val_entiere_taille = j;
j=0;
i++; // on ne stock pas le point dans les chaines
while (trame[i]!=',')
{
val_decimal[j]=trame[i]; // stock la partie decimale
while (nbr_virgule<4) // on compte jusqu'a la deuxieme virugle (cinquieme champs)
{
if (trame[i]==',')
{
nbr_virgule = nbr_virgule+1;
}
i++;
}
longit[j]=trame[i];
j++;
i++;
if (trame[i]==',')
{
nbr_virgule = nbr_virgule+1;
}
}
val_decimale_taille = j;
longitude = decode_nombre(val_entiere,val_entiere_taille) + 0.0001* decode_nombre(val_decimal,val_decimale_taille); //on stock la valeur de la longitude
longitude = sexagesimal_to_float(longitude);
p->longitude = sexagesimal_to_float(longit); // transformation en flottant
return longitude;
return 1;
}
//Fonction ? modifier !!!!!
void traitement(char * trame)
{
Position p;
static int cpt = 0;
cpt++;
if (trame_cmp(trame,"GPGGA"))
if (decode_trame(trame,&p))
{
printf ("> %s\n",trame);
printf("latitude en reel : %f\n",lat_sexagesimal(trame));
printf("longitude en reel : %f\n\n",longitude_sexagesimal(trame));
printf("latitude en reel : %f\n",p.latitude);
printf("longitude en reel : %f\n\n",p.longitude);
}
}
......
printf ("Erreur Test unitaire decode_nombre.\n");
exit(-1);
}
/*if ((sexagesimal_to_float (3723.2475)<=37,387458)||(sexagesimal_to_float (3723.2475)>=37,387460))
if ((sexagesimal_to_float ("3723.2475")<=37.387458)||(sexagesimal_to_float ("3723.2475")>=37.387459))
{
printf ("Erreur Test unitaire sexagesimal_to_float.\n");
exit(-1);
}*/
}
if ((sexagesimal_to_float ("00306.6036")<=3.11006)||(sexagesimal_to_float ("00306.6036")>=3.11007))
{
printf ("Erreur Test unitaire sexagesimal_to_float.\n");
exit(-1);
}
}
// Ne pas modifier cette fonction

Formats disponibles : Unified diff