Index: branch/Morales/sp4a12/main.c
===================================================================
--- branch/Morales/sp4a12/main.c	(revision 210)
+++ branch/Morales/sp4a12/main.c	(revision 211)
@@ -1,9 +1,14 @@
 #include <stdio.h>
 #include <stdlib.h>
-#include <strings.h>
+#include <strings.h>
+#include <math.h>
 #include "trame.h"
-
-//Trames de tests à modifier si nécessaire.
+/*
+****************************
+    DONNEES CONSTANTES
+****************************
+*/
+//Trames de tests
 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",
@@ -12,7 +17,7 @@
                     "$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};
+                    0};
 
 // structure pour la longitude et la latitude.
 typedef struct {
@@ -20,47 +25,70 @@
 float longitude;
 } Position ;
 
+//structure des zones dangereuses
+typedef struct {
+ Position rpos;
+ float vitmax;
+ } Zone ;
+
+Zone zones[] = {
+ {{44.7887762, -3.012}, 50}, /* Descripteur de la première zone */
+ {{44.7891220, -3.013}, 70}, /* Descripteur de la 2eme zone */
+ {{44.8384094, -3.013005}, 110}, /* Descripteur de la 3eme zone */
+ {{44.9312729, -3.018929}, 130}, /* Descripteur de la 4eme zone */
+ {{45.0344601, -3.244438}, 30}, /* Descripteur de la 5eme zone */
+ {{45.3004, -3.00154635}, 20},  /* Descripteur de la 6eme zone */
+ {{45.4369, -3.005612}, 30},    /* Descripteur de la 7eme zone */
+ {{45.2433, -3.085264}, 160},   /* Descripteur de la 8eme zone */
+ {{45.6999, -3}, 140},           /* Descripteur de la 9eme zone */
+ {{45.1248, -3.00094635},80},   /* Descripteur de la 10eme zone */
+ {{45.7625, -3.005555}, 90},    /* Descripteur de la 11eme zone */
+};
+#define nbr_zones 11            // definit le nombre total de zones.
+
 // 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);
+float calcul_vitesse (Position pos, Position pos_prec);
+int distance_a_la_plus_proche_zone (Position p, Zone r[], int nb_zones, float *d);
+void traitement(char * trame);
 
-
-
-
+/*
+*****************************
+    FONCTIONS DE CALCUL
+*****************************
+*/
 //fonction comparant les trames
 int trame_cmp(char* trame,char* type)
 {
-int i=1;
-int comp=1;                             // comparateur
-int end_comp=1;                         //permet de savoir quand arreter la comparaison
-    while (end_comp!='\0')              // comparaison
+int i=1;                // initialisé à 1 pour ne pas prendre en compte le $
+int end_comp=1;                    //permet de savoir quand arreter la comparaison
+    while (end_comp!='\0')         // comparaison
     {
         if (trame[i]!=type[i-1])
         {
-            comp=0;
+            return 0;            // si le trames sont differentes, on retourne 0
         }
         i=i+1;
         end_comp=type[i];
     }
-return comp;
+return 1;   // retourne 1 si les trames sont les mêmes
 }
 
 //fonction qui retourne l'entier correspondant au caractere mis en argument. (le caractère '1' retourne l'entier 1)
 int decode_int (char c)
 {
-int return_var=0;           // variable de retour
+int return_var=0;          // variable de retour
     if ((c>=48)&&(c<=57))
     {
-        return_var=c-48;
+        return_var=c-48;    //si "c" est un chiffre, on le retourne en tant qu'entier
     }
     else
     {
-        (return_var=-1);
+        (return_var=-1);    // si "c" est autre chose, on retourne -1
     }
 return return_var;
 }
