Projet

Général

Profil

Télécharger (16,3 ko) Statistiques
| Révision:

root/branch/duvivier_lea/sp4a12/main.c @ 407

1 jalaffon
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
205 leduvivier
#include "trame.h"
#include <math.h>
1 jalaffon
50 leduvivier
/*Trames de tests ? modifier si n?cessaire.*/
406 leduvivier
char * trames[]= {"$GPGSV,3,2,10,15,03,077,,18,04,041,42,19,85,271,,20,08,214,*7C", /* Tableau avec differentes trames*/
1 jalaffon
"$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",
406 leduvivier
/* Declaration des structures positions, Zones et du tableau contenant des zones*/ 0};
typedef struct{ /* Definition de la position */
190 leduvivier
float latitude;
float longitude;
22 leduvivier
50 leduvivier
190 leduvivier
}Position;
381 leduvivier
Position p1,p2,p3,p4,p5,p6,p7,p8,p9,p10;
205 leduvivier
typedef struct{
Position rpos;
float vitmax;


}Zone;
406 leduvivier
Zone zones[]= /*Definition des zones dangereuses*/
205 leduvivier
{
{{44.7887762, -3.012}, 50},
{{44.7891220, -3.013},70},
190 leduvivier
205 leduvivier
};


381 leduvivier
float latitude_nbf(char* c) /* Fonction qui convertit une latitude en latitude mais en nombre flottant*/
38 leduvivier
{
int degre;
int minute1;
int minute2;
float minute11;
float minute22;
float degre11;
float resultat;
381 leduvivier
degre=decode_nombre(&c[0],2); /* Ici on recupere les termes qui nous interessent et on separe les degres et les minutes*/
38 leduvivier
minute1=decode_nombre(&c[0+2],2);
minute2=decode_nombre(&c[0+5],4);
381 leduvivier
degre11=(float)degre; /* On convertit les int en flottant*/
38 leduvivier
minute11=(float)minute1;
minute22=(float)minute2;
381 leduvivier
resultat=degre11+(minute11/60)+(minute22/600000); /* On additionne chaque terme "modifi?" pour avoir le resultat en flottant*/
38 leduvivier
return resultat;
}
381 leduvivier
float longitude_nbf(char* c) /* Fonction qui convertit une longitude en longitude mais en nombre flottant*/

