Index: branch/CLAUD/sp4a12/main.c
===================================================================
--- branch/CLAUD/sp4a12/main.c	(revision 669)
+++ branch/CLAUD/sp4a12/main.c	(revision 670)
@@ -128,6 +128,7 @@
     }
 }
 
+
 // Fonction decode_nombre
 int decode_nombre (char * ch, int n)
 {
@@ -139,6 +140,37 @@
     return res;
 }
 
+
+/* Fonction decode_nombre en virgule fixe
+ int decode_nombre (char * trame) {
+    int i=0;
+    int j=0,memoire=0;
+    int res3=0;
+    char tab[9];
+    int res4=0;
+    while (i<10)
+    {
+        if (decode_int(trame[i])!=(-1))
+        {
+            tab [j]=decode_int(trame[i]);
+            res3 = res3*10+tab[j];
+            memoire++;
+        }
+        i++;
+        j++;
+    }
+    switch(trame[memoire+2])
+    {
+    case 'S' :
+        res3 = res3*(-1);
+        break;
+    case 'W' :
+        res3 = res3*(-1);
+        break;
+    }
+    return res3;
+*/
+
 // Fonction de tests unitaire
 void test_decode_nombre(void)
 {
@@ -223,6 +255,32 @@
     }
 }
 
+
+// Fonction a revoir
+int Conversion_sexagesimale(int nb_sexa)
+{
+    int degres=0,result_min=0;
+    int temp=0;
+    int result=0;
+
+    temp = nb_sexa;
+
+    degres=temp/1000000;
+    result_min=(temp-(degres*1000000));
+    result=(degres+(result_min/60));
+
+    /* 1/10000 de minute => K = 1.666*10^-6 pour passer en degr?s
+     K_rad = 1.666*10^-6 * Pi/180
+                       */
+    result = (degres*600000)+(result_min);
+
+   // printf("%ld\n",result);
+    return result;
+}
+
+
+
+
 // ----------------------------------------------------------------------------------------------
 //                                      Fin Séance 1a
 //                                      Début séance 2a
@@ -229,22 +287,90 @@
 // ----------------------------------------------------------------------------------------------
 
 
-typedef struct {
+typedef struct {        // Structure Position
     float latitude;
     float longitude;
 } Position;
 
-int decode_trame(char * trame, Position *p){
-    char longitude_trame[10];
-    char latitude_trame[9];
-    int compteur = 0;
+typedef struct {       // Structure Zone
+        Position rpos;
+        float vitmax;
+} Zone;
+
+ Zone zones[] = {                   //Pour nos tests on cree une zone.
+    {{44.7887762, -3.012}, 50},     // Description de la premiere zone
+    {{44.7891220, -3,013}, 70},
+    };
+
+Position decode_trame(char * trame){        //On va decoder la trame et l'afficher
+    if (trame_cmp(trame, "GPGGA")!= 1){     //On regarde si on est au bon format.
+        printf("Cette trame n'est pas au bon format.");
+    }
+    else{                                   //Si c'est le cas on continue
+    //On definit notre structure
+    Position position_trame;                //Initialisation.
+    char latitude[10];
+    char longitude[11];
+    int n = 0;
     int i = 0;
     int j = 0;
-    int y = 0;
-    if (trame_cmp(trame, "GPGGA") == 1)
-    {
+    int k = 0;
+        while (trame[i] != '\0'){           //On veut r?cup?rer les diff?rentes informations suivant le mod?le pr?cis de trame.
+            if (trame[i] == ','){ //On rep?re les virgules
+                n = n + 1;
+                i = i + 1;
+            }
+            if (n == 2) { //Apr?s virgule 2 on a la latitude
+                latitude[j] = trame[i]; //On r?cup?re la latitude
+                j = j + 1;
+            }
+            if (n == 4) { //Apr?s virgule 4 on a la longitude
+                longitude[k] = trame[i]; //On stocke caract?re par caract?re pour isoler la longitude afin de la convertir.
+                k = k + 1;
+            }
+            i ++;
+        }
+        latitude[j] = '\0';     //On ferme bien la chaine
+        longitude[k] = '\0';
+        position_trame.latitude = conversion(latitude);
+        position_trame.longitude = conversion(longitude); //On stocke la latitude et la longitude convertie dans structure position.
+        return position_trame;
+    }
+}
+float calcule_distance(Position position_trame1, Position position_trame2){
+    //On utilise la formule en connaissant le rayon de la terre.
+    float x = (position_trame2.longitude - position_trame1.longitude) * cos( (position_trame1.latitude + position_trame2.latitude) / 2);
+    float y = position_trame2.latitude - position_trame1.latitude;
+    float z = sqrt(x*x + y*y);
+    float k = 1.852 * 60;
+    float d = k * z;
+    return d;
+}
+float calcule_vitesse(Position position_trame1, Position position_trame2){
+    // On doit calculer la distance :
+    float d;
+    d = calcule_distance(position_trame1, position_trame2);
+    //On a la distance, on calcule la vitesse;
+    float v = d * 3600;
+    return v;
+}
 
+float p;        //On initialise notre pointeur de distance.
+float * d = &p;
+
+int distance_a_la_plus_proche_zone(Position p, Zone r[], int nb_zones, float *d){
+    int i = 1;
+    *d = calcule_distance(p, r[0].rpos); //On initialise par d?faut que la premi?re zone est la plus proche
+    float temp_d;
+    while (i < nb_zones){                //On compare si elle est plus proche que celle d'avant, si oui on remplace.
+        temp_d = calcule_distance(p, r[i].rpos);
+        if (temp_d < *d){
+            *d = temp_d;
+        }
+        i++;
     }
+    return i;
+}
 
 }
 
@@ -272,65 +398,3 @@
 }
 
 
-/* Code Anthony (à regarder !)
-float decode_nombre (char * trame) {
-    int i=0;
-    int j=0,memoire=0;
-    long res3=0;
-    char tab[9];
-    long res4=0;
-    while (i<10)
-    {
-        if (decode_int(trame[i])!=(-1))
-        {
-            tab [j]=decode_int(trame[i]);
-            res3 = res310+tab[j];
-            memoire++;
-        }
-        i++;
-        j++;
-    }
-   / while (i<12)
-    {
-        if (decode_int(trame[i]=='S'))
-        {
-
-            res4 = res3 - (2*res3);
-            printf("%d\n",res4);
-        }
-        else
-        {
-            res4 = res3;
-        }
-        i++;
-    } /
-
-    switch(trame[memoire+2])
-    {
-    case 'S' :
-        res3 = res3(-1);
-        break;
-    case 'W' :
-        res3 = res3(-1);
-        break;
-    }
-
-
-
-    return res3;
-
- }
- float Conversion_sexagesimale(long nb_sexa)
-{
-    float result=0, result_min=0;
-    int degres=0;
-
-    degres=nb_sexa/1000000;
-    result_min=(nb_sexa-(degres1000000));
-    result_min=(reste/10000);
-    result=(degres+(reste/60));
-
-    return result;
-}
-
-*/
