Index: branch/papa_ndiaye/sp4a12/main.c
===================================================================
--- branch/papa_ndiaye/sp4a12/main.c	(revision 501)
+++ branch/papa_ndiaye/sp4a12/main.c	(revision 502)
@@ -1,232 +1,471 @@
-#include <stdio.h>
-#include <stdlib.h>
+#include <stdio.h>
+#include <stdlib.h>
 #include <strings.h>
-#include <math.h>
-#include "trame.h"
-#define nbtrames 8
+#include "trame.h"
+#include <math.h>
+#define rayonter  6367.445
+//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};
 
-struct Position{
+typedef struct //Structure contenant la latitude et la longitude
+{
+  float latitude;
 
-    float lattitude;
-    float longitude;
+  float longitude;
 
+}Position ;
+
+typedef struct //Structure contenant la position et la vitesse maximale
+{
+    Position rpos;
+
+    float vitmax;
+}Zone;
+
+Zone zones[]={
+    {{44.7887762, -3.012}, 50},
+    {{44.7891220, -3.013}, 70},
+    {{45.3456220, -3.045}, 80},
+    {{46.7350220, -3.023}, 90},
 };
-//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};
 
+int trame_cmp(char* trame,char *type)
+/*fonction qui renvoie 1 si la trame commence
+par la chaîne de caractère type et zéro dans les autres cas*/
+{
+	int i, ok =1 ;
+	for(i=0 ;i<=4 ;i=i+1)
+    {
+		if (trame[i+1] !=type[i])
+        /*comparaison de la première chaine (sans le '$')
+        et de la deuxième chaine passées en paramètre*/
+		{
+			ok=0;
+        /*si des caractères diffèrent lors de la comparaison ok=0
+        et on en conclut que les deux chaines comparées ne sont pas pareils*/
+		}
+	}
+	 return ok;
+}
 
-int decode_int(char c)
-{
-    int resu;
-    if(c<'0' && c>'9')
-        resu=-1;
+int decode_int(char car)
+{  //qui renvoie la valeur décimale associée à un caractère donné en paramètre
+    int entier;
+    if(car<='9' && car>='0')
+    {
+        entier= car-48; //on soustrait au code ascii du caractère le code ascii du caractère '0'
+    }
     else
-        resu=c-48;
-    return resu;
+    {
+        entier=-1;  // si le caractere entré ne correspond pas à un chiffre on renvoie -1
+    }
+    return entier;
 }
 
-int decode_nombre(char * ch , int n)
+
+
+int decode_nombre (char *ch,int n)
+ /*fonction qui renvoie qui renvoie la valeur décimale
+ des n premiers caractères de la chaîne ch*/
 {
-    int s;
-    for(int i=0;i<n;i++)
+    int i,s=0;
+    for(i=0;i<n;i++)
     {
-        s=s+ decode_int(ch[n-1+i])*pow(10,n);
+       s=s + decode_int(ch[i])*pow(10,n-1-i);
     }
-
     return s;
+}
 
+
+float conv_lat_flottant(char * ch)
+ // fonction qui convertit les latitudes en flottant
+{
+    float latitude;
+
+    int val_degree,valEnt_min,valDec_min;
+
+    val_degree=decode_nombre(ch,2); //Recuperation de la partie entiere correspondant aux degrees
+
+    valEnt_min=decode_nombre(&ch[2],2);//Recuperation de la partie entiere des minututes
+
+    valDec_min=decode_nombre(&ch[5],4);  // recuperation de la partie decimale des minututes
+
+    latitude=val_degree + ((valEnt_min+valDec_min*0.0001)/60); // conversion en flottant
+
+    return latitude;
 }
-int trame_cmp(char * trame, char * type)
+
+
+float conv_long_flottant(char * ch)
+/*fonction convertissant la chaîne de caractère contenant
+la longitude en nombre flottant et son test unitaire.*/
 {
-    int i=4,resu =1;
-    while(resu==1 && i>=0){
+    float longitude;
+    int val_degree,valEnt_min,valDec_min;
 
-        if(trame[i+1] != type[i])
-            resu =0;
-        i--;
+    val_degree=decode_nombre(ch,3);  /* Recuperation de la partie
+                                        entiere correspondant aux degrees*/
+    valEnt_min=decode_nombre(ch+3,2);  //Recuperation de la partie entiere des minututes
 
-    }
-    return resu;
+    valDec_min=decode_nombre(ch+6,4);  //Recuperation de la partie decimale des minututes
+
+    longitude=val_degree + ((valEnt_min+valDec_min*0.0001)/60); //conversion en flottant
+
+    return longitude;
 }
-float decode_lattitude(char * ch)
+
+
+float conv_sexa_flottant(char * ch)
+// Qui décode indifféremment une latitude ou une longitude.
 {
-   int pos=0,pos1,i=0,m=0;
-       while(m==0 && pos<strlen(*ch))
-       {
+    float coordonnee;
 
-            if(ch[pos]=',')
-               {
-                    pos1++;
-                    if(pos1==3)
-                        m=1;
-                }
-             pos++;
+    if (ch[4]!='.')
+    // si la chaine contient 5 caractères avant le point on considère que c'est une longitude
+    {
+        coordonnee=conv_long_flottant(ch);
+    }
+    else
+    // sinon on considère que c'est une latitude
+    {
+        coordonnee=conv_lat_flottant(ch);
+    }
+    return coordonnee;
+}
 
-           }
 
-   float s,s1=0,s2=0,s3=0;
-    for(i=pos;i<pos+2;i++)
-        s1=s1+ decode_int(ch[i])*pow(10,pos+1-i);
-    for(i=pos+2;i<pos+4;i++)
-        s2=s2+ decode_int(ch[i])*pow(10,pos+3-i)/60;
-    for(i=pos+5;i<pos+7;i++)
-        s3=s3+ decode_int(ch[i])*pow(10,pos+6-i)/3600;
+int decode_trame(char* t, Position* p){
+    int a,i;     //a=1 si la trame est valide ; a=0 si la trame n'est pas valide
 
-    return s=s1+s2+s3 ;
+    char copie_lat[9];  //chaine dans laquelle on copiera la latitude
 
+    char copie_long[10]; //chaine dans laquelle on copiera la longitude
+
+    a=trame_cmp(t,"GPGGA");  //comparaison pour voir si la trame est valide
+
+    if(a==1)
+    {
+        for(i=0;i<9;++i)
+        {
+            copie_lat[i]=t[17+i];  //on extrait la latitude
+        }
+
+        (*p).latitude= conv_lat_flottant(copie_lat);  //on convertit la laatitude en flottant
+
+        for(i=0;i<10;++i)
+        {
+            copie_long[i]=t[29+i];  //on extrait la longitude
+        }
+        (*p).longitude=conv_long_flottant(copie_long); //on convertit la longitude en flottant
+    }
+    return a;
 }
 
-float decode_longitude(char * ch)
+float calcul_distance(Position pos, Position pos_prec){
+    float distance,A1,A2,B1,B2,C1;
+    A1=pos_prec.latitude;//Latitude du premier point
+
+    A2=pos.latitude;//Latitude du second point
+
+    B1=pos_prec.longitude;//Longitude du premier point
+
+    B2=pos_prec.longitude;//Longitude du second point
+
+    C1=B1-B2;//Difference entre les 2 longitudes
+
+    distance=(acosf(sinf(A1)*sinf(A2)+cosf(B1)*cosf(B2)*cosf(C1))*rayonter);
+
+    return distance;  //on renvoie la distance en km
+
+}
+
+float calcul_vitesse(Position pos, Position pos_prec)
 {
-   int pos=0,pos1=0,i=0,m=0;
-       while(m==0 && pos<strlen(*ch))
-       {
+    float vitesse,distance;
 
-            if(ch[pos]=',')
-               {
-                    pos1++;
-                    if(pos1==5)
-                        m=1;
-                }
-            pos++;
-           }
-   float s,s1=0,s2=0,s3=0;
-    for(i=pos;i<pos+3;i++)
-        s1=s1+ decode_int(ch[i])*pow(10,pos+1-i);
-    for(i=pos+2;i<pos+4;i++)
-        s2=s2+ decode_int(ch[i])*pow(10,pos+3-i)/60;
-    for(i=pos+5;i<pos+7;i++)
-        s3=s3+ decode_int(ch[i])*pow(10,pos+6-i)/3600;
+    distance=calcul_distance(pos,pos_prec);
 
-    return s=s1+s2+s3 ;
-}
+    vitesse=distance*3600;
+    /*le temps étant de 1s, on a directement la vitessse en m/s ,
+    on la convertit en km/h en multipliant par 3,6*/
 
-float decode(char * ch , int pos)
+    return vitesse;
+
+}
+
+int distance_a_la_plus_proche_zone(Position p,Zone r[],int nb_zones,float *d)
 {
-    int i;
-     float s,s1=0,s2=0,s3=0;
-    for(i=pos;i<pos+3;i++)
-        s1=s1+ decode_int(ch[i])*pow(10,pos+1-i);
-    for(i=pos+2;i<pos+4;i++)
-        s2=s2+ decode_int(ch[i])*pow(10,pos+3-i)/60;
-    for(i=pos+5;i<pos+7;i++)
-        s3=s3+ decode_int(ch[i])*pow(10,pos+6-i)/3600;
+    float d1;
 
-    return s=s1+s2+s3 ;
+    int a=0,i;
+
+    *d=calcul_distance(p, r[0].rpos);
+    /*on calcule la distance entre la position actuelle
+    et la premiere zone dangereuse du tableau*/
+    if(nb_zones==0)
+        a=-1;
+    for(i=1;i<nb_zones;i++)
+    {
+        d1=calcul_distance(p, r[i].rpos);
+        /*a chaque itération on calcule la distance entre la position actuelle
+                                et une zone dangeureuse*/
+        if(d1<(*d))
+        /*si cette distance est inférieure à la distance d calculée
+        ,on remplace d par cette nouvelle distance*/
+
+        {
+            (*d)=d1;
+             a=i;  // a prend la valeur de l'indice correspondant à cette zone dangereuse
+        }
+    }
+
+    return a;  // on revoie l'indice de la zone dangereuse la plus proche
 }
 
-
-
-//Fonction à modifier !!!!!
-void traitement(char * trame)
+//Fonction à modifier !!!!!
+void traitement(char * trame)
 {
-    for(int i=0; i< nbtrames ; i++)
-        if(trame_cmp(&(trame[i]),"GPGGA")==1)
+    static int cpt=0;
 
-                printf("%s",&(trame[i]));
+    cpt++;
 
+    float d,vitesse;//d=distance
 
-
+    int a,b;
+
+    int nb_zones=4;
+
+    Position p;
+
+    b=decode_trame(trame,&p);
+
+    if(b==1)
+    // si la trame est valide
+    {
+        printf("%s\n", trame);  // on affiche juste pour vérifier que la trame est valide
+
+        a=distance_a_la_plus_proche_zone(p,zones,nb_zones,&d);
+        /*on recupere l'indice de la zone dangereuse et
+        la distance entre la zone et la position actuelle*/
+
+        vitesse=calcul_vitesse(p,zones[a].rpos);
+        // on calcule la vitesse
+
+        if(d>680 && vitesse>2464890)
+        // 680=seuil de la distance et 2464890=seuil dela vitesse
+        {
+            printf("alarme=on\n");        // si les conditions sont respectées alarme=on
+
+            printf("distance: %f  ", d);
+
+            printf("vitesse;%f\n",vitesse);
+        }
+        else
+        {
+            printf("alarme=off\n");       // sinon alarme=off
+        }
+    }
 }
 
-int decode_trame(char *trame, struct Position *p)
- {
-     int a=0,s=1;
-     float r=0,q=0;
-    a= trame_cmp((trame),"GPGGA");
-    r=decode_longitude(trame);
-    q=decode_lattitude(trame);
-    if(s!=1 || r!=*(p).lattitude || q!=*(p).longitude);
+//Ajouter vos tests unitaires dans cette fonction.
+void tests_unitaires(void){
+    Position a={0.0,0.0};
+    // on initialise 2 struxtrures afin d'effecuer les test unitaires de decode_trame
+    Position b={0.0,0.0};
 
- }
-
-void test_decode_int(void)
-{
-    if (5!=5){
-        printf ("Erreur Test unitaire basique.\n");
-        exit(-1);
+    Position p1={45.750000,3.11006};
+
+    Position p3={45.750403,3.11007};
+
+    Position* p;
+
+    Position* p2;    // pour tester decode_trame
+
+    p=&a;  // on affecte à chache pointeur l'adresse d'une stru
+
+    p2=&b;
+
+    float d;
+
+    int nb_zones=4;
+
+   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");
 
-     if (decode_int('6')==-1){
+         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);
+    }
+    if (trame_cmp("$GPGGA suite chaine","GPGGA")!=1)
+    {
         printf ("Erreur Test unitaire trame_cmp.\n");
+
         exit(-1);
-     }
+    }
+    if(decode_int('0')!=0)
+    //tests decode_int
+    {
+        printf ("Erreur Test unitaire decode_int.\n");
 
-}
-void test_decode_nombre(char * ch, int n)
-{
-    int s=decode_nombre(ch, n);
-    for(int i=0;i<n;i++)
+         exit(-1);
+    }
+     if(decode_int('A')!=-1){
+        printf ("Erreur Test unitaire decode_int.\n");
+
+         exit(-1);
+    }
+    if(decode_nombre("5145",2)!=51)
+    //test decode_nombre
     {
-        s=s- decode_int(ch[n-1+i])*pow(10,n);
+        printf ("Erreur Test unitaire decode_nombre.\n");
+
+        exit(-1);
     }
-     if (5!=5){
-        printf ("Erreur Test unitaire basique.\n");
-        exit(-1);
+     if(decode_nombre("1234",2)!=12)
+    {
+        printf ("Erreur Test unitaire decode_nombre.\n");
+
+         exit(-1);
     }
+    if(conv_lat_flottant("3723.2475")-37.387458>0.0001)
+    /*test de la fonction de conversion d'une latitude en flottant/
+    prise en compte de l'erreur sur la précision*/
+    {
+        printf ("Erreur Test unitaire conv_lat_flottant.\n");
 
-     if (s!=0){
-        printf ("Erreur Test unitaire trame_cmp.\n");
         exit(-1);
-     }
+    }
+    if(conv_lat_flottant("4557.5679")-45.959465>0.0001)
+    // prise en compte de l'erreur sur la précision
+    {
+        printf ("Erreur Test unitaire conv_lat_flottant.\n");
 
-}
-//Ajouter vos tests unitaires dans cette fonction.
-void tests_unitaires(void){
-    if (5!=5){
-        printf ("Erreur Test unitaire basique.\n");
-        exit(-1);
+         exit(-1);
     }
+     if(conv_long_flottant("00306.6036")-3.11006>0.0001)
+    /*test de la fonction de conversion d'une longitude en flottant/
+    prise en compte de l'erreur sur la précision*/
+    {
+        printf ("Erreur Test unitaire conv_long_flottant.\n");
 
-     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");
+    }
+    if(conv_long_flottant("00405.3567")-4.089227>0.0001)
+    // prise en compte de l'erreur sur la précision
+    {
+        printf ("Erreur Test unitaire conv_long_flottant.\n");
+
         exit(-1);
-     }
-     if (trame_cmp("$GPRMC... ", "GPRMC" )!=1){
-        printf ("Erreur Test unitaire trame_cmp.\n");
+    }
+    if(conv_sexa_flottant("3723.2475")-37.387458>0.0001)
+    /*test de la fonction de conversion d'une coordonnée sexagésimale en flottant
+    /prise en compte de l'erreur sur la précision*/
+    {
+        printf ("Erreur Test unitaire conv_sexa_flottant.\n");
+         exit(-1);
+    }
+     if(conv_sexa_flottant("00306.6036")-3.11006>0.0001)
+     // prise en compte de l'erreur sur la précision
+    {
+        printf ("Erreur Test unitaire conv_sexa_flottant.\n");
+
         exit(-1);
-     }
-     if (trame_cmp("$APRMC...", "GPGGA")!=0){
-        printf ("Erreur Test unitaire trame_cmp.\n");
+    }
+   if(decode_trame("$GPGGA,141915.00,4545.0242,N,00306.6039,E,1,05,3.4,499.5,M,,M,,*72",p2)==0)
+   // test pour voir si la comparaison marche(trame valide ou non)
+    {
+        printf ("Erreur Test unitaire decode_trame.\n");
+
         exit(-1);
-     }
-    /*if (trame_cmp("$GPGGA suite chaine","GPGGA")!=1){
-        printf ("Erreur Test unitaire trame_cmp.\n");
-        exit(-1);
-    }*/
-}
-
-// 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 ("\nTrames de tests du fichier gps.log\n");
-    while  ((trame = trame_suivante()))
-        traitement(trame);
-
-    return 0;
-}
+    }
+   decode_trame("$GPGGA,141915.00,3723.2475,N,00306.6036,E,1,05,3.4,499.5,M,,M,,*72",p);
+   if((*p).longitude-3.11006>0.0001)
+    //test pour voir si le calcul de la longitude extraite de la trame est bon
+   {
+         printf ("Erreur Test unitaire decode_trame.\n");
+
+         exit(-1);
+   }
+   if((*p).latitude-37.387458>0.0001)
+    //test pour voir si le calcul de la latitude extraite de la trame est bon
+    {
+         printf ("Erreur Test unitaire decode_trame.\n");
+
+         exit(-1);
+
+   }
+   if(calcul_distance(p1,p3)-0.044812>0.001)
+   //test  calcul_distance (prise en com^te de l'erreur d'1m)
+    {
+        printf ("Erreur Test unitaire calcul_distance.\n");
+
+        exit(-1);
+    }
+    if(calcul_vitesse(p1,p3)-1613.232>0.01)
+    //test  calcul_vitesse (prise en compte de l'erreur)
+    {
+        printf ("Erreur Test unitaire calcul_vitesse.\n");
+
+         exit(-1);
+    }
+   if(distance_a_la_plus_proche_zone(p1,zones,nb_zones,&d)!=2)
+   //test  distance_a_la_plus_proche (prise en compte de l'erreur)
+    {
+        printf ("Erreur Test unitaire calcul_distance_plus_proche.\n");
+
+        exit(-1);
+    }
+
+
+
+}
+
+
+// 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;
+}