46 leduvivier
{
int degre;
int minute1;
int minute2;
float minute11;
float minute22;
float degre11;
float resultat;
381 leduvivier
degre=decode_nombre(&c[0],3); /* Memes operations que pour la latitude_nbf*/
46 leduvivier
minute1=decode_nombre(&c[0+3],2);
minute2=decode_nombre(&c[0+3],4);
degre11=(float)degre;
minute11=(float)minute1;
minute22=(float)minute2;
resultat=degre11+(minute11/60)+(minute22/600000);
return resultat;
}
381 leduvivier
float lat_lon(char* c) /*Fonction qui decode indifferemment une latitude et une longitude*/
50 leduvivier
{
float resultat;
406 leduvivier
if(c[4]==46) /*On regarde ici si le caract?re 5 est un point et si oui on sait que ?a correspond ? une latitude*/
50 leduvivier
{
resultat=latitude_nbf(c);
}
else{

resultat=longitude_nbf(c);
381 leduvivier
}
50 leduvivier
return resultat;
}
381 leduvivier
int trame_cmp(char * trame, char * type) /*Fonction qui regarde si la trame commence par la chaine de caract?re type*/
22 leduvivier
{
int i;
int ok;
406 leduvivier
ok=1; /* On part du principe que la trame est correcte donc ok=1*/
381 leduvivier
for(i=0;i<5;i=i+1) /* Ici on parcourt 5 fois car il y a 5 lettres sur les debuts de trames*/
22 leduvivier
{
381 leduvivier
if(trame[i+1]!=type[i]) /* On compare element par element jusqu'? trouver une difference ou non*/
22 leduvivier
{
406 leduvivier
ok=0; /* Si difference trame incorrecte donc ok passe ? 0*/
22 leduvivier
}

}
return ok;
}
381 leduvivier
int decode_int(char c) /* Fonction qui renvoie la valeur en decimale d'un caract?re*/
22 leduvivier
{
int decode;
381 leduvivier
if(c<='9' && c>='0') /* on regarde si il est compris entre 0 et 9 dans la table ascii*/
22 leduvivier
{
381 leduvivier
decode=c-48; /* on soustrait 48 ("0") car on veut afficher la bonne correspondance*/
22 leduvivier
}
50 leduvivier
else
{
406 leduvivier
decode=-1; /* Sinon ce n'est pas un chiffre donc on retourne -1*/
50 leduvivier
}
22 leduvivier
return decode;
26 leduvivier
}
381 leduvivier
int decode_nombre(char *ch, int n) /*Fonction qui renvoit la valeur decimale des n premiers caract?res de la chaine*/
26 leduvivier
{
int i;
int resultat=0;
381 leduvivier
for(i=0;i<n;i=i+1) /* Parcourt la chaine jusqu'au nombre de caract?re souhait?*/
26 leduvivier
{
406 leduvivier
resultat=(resultat*10)+decode_int(ch[i]); /* On utilise ici *10 pour ne pas perdre le precedent chiffre ? chaque iteration */
26 leduvivier
}
return resultat;
38 leduvivier
}
50 leduvivier
381 leduvivier
int decode_trame(char* trame,Position* p) /*Fonction qui permet de verifier si une trame est correcte et qui recup?re la latitude et la longitude dans une structure*/
190 leduvivier
{
int ok;
ok=0;
406 leduvivier
if(trame[16]!=trame[17] && trame[28]!=trame[29]) /* Verifie si la trame est correcte, si il n'y a pas deux virgules ? c?t?*/
190 leduvivier
{


406 leduvivier
if(trame_cmp(trame,"GPGGA")==1) /* Regarde si la trame commence bien par GPGGA*/
190 leduvivier
{
407 leduvivier
p->latitude=latitude_nbf(&trame[17]); /* On recupere la latitude et la longitude et on les places dans la structure, 17, et 29 correspondent aux positions de latitude et longitude dans la trame*/
190 leduvivier
p->longitude=longitude_nbf(&trame[29]);
ok=1;
}
}
return ok;
}
381 leduvivier
float calcule_distance(Position p1, Position p2) /*Fonction qui permet d'obtenir la distance entre deux points qui ont comme coordonn?es la latitude et la longitude*/
192 leduvivier
{
float distance;
distance=((2*3.14*6370)/360)*sqrt((p2.latitude-p1.latitude)*(p2.latitude-p1.latitude)+(p2.longitude-p1.longitude)*(p2.longitude-p1.longitude));
return distance;
}
406 leduvivier
float calcule_vitesse(Position p1, Position p2) /*Fonction qui calcule la vitesse en km/h*/
195 leduvivier
{
float vitesse;
406 leduvivier
vitesse=(calcule_distance(p1,p2)*3600); /* *3600 pour passer en km/h*/
195 leduvivier
return vitesse;
}
406 leduvivier
int distance_a_la_plus_proche_zone(Position p, Zone r[], int nb_zones, float *d) /*Fonction qui retourne le numero de la zone dont la distance est la plus proche*/
387 leduvivier
205 leduvivier
{
406 leduvivier
*d=calcule_distance(p,r[0].rpos); /*recup?re la distance entre la position p et la position initiale de la zone dangereuse*/
352 leduvivier
float distance;
205 leduvivier
int i;
381 leduvivier
int numero_tab=0;
352 leduvivier
if (nb_zones>0) /* regarde si il y a des zones dans la table*/
381 leduvivier
{
406 leduvivier
for(i=1;i<nb_zones;i++) /*On parcourt le tableau des zones dangereuses*/
352 leduvivier
{
406 leduvivier
distance=calcule_distance(p,r[i].rpos); /*On recalcule la distance entre la position p et la zone actuelle*/
if(distance<(*d)) /*On regarde si la distance est inferieur ? celle qui compare p et la premiere zone dangereuse soit l'initialisation*/
352 leduvivier
{
205 leduvivier
387 leduvivier
(*d)=distance;
406 leduvivier
numero_tab=i; /*On increment le numero_tab pour recuperer le numero de la zone dangereuse*/
352 leduvivier
}

}
return numero_tab;
381 leduvivier
}
352 leduvivier
else{
return (-1);
381 leduvivier
}
352 leduvivier

}
406 leduvivier
void test_distance_a_la_plus_proche_zone(void) /*Test qui permet de tester la fonction de la distance de la plus proche zone*/
381 leduvivier
{
Position p,p1,p2;
407 leduvivier
p1.latitude=44.7887762; /* Valeurs des deux positions des zones dangereuses. Permet de verifier si la distance affich?e est bien celle dans les watches pour comparer et verifier le bon fonctionnement*/
381 leduvivier
p1.longitude=-3.012;
p2.latitude=44.7891220;
p2.longitude=-3.013;
406 leduvivier
decode_trame("$GPGGA,141914.00,4545.0000,N,00306.6036,E,1,05,3.4,499.3,M,,M,,*7D", &p); /*Cette trame permet de faire un test pour verifier que la fonction fonctionne*/
381 leduvivier
float d1,d2;
407 leduvivier
d1=calcule_distance(p,p1); /*On calcul les distaances pour comparer ? celles dans les watchs quand on debug*/
381 leduvivier
d2=calcule_distance(p,p2);
printf("%f\n", d1);
printf("%f\n", d2);
int nb_zone;
387 leduvivier
float *d;
406 leduvivier
nb_zone=distance_a_la_plus_proche_zone(p,zones,2,&d); /*On recupere le numero de la zone dont la distance est la plus proche ? celle de la trame*/
if(nb_zone!=0) /* Ici la distance la plus courte est celle de la premiere zone donc correspond ? l'indice 0 dans le tableau des zones*/
381 leduvivier
{
printf("Erreur dans la zone la plus proche");
exit(-1);
}
}
50 leduvivier
/*Fonction ? modifier !!!!!*/
1 jalaffon
void traitement(char * trame)
381 leduvivier
{
387 leduvivier
/*int i=0;
381 leduvivier
if(i==0)
{
406 leduvivier
test_distance_a_la_plus_proche_zone(); /* Appel de la fonction de test */
/*i=1;
381 leduvivier
exit(-1);
387 leduvivier
}*/
406 leduvivier
int trame_valide,d; /*Initialisation des variables*/
387 leduvivier
float vitesse,distance;
Position posi,posi_initiale;
if(trame_cmp(trame,"GPGGA")==1) /* Ici si la trame est correcte et commence par GPGGA, on l'affiche */
{
406 leduvivier
printf ("> %s\n",trame); /* On affiche toutes les trames GPGGA*/
decode_trame("$GPGGA,141914.00,4545.0000,N,00306.6036,E,1,05,3.4,499.3,M,,M,,*7D",&posi_initiale); /*Ici je prends la premiere trame et je la considere comme la trame initiale et je recupere sa latitude et sa longitude dans une structure*/
trame_valide=decode_trame(trame,&posi); /*Met les valeurs de latitude et longitude de la trame "du moment" dans une structure pour l'utiliser dans les calculs d'apr?s*/
vitesse=calcule_vitesse(posi,posi_initiale); /* Calcul de la vitesse entre les trames et la position "initiale"*/
387 leduvivier
distance=calcule_distance(posi,posi_initiale);
406 leduvivier
d=distance_a_la_plus_proche_zone(posi,zones,2,&distance); /*Donne le numero de la zone dangereuse la plus proche qui va permettre le declenchement de l'alarme si on est trop proche*/
381 leduvivier
406 leduvivier
if(distance<687.68 && vitesse>zones[d].vitmax) /* Compare la distance ? un seuil et la vitesse ? la vitesse max ce qui va permettre de declencher l'alarme si on est trop proche de la zone*/
387 leduvivier
{
406 leduvivier
printf("Alarme : on \n"); /* Declenchement des alarmes et affichages des distances et des vitesses pour chaque trame*/
387 leduvivier
printf("La distance est : ");
printf("%f \n", distance);
printf("La vitesse est : ");
printf("%f\n", vitesse);
}
else{
381 leduvivier
387 leduvivier
printf("Alarme : Off \n");
406 leduvivier
posi_initiale=posi; /* Si l'alarme se declenche pas on change la position initiale ? la position actuelle*/
387 leduvivier
}



}
407 leduvivier
}
387 leduvivier
381 leduvivier

