Index: tag/rc_1/CLEMENT
===================================================================
--- tag/rc_1/CLEMENT	(nonexistent)
+++ tag/rc_1/CLEMENT	(revision 666)
@@ -0,0 +1,361 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <strings.h>
+#include "trame.h"
+#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",
+                    "$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};
+
+typedef struct{             // On Définit la structure position
+        float latitude;
+        float longitude;
+    }position;
+
+typedef struct{             // On Définit la structure zone
+position rpos;
+float vitmax;
+}zone;
+
+ zone zones[] = {               //Pour nos tests ont créer une zone.
+    {{44.7887762, -3.012}, 50}, /* Descripteur de la première zone */
+    {{44.7891220, -3,013}, 70},
+    };
+
+
+int trame_cmp(char* trame,char* type){
+
+    int i=0;    //Initialisation des variables
+    int verif = 1;
+    int j;
+
+     while(type[i] != NULL){ //Calcul de la taille de la chaine type
+        i++;
+    }
+
+    for(j=0; j<i; j++){     //On vérifie que les premiers caractères sont identiques
+        if (trame[j+1] != type[j]){
+            verif = 0;
+        }
+
+
+    }
+
+    return verif;           //On retourne, 1 c'est validé, 0 c'est pas validé.
+}
+
+
+
+
+
+int decode_int(char c){ // Fonction permettant de transformer un code ASCII en décimale
+
+    int res;
+    if (c < 48 || c > 57){ // Si on est pas entre 0 et 9 on retourne -1
+        res = -1;
+    }
+    else {
+        res = c-48; // 48 = code ascii de 0
+    }
+    return res;
+
+}
+
+
+int decode_nombre(char * ch, int n){ //Fonction permettant de décoder un nombre
+
+    int i;                           //Initialisation des variables.
+    int finale;
+    int temp;
+    for(i=0; i<n; i++){
+
+        finale = (pow(10, n-i-1)) * (decode_int(ch[i])) + temp;     //Suivant la place du nombre dans le chiffre on multiplie par une puissance de 10
+        temp = finale;
+    }
+    return finale;
+
+}
+
+
+float conv_lat(char * latitude){        //Fonction permettant de convertir la latitude en float.
+
+    float val = decode_nombre(latitude,4);      //On décode d'abord l'ensemble en float.
+    float res = 0;
+    for (int i = 5; i < 9;i++){                 //On connait les chiffres que l'on veut donc on multiplie par puissance de 10
+        val += (decode_int(latitude[i]))*pow(10,-i+4);
+    }
+    res = (int)(val/100);                       //On convertir le sexa en décimale.
+    res += (val - res*100)/60;
+    return res;}
+
+float conv_long(char * longitude){          //Même principe que la fonction précédente mais avec un chiffre de plus.
+
+    float val = decode_nombre(longitude,5);
+    float res = 0;
+    for (int i = 6; i < 10;i++){
+        val += (decode_int(longitude[i]))*pow(10,-i+5);
+    }
+    res = (int)(val/100);
+    res += (val - res*100)/60;
+    return res;}
+
+float conversion(char * chaine){            //On regroupe les deux fonctions précédentes en une seule.
+
+    int cpt = 0;
+    while (chaine[cpt]!='\0'){
+        cpt++;
+    }
+    if (cpt == 9){
+        return conv_lat(chaine);
+    }
+    else if(cpt==10){
+        return conv_long(chaine);
+    }
+    else{
+        return 1000.0;                      //On créer un code d'erreur au cas ou
+    }
+}
+
+position decode_trame(char * trame){        //On va décoder 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 définit notre structure
+
+    position position_trame;                //Initialisation.
+    char latitude[10];
+    char longitude[11];
+    int n = 0;
+    int i = 0;
+    int j = 0;
+    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;
+}
+
+//Fonction à modifier !!!!!
+void traitement(char * trame) // C'est ici qu'on gère tout l'affichage.
+{
+    position affichage;       //On initialise ce dont on aura besoin.
+    static int cpt=0 ;
+    int i;
+    float vitesse;
+    position temp_trame;
+
+    if ((trame_cmp(trame, "GPGGA")) == 1){ //On vérifie qu'on est bien dans une trame valide.
+
+
+        temp_trame.longitude = affichage.longitude;     //On retient la trame précédente pour le calcul de la vitesse.
+        temp_trame.latitude = affichage.latitude;
+
+
+        printf("> %s\n",trame);         //On affiche la trame et on la décode.
+        affichage = decode_trame(trame);
+        printf("Latitude : %f \nLongitude %f\n\n", affichage.latitude, affichage.longitude);
+
+        i = distance_a_la_plus_proche_zone(affichage, zones, 2, d); //On calcule la distance jusqu'à la prochaine zone
+        vitesse = calcule_vitesse(temp_trame, affichage);           //La vitesse du véhicule
+        if (vitesse < 10000){                                       //Si le résultat est aberrant c'est que la trame précédente ne suivait pas.
+        printf("Vous roulez a une vitesse de %f km/h et vous etes proches d'une zone a %f km/h.", vitesse, zones[i-1].vitmax); //On affiche les informations.
+        if (vitesse > zones[i-1].vitmax){
+            printf("\n\nAlarme : On\n\n");
+        }
+        else{
+            printf("\n\nAlarme : Off\n\n");
+        }
+        }
+        else{
+            printf("Nous ne sommes pas encore en mesure de vous donner la vitesse.\n\n"); // Au cas ou la vitesse est aberrante.
+        }
+    }
+    cpt++ ;
+
+
+}
+
+
+//Ajouter vos tests unitaires dans cette fonction.
+void tests_unitaires(void){
+    if (5!=5){
+        printf ("Erreur Test unitaire basique.\n");
+        exit(-1);
+    }
+    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");
+        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(decode_int('2') != 2){
+        printf ("Erreur Test unitaire decode_int.\n");
+        exit(-1);
+    }
+    if(decode_nombre("9876", 2) != 98){
+        printf ("Erreur Test unitaire decode_nombre.\n");
+        exit(-1);
+    }
+
+      if ((conv_lat("3723.2475")-37.387458)>= pow(10,-6)){  // On s'arrange pour avoir le même arrondis que code blocks.
+        printf ("Erreur Test unitaire conv_lat.\n");
+        exit(-1);
+    }
+    if ((conversion("00306.6036")-3.11006)>= pow(10,-6)){   // On s'arrange pour avoir le même arrondis que code blocks.
+        printf ("Erreur Test unitaire conversion.\n");
+        exit(-1);
+    }
+    if ((conversion("3723.2475")-37.387458) >= pow(10,-6)){  // On s'arrange pour avoir le même arrondis que code blocks.
+        printf ("Erreur Test unitaire conversion.\n");
+        exit(-1);
+    }
+
+    // On va passer au test unitaire de notre fonction decode_tram :
+    char test1[] = "$GPGGA,141914.00,4545.0000,N,00306.6036,E,1,05,3.4,499.3,M,,M,,*7D";
+    char test2[] = "$GPGGA,141915.00,4545.0242,N,00306.6039,E,1,05,3.4,499.5,M,,M,,*72";
+    position test1_1;
+    position test2_1;
+    float dtest;
+    test1_1 = decode_trame(test1);
+    test2_1 = decode_trame(test2);
+
+
+    if (((test1_1.latitude - 45.75) >= pow(10,-6)) && (test1_1.longitude - 003.11006) >= pow(10,-6)){
+        printf("Erreur Test unitaire decode_tram1.\n");
+        exit(-1);
+    }
+
+     if (((test2_1.latitude - 45.750401) >= pow(10,-6)) && ((test2_1.longitude - 003.110065) >= pow(10,-6))){
+        printf("Erreur Test unitaire decode_tram2.\n");
+         exit(-1);
+    }
+
+    if ((calcule_distance(test1_1, test2_1) - 0.044508) >= pow(10,-6)){
+        printf("Erreur test unitaire distance.\n");
+         exit(-1);
+    }
+
+    if ((calcule_vitesse(test1_1, test2_1) - 160.2304) >= pow(10,-4)){
+        printf("Erreur test unitaire calcul_vitesse\n");
+         exit(-1);
+    }
+
+    //On définit la zone pour faire un test unitaire
+
+    distance_a_la_plus_proche_zone(test1_1, zones, 2, d);
+
+    if ((*d - 217.8 >= pow(10,-1))){
+        printf("Erreur test unitaire distance_a_la_plus_proche_zone\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;
+}
