Projet

Général

Profil

Télécharger (8,62 ko) Statistiques
| Révision:

root/branch/Morales/sp4a12/main.c @ 197

1 jalaffon
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include "trame.h"

//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",
"$GPRMC,141914.00,A,4545.6424,N,00306.6036,E,0.4,99.4,010206,,*0C",
"$GPGLL,4545.6424,N,00306.6036,E,141914.00,A*0E",
"$GPGGA,141914.00,4545.0000,N,00306.6036,E,1,05,3.4,499.3,M,,M,,*7D",
"$GPGSA,A,3,,03,,22,14,,01,,18,,,,3.9,3.4,1.9*39",
"$GPVTG,99.4,T,,M,0.4,N,0.7,K*57",
"$GPZDA,141914.00,01,02,2006,00,00*69",
0};
3 jalaffon
48 mamorales
//fonction comparant les trames
int trame_cmp(char* trame,char* type)
{
int i=1;
80 mamorales
int comp=1; // comparateur
int end_comp=1; //permet de savoir quand arreter la comparaison
while (end_comp!='\0') // comparaison
48 mamorales
{
if (trame[i]!=type[i-1])
{
comp=0;
}
i=i+1;
end_comp=type[i];
}
return comp;
3 jalaffon
}
57 mamorales
63 mamorales
//fonction qui retourne l'entier correspondant au caractere mis en argument. (le caract?re '1' retourne l'entier 1)
int decode_int (char c)
{
80 mamorales
int return_var=0; // variable de retour
63 mamorales
if ((c>=48)&&(c<=57))
{
80 mamorales
return_var=c-48;
63 mamorales
}
else
{
80 mamorales
(return_var=-1);
63 mamorales
}
80 mamorales
return return_var;
63 mamorales
}

80 mamorales
//fonction retournant uniquement les n premier chiffres dans un nombre.
int decode_nombre(char * ch,int n)
{
int i=0;
int nbr_return=0;
while (i<n)
{
nbr_return = nbr_return*10 + decode_int(ch[i]);
i=i+1;
}
return nbr_return;
}
63 mamorales
197 mamorales
//fonction covertissant des sexagesimal (latitude ou longitude) en reel
80 mamorales
float sexagesimal_to_float(float lat)
{
197 mamorales
int float_deg=lat/100;
float float_minutes=0;
float value = 0;
80 mamorales
197 mamorales
float_minutes = (lat-float_deg*100)/60;
value = float_deg + float_minutes;
80 mamorales
197 mamorales
return value;
80 mamorales
}

//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;
197 mamorales
int val_entiere_taille = 0;
int val_decimale_taille = 0;
80 mamorales
int nbr_virgule=0;
float lat=0;
197 mamorales
char val_entiere[6];
char val_decimal[6];
80 mamorales
197 mamorales
while (nbr_virgule<2) // on compte jusqu? la deuxi?me virgule (3?me champs)
80 mamorales
{
if (trame[i]==',')
{
nbr_virgule = nbr_virgule+1;
}
i++;
}
197 mamorales
// 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]!='.')
80 mamorales
{
197 mamorales
val_entiere[j]=trame[i];
j++; // stock la partie entiere
80 mamorales
i++;
}
197 mamorales
val_entiere_taille = j;
j=0;
i++; // on ne stock pas le point dans les chaines
while (trame[i]!=',')
80 mamorales
{
197 mamorales
val_decimal[j]=trame[i]; // stock la partie decimale
j++;
80 mamorales
i++;
}
197 mamorales
val_decimale_taille = j;
80 mamorales
197 mamorales

lat = decode_nombre(val_entiere,val_entiere_taille) + 0.0001* decode_nombre(val_decimal,val_decimale_taille); //on stock la valeur de la latitude

lat = sexagesimal_to_float(lat); // transformation en flottant
80 mamorales
return lat;
}

//fonction convertissant la cha?ne de caract?re contenant la longitude en nombre flottant
float longitude_sexagesimal(char* trame)
{
int i=0;
int j=0;
197 mamorales
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
80 mamorales
int nbr_virgule=0;
float longitude=0;
197 mamorales
char val_entiere[6]; //valeur entiere de la longitude, on reserve 6 cases par s?curit?.
char val_decimal[6];
80 mamorales
197 mamorales
while (nbr_virgule<4) // on compte jusqu? la quatri?me virgule (5?me champs)
80 mamorales
{
if (trame[i]==',')
{
nbr_virgule = nbr_virgule+1;
}
i++;
}
197 mamorales
// 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]!='.')
80 mamorales
{
197 mamorales
val_entiere[j]=trame[i];
j++; // stock la partie entiere
80 mamorales
i++;
}
197 mamorales
val_entiere_taille = j;
j=0;
i++; // on ne stock pas le point dans les chaines
while (trame[i]!=',')
80 mamorales
{
197 mamorales
val_decimal[j]=trame[i]; // stock la partie decimale
j++;
80 mamorales
i++;
}
197 mamorales
val_decimale_taille = j;
80 mamorales
197 mamorales
longitude = decode_nombre(val_entiere,val_entiere_taille) + 0.0001* decode_nombre(val_decimal,val_decimale_taille); //on stock la valeur de la longitude
80 mamorales
longitude = sexagesimal_to_float(longitude);

return longitude;
}


