Projet

Général

Profil

« Précédent | Suivant » 

Révision 406

Ajouté par Lea DUVIVIER il y a presque 3 ans

Fin tp + Ajout des commentaires

Voir les différences:

main.c
#include <math.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",
char * trames[]= {"$GPGSV,3,2,10,15,03,077,,18,04,041,42,19,85,271,,20,08,214,*7C", /* Tableau avec differentes trames*/
"$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",
......
"$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",
/* Declaration des structures positions, Zones et du tableau contenant des zones*/ 0};
typedef struct{
/* Declaration des structures positions, Zones et du tableau contenant des zones*/ 0};
typedef struct{ /* Definition de la position */
float latitude;
float longitude;
......
}Zone;
int decode_nombre(char *ch, int n);
Zone zones[]=
Zone zones[]= /*Definition des zones dangereuses*/
{
{{44.7887762, -3.012}, 50},
{{44.7891220, -3.013},70},
......
float lat_lon(char* c) /*Fonction qui decode indifferemment une latitude et une longitude*/
{
float resultat;
if(c[4]==46) /*On regarde ici si le caract?re 5 est un point et si oui on c'est que ?a correspond ? une latitude*/
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*/
{
resultat=latitude_nbf(c);
}
......
{
int i;
int ok;
ok=1;
ok=1; /* On part du principe que la trame est correcte donc ok=1*/
for(i=0;i<5;i=i+1) /* Ici on parcourt 5 fois car il y a 5 lettres sur les debuts de trames*/
{
if(trame[i+1]!=type[i]) /* On compare element par element jusqu'? trouver une difference ou non*/
{
ok=0;
ok=0; /* Si difference trame incorrecte donc ok passe ? 0*/
}
}
......
}
else
{
decode=-1;
decode=-1; /* Sinon ce n'est pas un chiffre donc on retourne -1*/
}
return decode;
......
int resultat=0;
for(i=0;i<n;i=i+1) /* Parcourt la chaine jusqu'au nombre de caract?re souhait?*/
{
resultat=(resultat*10)+decode_int(ch[i]); /* On utilise ici *10 pour ne pas perdre le precedent chiffre ? chaque iteration*/
resultat=(resultat*10)+decode_int(ch[i]); /* On utilise ici *10 pour ne pas perdre le precedent chiffre ? chaque iteration */
}
return resultat;
}
......
{
int ok;
ok=0;
if(trame[16]!=trame[17] && trame[28]!=trame[29]) /* Verifie si la trame est correcte*/
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?*/
{
if(trame_cmp(trame,"GPGGA")==1)
if(trame_cmp(trame,"GPGGA")==1) /* Regarde si la trame commence bien par GPGGA*/
{
p->latitude=latitude_nbf(&trame[17]);
p->latitude=latitude_nbf(&trame[17]); /* On recupere la latitude et la longitude et on les places dans la structure*/
p->longitude=longitude_nbf(&trame[29]);
ok=1;
}
......
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;
}
float calcule_vitesse(Position p1, Position p2)
float calcule_vitesse(Position p1, Position p2) /*Fonction qui calcule la vitesse en km/h*/
{
float vitesse;
vitesse=(calcule_distance(p1,p2)*3600);
vitesse=(calcule_distance(p1,p2)*3600); /* *3600 pour passer en km/h*/
return vitesse;
}
int distance_a_la_plus_proche_zone(Position p, Zone r[], int nb_zones, float *d)
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*/
{
*d=calcule_distance(p,r[0].rpos);
*d=calcule_distance(p,r[0].rpos); /*recup?re la distance entre la position p et la position initiale de la zone dangereuse*/
float distance;
int i;
int numero_tab=0;
if (nb_zones>0) /* regarde si il y a des zones dans la table*/
{
for(i=1;i<nb_zones;i++)
for(i=1;i<nb_zones;i++) /*On parcourt le tableau des zones dangereuses*/
{
distance=calcule_distance(p,r[i].rpos);
if(distance<(*d))
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*/
{
(*d)=distance;
numero_tab=i;
numero_tab=i; /*On increment le numero_tab pour recuperer le numero de la zone dangereuse*/
}
......
}
void test_distance_a_la_plus_proche_zone(void)
void test_distance_a_la_plus_proche_zone(void) /*Test qui permet de tester la fonction de la distance de la plus proche zone*/
{
Position p,p1,p2;
p1.latitude=44.7887762;
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*/
p1.longitude=-3.012;
p2.latitude=44.7891220;
p2.longitude=-3.013;
decode_trame("$GPGGA,141914.00,4545.0000,N,00306.6036,E,1,05,3.4,499.3,M,,M,,*7D", &p);
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*/
float d1,d2;
d1=calcule_distance(p,p1);
d2=calcule_distance(p,p2);
......
printf("%f\n", d2);
int nb_zone;
float *d;
nb_zone=distance_a_la_plus_proche_zone(p,zones,2,&d);
if(nb_zone!=0)
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*/
{
printf("Erreur dans la zone la plus proche");
exit(-1);
......
/*int i=0;
if(i==0)
{
test_distance_a_la_plus_proche_zone();
i=1;
test_distance_a_la_plus_proche_zone(); /* Appel de la fonction de test */
/*i=1;
exit(-1);
}*/
int trame_valide,d;
int trame_valide,d; /*Initialisation des variables*/
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 */
{
printf ("> %s\n",trame);
decode_trame("$GPGGA,141914.00,4545.0000,N,00306.6036,E,1,05,3.4,499.3,M,,M,,*7D",&posi_initiale);
trame_valide=decode_trame(trame,&posi);
vitesse=calcule_vitesse(posi,posi_initiale);
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"*/
distance=calcule_distance(posi,posi_initiale);
d=distance_a_la_plus_proche_zone(posi,zones,2,&distance);
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*/
if(distance<687.68 && vitesse>zones[d].vitmax)
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*/
{
printf("Alarme : on \n");
printf("Alarme : on \n"); /* Declenchement des alarmes et affichages des distances et des vitesses pour chaque trame*/
printf("La distance est : ");
printf("%f \n", distance);
printf("La vitesse est : ");
......
else{
printf("Alarme : Off \n");
posi_initiale=posi;
posi_initiale=posi; /* Si l'alarme se declenche pas on change la position initiale ? la position actuelle*/
}
......
/* float lat,lat2,lat3,lat4;
/*float lat,lat2,lat3,lat4;
float longi,longi2,longi3,longi4;
int i;
i=0;
if (i==0)
if (i==0) /*Pour faire qu'une fois le test*/
{
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);
decode_trame("$GPGGA,141915.00,4545.0242,N,00306.6039,E,1,05,3.4,499.5,M,,M,,*72", &p3);
/*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);
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;
......
longi2=p2.longitude;
lat=p1.latitude;
longi=p1.longitude;
printf("%s", "La latitude et la longitude de la premiere trame sont : "); /*Affichage pour chaque trame de la position */
/* 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);
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 quatrieme trame sont : ");
printf("%f , %f\n", lat4, longi4);
p5.latitude=latitude_nbf("4545.0000"); /* Test avec les trames donn?es dans le sujet */
/* p5.longitude=longitude_nbf("00306.6036");
/*p5.longitude=longitude_nbf("00306.6036");
p6.latitude=latitude_nbf("4545.0242");
p6.longitude=longitude_nbf("00306.6039");
printf("%s", "La distance est :");
printf("%f%s", calcule_distance(p5,p6)," km\n");
p7.latitude=latitude_nbf("4852.0010"); /* Test distance entre Paris et Toulouse : Paris:p7 et Toulouse:p8*/
/* p7.longitude=longitude_nbf("00219.5999");
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");
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");
p9.latitude=latitude_nbf("4317.6000"); /* Test distance entre Marseille et Toulouse : Marseille:p5 et Toulouse:p6*/
/* p9.longitude=longitude_nbf("00524.0000");
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");
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");
printf("%s", "La vitesse est :");
printf("%f", calcule_vitesse(p1,p2)); /* Test de calcul Vitesse*/
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*/
/*
i=1;
exit(-1);

Formats disponibles : Unified diff