406 leduvivier
/*float lat,lat2,lat3,lat4;
190 leduvivier
float longi,longi2,longi3,longi4;
int i;
i=0;
406 leduvivier
if (i==0) /*Pour faire qu'une fois le test*/
407 leduvivier
/*{
406 leduvivier
/*decode_trame("$GPGGA,141914.00,4545.0000,N,00306.6036,E,1,05,3.4,499.3,M,,M,,*7D", &p1);
decode_trame("$GPGGA,141914.00,5078.0000,N,00306.6036,E,1,05,3.4,499.3,M,,M,,*7D", &p2); /*Test unitaires qui valident le fonctionnement de decode trame*/
/*decode_trame("$GPGGA,141915.00,4545.0242,N,00306.6039,E,1,05,3.4,499.5,M,,M,,*72", &p3);
190 leduvivier
decode_trame("$GPGGA,141915.00,4554.0242,N,00306.8039,E,1,05,3.4,499.5,M,,M,,*72", &p4);
lat4=p4.latitude;
longi4=p4.longitude;
lat3=p3.latitude;
longi3=p3.longitude;
lat2=p2.latitude;
longi2=p2.longitude;
lat=p1.latitude;
longi=p1.longitude;
407 leduvivier
/* printf("%s", "La latitude et la longitude de la premiere trame sont : "); /*Affichage pour chaque trame de la position et verification que tout marche*/
/* printf("%f , %f\n", lat, longi);
381 leduvivier
printf("%s", "La latitude et la longitude de la deuxieme trame sont : ");
printf("%f , %f\n", lat2, longi2);
printf("%s", "La latitude et la longitude de la troisieme trame sont : ");
printf("%f , %f\n", lat3, longi3);
printf("%s", "La latitude et la longitude de la quatrieme trame sont : ");
printf("%f , %f\n", lat4, longi4);
p5.latitude=latitude_nbf("4545.0000"); /* Test avec les trames donn?es dans le sujet */
406 leduvivier
/*p5.longitude=longitude_nbf("00306.6036");
381 leduvivier
p6.latitude=latitude_nbf("4545.0242");
p6.longitude=longitude_nbf("00306.6039");
printf("%s", "La distance est :");
406 leduvivier
printf("%f%s", calcule_distance(p5,p6)," km\n");/*Test unitaire de calcul distance*/
/*p7.latitude=latitude_nbf("4852.0010"); /* Test distance entre Paris et Toulouse : Paris:p7 et Toulouse:p8*/
/*p7.longitude=longitude_nbf("00219.5999");
381 leduvivier
p8.latitude=latitude_nbf("4335.5999");
p8.longitude=longitude_nbf("00125.5999");
printf("%s", "La distance entre Paris et Toulouse est :");
printf("%f%s", calcule_distance(p7,p8)," km\n");
406 leduvivier
p9.latitude=latitude_nbf("4317.6000"); /* Test distance entre Marseille et Toulouse : Marseille:p5 et Toulouse:p6 ( comparaison avec travail preparatoire tout est coherent)*/
/*p9.longitude=longitude_nbf("00524.0000");
381 leduvivier
p10.latitude=latitude_nbf("4335.5999");
p10.longitude=longitude_nbf("00125.5999");
printf("%s", "La distance entre Marseille et Toulouse est :");
printf("%f%s", calcule_distance(p9,p10)," km\n");
406 leduvivier
printf("%s", "La vitesse est :"); /*Test unitaire pour verifier que le calcul de la vitesse est correct*/
/*printf("%f", calcule_vitesse(p1,p2)); /* Test de calcul Vitesse*/
381 leduvivier
/*
190 leduvivier
i=1;
exit(-1);
192 leduvivier
}*/
190 leduvivier
407 leduvivier
/*}
1 jalaffon
50 leduvivier
/*Ajouter vos tests unitaires dans cette fonction.*/
1 jalaffon
void tests_unitaires(void){
if (5!=5){
printf ("Erreur Test unitaire basique.\n");
exit(-1);
}
22 leduvivier
if (trame_cmp("$GPGGA suite chaine","GPGGA")!=1){
1 jalaffon
printf ("Erreur Test unitaire trame_cmp.\n");
exit(-1);
22 leduvivier
}
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");
exit(-1);
}
38 leduvivier
if(decode_int('5')!=5)
22 leduvivier
{
381 leduvivier
printf("Erreur du test decode int\n");
22 leduvivier
exit(-1);
26 leduvivier
}
381 leduvivier
if((decode_int('9'))!=9)
{
printf("Erreur du test decode int\n");
exit(-1);
}
26 leduvivier
if(decode_nombre("9555",2)!=95)
{
381 leduvivier
printf("Erreur du test decode nombre\n");
26 leduvivier
exit(-1);
38 leduvivier
}
381 leduvivier
if((latitude_nbf("3723.2475")-37.38)>0.01) /* On regarde combien ca nous donne ? l'aide d'une calculatrice et on met une marge d'erreur pour savoir si le nombre retourn? correspond car on ne peut pas faire tr?s precis */
38 leduvivier
{
381 leduvivier
printf("Erreur du test pour la latitude\n");
38 leduvivier
exit(-1);

46 leduvivier
}
205 leduvivier
if((longitude_nbf("00306.6036")-3.11)>0.01)
46 leduvivier
{
381 leduvivier
printf("Erreur du test pour la latitude\n");
46 leduvivier
exit(-1);

50 leduvivier
}
205 leduvivier
if ((lat_lon("00306.6036")-3.11)>0.01)
50 leduvivier
{
381 leduvivier
printf("Erreur de test pour la combinaison des deux fonctions\n");
50 leduvivier
exit(-1);
}
381 leduvivier
if ((lat_lon("3723.2475")-37.38)>0.01)
50 leduvivier
{
381 leduvivier
printf("Erreur de test pour la combinaison des deux fonctions\n");
50 leduvivier
exit(-1);
190 leduvivier
}
381 leduvivier
if((lat_lon("2526.4536")-25.44)>0.01)
{
printf("Erreur de test pour la combinaison de deux fonctions\n");
exit(-1);
}
if ((lat_lon("01304,6025")-13.07)>0.01)
{
printf("Erreur de test pour la combinaison de deux fonctions\n");
exit(-1);
}