@@ -69,7 +97,7 @@
 int decode_nombre(char * ch,int n)
 {
 int i=0;
-int nbr_return=0;
+int nbr_return=0;       //nombre retourne
     while (i<n)
     {
         nbr_return = nbr_return*10 + decode_int(ch[i]);
@@ -93,7 +121,7 @@
 // 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 (value[i]!='.')
+        while (value[i]!='.')   // on s'arrete au point dans la chaine de caractère qui marque la separation entre partie reelle et decimale
         {
             val_entiere[j]=value[i];
             j++;           // stock la partie entiere
@@ -115,6 +143,7 @@
 // stockage de la valeur sexagesimale
 sexages_value = decode_nombre(val_entiere,val_entiere_taille) + 0.0001* decode_nombre(val_decimal,val_decimale_taille);
 
+//conversion en decimal
 int float_deg=sexages_value/100;
 float float_minutes=0;
 
@@ -160,6 +189,11 @@
 
         p->latitude = sexagesimal_to_float(lat);      // transformation en flottant
 
+        if ((p->latitude>90)||(p->latitude<(-90)))      // verifie validite de la latitude
+        {
+            return 0;
+        }
+
         j=0;     //reinitialise j
         i++;     // une itération de i pour avoir i!=','
 
@@ -187,25 +221,105 @@
 
         p->longitude = sexagesimal_to_float(longit);      // transformation en flottant
 
-return 1;
+        if ((p->longitude>180)||(p->longitude<(-180)))      // verifie validite de la longitude
+        {
+            return 0;
+        }
+
+return 1;   //retour 1 si tout est OK
 }
+
+//fonction revoyant la vitesse du vehicule a partir de sa position
+float calcul_vitesse (Position pos, Position pos_prec)
+{
+float v=0;
+float d=0;        //calcul la distance entre les deux points.
+float x=0;        // calcul intermediare
+float y=0;        // calcul intermediaire
+
+    x=(pos.longitude-pos_prec.longitude)*cos((pos.latitude+pos_prec.latitude)/2);
+    y=pos.latitude-pos_prec.latitude;
+    d= 1.852*60*sqrt(x*x + y*y);
+    v=d*3600;    // passage km/s a km/h (1 seconde d'interval entre 2 trames)
+return v;
+}
+
+//fonction calculant la distance à la plus proche zone et renvoyant le numero de cette zone.
+int distance_a_la_plus_proche_zone (Position p, Zone r[], int nb_zones, float *d)
+{
+int i =0;
+int num_zone=-1;    // numero de la zone la plus proche
+
+    *d=40075.017 ; // perimètre de la terre (distance max) en km
+
+    for (i=0;i<nb_zones;i++)
+    {
+        //verifie si la distance a la zone i est plus petite que celle a la zone i-1
+        if (sqrt((p.latitude - r[i].rpos.latitude)*(p.latitude - r[i].rpos.latitude)+(p.longitude-r[i].rpos.longitude)*(p.longitude-r[i].rpos.longitude))<=*d)
+        {
+            *d=sqrt((p.latitude - r[i].rpos.latitude)*(p.latitude - r[i].rpos.latitude)+(p.longitude-r[i].rpos.longitude)*(p.longitude-r[i].rpos.longitude));
+            num_zone=i;
+        }
+    }
+return num_zone;
+}
+
+
+
+/*
+***************************
+    BLOC TRAITEMENT
+***************************
+*/
+Position p;
+Position p_prec;
 
-//Fonction à modifier !!!!!
+//Fonction traitement
 void traitement(char * trame)
 {
-Position p;
-    static int cpt = 0;
+
+float distance_zone=0;
+int num_zone=-1;
+float vitesse;
+static int cpt = 0;
     cpt++;
+
     if (decode_trame(trame,&p))
     {
         printf ("> %s\n",trame);
 
         printf("latitude en reel : %f\n",p.latitude);
-        printf("longitude en reel : %f\n\n",p.longitude);
-    }
-}
+        printf("longitude en reel : %f\n",p.longitude);
+        num_zone=distance_a_la_plus_proche_zone (p, zones, nbr_zones, &distance_zone);
+        printf ("zone la plus proche : zone numero %d, a %f km.\n",num_zone+1,distance_zone);
+        vitesse = calcul_vitesse (p, p_prec);
+
+        if (calcul_vitesse (p, p_prec)<1000)      // la premiere vitesse est fausse puisqu'on a pas de valeur précedente donc on met ca pour eviter d'afficher des erreurs.
+        {                                         // puisqu'aucune voiture ne va a plus de 1000km/h, cela devrait être suffisant.
+            printf("vitesse entre les positions : %f km/h\n",vitesse);
+        }
+
+        if ((vitesse > zones[num_zone].vitmax)&&(distance_zone<10))
+        {
+            printf("********\nalarm on\n********\n\n");
+        }
+        else
+        {
+            printf("alarm off\n\n");
+        }
+
+
+    }
+    p_prec=p;
 
-//Ajouter vos tests unitaires dans cette fonction.
+}
+
+/*
+**************************
+    TESTS UNITAIRES
+**************************
+*/
+
 void tests_unitaires(void){
 
     if (5!=5){
@@ -312,15 +426,79 @@
     {
         printf ("Erreur Test unitaire sexagesimal_to_float.\n");
         exit(-1);
-    }
+    }
+
+    Position p;
+    Position p_prec;
+
+    if (decode_trame ("$GPGSV,3,2,10,15,03,077,,18,04,041,42,19,85,271,,20,08,214,*7C",&p)!=0)
+    {
+        printf ("Erreur Test unitaire decode_trame 1.\n");
+        exit(-1);
+    }
+    if (decode_trame ("$GPGGA,141914.00,9100.0000,N,00306.6036,E,1,05,3.4,499.3,M,,M,,*7D",&p)!=0)
+    {
+        printf ("Erreur Test unitaire decode_trame 2.\n");
+        exit(-1);
+    }
+    if (decode_trame ("$GPGGA,141914.00,4545.0000,N,18106.6036,E,1,05,3.4,499.3,M,,M,,*7D",&p)!=0)
+    {
+        printf ("Erreur Test unitaire decode_trame 2.\n");
+        exit(-1);
+    }
+
+    p.latitude=45.75;
+    p.longitude=3.11006;
+    p_prec.latitude=45.75;
+    p_prec.longitude=3.11006;        //p = p_prec donc la vitesse devrait être nulle
+    float d=100;
+
+    if (calcul_vitesse (p,p_prec)!=0)
+    {
+        printf ("Erreur Test unitaire calcul_vitesse.\n");
+        exit(-1);
+    }
+
+    p_prec.latitude=45.7504;          //longitude et latitude de la preparation
+    p_prec.longitude=3.110065;
+
+    if ((calcul_vitesse (p,p_prec)<158)||(calcul_vitesse (p,p_prec)>161))       // on a une erreur de calcul de 3 km/h
+    {
+        printf ("Erreur Test unitaire calcul_vitesse.\n");
+        exit(-1);
+    }
+
+    p.latitude=44.9312729;
+    p.longitude=-3.018929;
+
+    if (distance_a_la_plus_proche_zone (p, zones, nbr_zones, &d)!=3)    // la fonction doit renvoyer la zone 4 (case 3 dans le tableau),
+    {                                                                   // qui correspond exactement à la latitude et longitude de p.
+        printf ("Erreur Test unitaire distance_a_la_plus_proche_zone.\n");
+        exit(-1);
+    }
+    if (d!=0)              // p est exactement à la latitude de la zone 4 donc d =0
+    {
+        printf ("Erreur Test unitaire distance_a_la_plus_proche_zone.\n");
+        exit(-1);
+    }
+    //RAZ des structures.
+    p.latitude=0;
+    p.longitude=0;
+    p_prec.latitude=0;
+    p_prec.longitude=0;
 }
-
+
+
+/*
+***************************
+    FONCTION PRINCIPALE
+***************************
+*/
 // 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;