1 jalaffon
//Fonction ? modifier !!!!!
void traitement(char * trame)
46 mamorales
{
80 mamorales

46 mamorales
static int cpt = 0;
57 mamorales
cpt++;
if (trame_cmp(trame,"GPGGA"))
{
printf ("> %s\n",trame);
80 mamorales
printf("latitude en reel : %f\n",lat_sexagesimal(trame));
printf("longitude en reel : %f\n\n",longitude_sexagesimal(trame));
57 mamorales
}
1 jalaffon
}

//Ajouter vos tests unitaires dans cette fonction.
48 mamorales
void tests_unitaires(void){

if (5!=5){
1 jalaffon
printf ("Erreur Test unitaire basique.\n");
exit(-1);
}
if (trame_cmp("$GPGGA suite chaine","GPGGA")!=1){
printf ("Erreur Test unitaire trame_cmp.\n");
exit(-1);
}
if (trame_cmp("$GPRMC suite chaine","GPGGA")!=0){
printf ("Erreur Test unitaire trame_cmp.\n");
exit(-1);
}
if (trame_cmp("$GPRMC... ", "GPRMC" )!=1){
printf ("Erreur Test unitaire trame_cmp.\n");
exit(-1);
}
if (trame_cmp("$APRMC...", "GPGGA")!=0){
printf ("Erreur Test unitaire trame_cmp.\n");
63 mamorales
exit(-1);
}
80 mamorales
if (decode_int('0')!=0)
63 mamorales
{
printf ("Erreur Test unitaire decode_int.\n");
exit(-1);
80 mamorales
}
if (decode_int('1')!=1)
{
printf ("Erreur Test unitaire decode_int.\n");
exit(-1);
}
if (decode_int('2')!=2)
{
printf ("Erreur Test unitaire decode_int.\n");
exit(-1);
}
if (decode_int('3')!=3)
{
printf ("Erreur Test unitaire decode_int.\n");
exit(-1);
}
if (decode_int('4')!=4)
{
printf ("Erreur Test unitaire decode_int.\n");
exit(-1);
}
if (decode_int('5')!=5)
{
printf ("Erreur Test unitaire decode_int.\n");
exit(-1);
}
if (decode_int('6')!=6)
{
printf ("Erreur Test unitaire decode_int.\n");
exit(-1);
}
if (decode_int('7')!=7)
{
printf ("Erreur Test unitaire decode_int.\n");
exit(-1);
}
if (decode_int('8')!=8)
{
printf ("Erreur Test unitaire decode_int.\n");
exit(-1);
}
if (decode_int('9')!=9)
{
printf ("Erreur Test unitaire decode_int.\n");
exit(-1);
}
if (decode_int('A')!=-1)
{
printf ("Erreur Test unitaire decode_int.\n");
exit(-1);
}
if (decode_nombre("7541",2)!=75)
{
printf ("Erreur Test unitaire decode_nombre.\n");
exit(-1);
}
if (decode_nombre("7541",3)!=754)
{
printf ("Erreur Test unitaire decode_nombre.\n");
exit(-1);
}
if (decode_nombre("123",3)!=123)
{
printf ("Erreur Test unitaire decode_nombre.\n");
exit(-1);
}
if (decode_nombre("987654321",2)!=98)
{
printf ("Erreur Test unitaire decode_nombre.\n");
exit(-1);
48 mamorales
}
197 mamorales
/*if ((sexagesimal_to_float (3723.2475)<=37,387458)||(sexagesimal_to_float (3723.2475)>=37,387460))
80 mamorales
{
printf ("Erreur Test unitaire sexagesimal_to_float.\n");
exit(-1);
197 mamorales
}*/
1 jalaffon
}

// Ne pas modifier cette fonction
int main(int argc,char ** argv)
{

tests_unitaires();

// Affichage des trames definies dans la table trames.
printf ("Trames de tests tableau trames:\n");
int i=0;
while (trames[i])
traitement(trames[i++]);

if (!trame_init())
exit(-1);
// Affichage des trames du fichier gps.log
char *trame;
printf ("Trames de tests du fichier gps.log\n");
while ((trame = trame_suivante()))
traitement(trame);

return 0;
}