/*if(decode_trame("$GPGPA,141914.00,4545.0000,N,00306.6036,E,1,05,3.4,499.3,M,,M,,*7D", &p1)!=1)
190 leduvivier
{
printf("Erreur de test pour decode trame");
exit(-1);
381 leduvivier
}*/ /*Trame incorrect car differente de GPGPA donc on quitte le programme*/
190 leduvivier
if(decode_trame("$GPGGA,141914.00,5078.0000,N,00306.6036,E,1,05,3.4,499.3,M,,M,,*7D", &p2)!=1)
{
printf("Erreur de test pour decode trame");
exit(-1);
}
381 leduvivier
/*if(decode_trame("$XPGGA,141915.00,4545.0242,N,00306.6039,E,1,05,3.4,499.5,M,,M,,*72", &p3)!=1)
190 leduvivier
{
printf("Erreur de test pour decode trame");
exit(-1);
381 leduvivier
}*/ /*Trame incorrect car commence par X donc quitte le programme*/
190 leduvivier
if(decode_trame("$GPGGA,141915.00,4554.0242,N,00306.8039,E,1,05,3.4,499.5,M,,M,,*72", &p4)!=1)
{
printf("Erreur de test pour decode trame");
exit(-1);
}




1 jalaffon
}

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

tests_unitaires();

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

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

return 0;
}