Projet

Général

Profil

Télécharger (15,4 ko) Statistiques
| Révision:

root/branch/Morales/sp4a12/main.c @ 817

1 jalaffon
#include <stdio.h>
#include <stdlib.h>
211 mamorales
#include <strings.h>
#include <math.h>
1 jalaffon
#include "trame.h"
211 mamorales
/*
****************************
DONNEES CONSTANTES
****************************
*/
//Trames de tests
1 jalaffon
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",
211 mamorales
0};
3 jalaffon
198 mamorales
// structure pour la longitude et la latitude.
typedef struct {
float latitude;
float longitude;
} Position ;

211 mamorales
//structure des zones dangereuses
typedef struct {
Position rpos;
float vitmax;
} Zone ;

232 mamorales
// zones dangereuses
211 mamorales
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 */
232 mamorales
{{45.7531, 3.11001}, 30}, /* Descripteur de la 5eme zone */
{{45.3004, 3.00154635}, 20}, /* Descripteur de la 6eme zone */
{{45.7503, 3.11}, 30}, /* Descripteur de la 7eme zone */
{{45.2433, 3.085264}, 160}, /* Descripteur de la 8eme zone */
{{45.7502, 3}, 140}, /* Descripteur de la 9eme zone */
{{45.1248, 3.00094635},80}, /* Descripteur de la 10eme zone */
{{45.75350, 3.11}, 90}, /* Descripteur de la 11eme zone */
211 mamorales
};
232 mamorales
#define nbr_zones 11 // definit le nombre total de zones dangereuses.
211 mamorales
198 mamorales
// 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);
int decode_trame (char*trame, Position *p);
211 mamorales
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);
198 mamorales
211 mamorales
/*
*****************************
FONCTIONS DE CALCUL
*****************************
*/
48 mamorales
//fonction comparant les trames
int trame_cmp(char* trame,char* type)
{
211 mamorales
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
48 mamorales
{
if (trame[i]!=type[i-1])
{
211 mamorales
return 0; // si le trames sont differentes, on retourne 0
48 mamorales
}
i=i+1;
end_comp=type[i];
}
211 mamorales
return 1; // retourne 1 si les trames sont les m?mes
3 jalaffon
}
57 mamorales
63 mamorales
//fonction qui retourne l'entier correspondant au caractere mis en argument. (le caract?re '1' retourne l'entier 1)
int decode_int (char c)
{
211 mamorales
int return_var=0; // variable de retour
63 mamorales
if ((c>=48)&&(c<=57))
{
211 mamorales
return_var=c-48; //si "c" est un chiffre, on le retourne en tant qu'entier
63 mamorales
}
else
{
211 mamorales
(return_var=-1); // si "c" est autre chose, on retourne -1
63 mamorales
}
80 mamorales
return return_var;
63 mamorales
}

80 mamorales
//fonction retournant uniquement les n premier chiffres dans un nombre.
int decode_nombre(char * ch,int n)
{
int i=0;
211 mamorales
int nbr_return=0; //nombre retourne
80 mamorales
while (i<n)
{
nbr_return = nbr_return*10 + decode_int(ch[i]);
i=i+1;
}
return nbr_return;
}
63 mamorales
197 mamorales
//fonction covertissant des sexagesimal (latitude ou longitude) en reel
198 mamorales
float sexagesimal_to_float(char* value)
80 mamorales
{
int i=0;
int j=0;
198 mamorales
int val_entiere_taille = 0; // taille de la partie entiere de la valeur
int val_decimale_taille = 0; // taille de la partie decimal de la valeur
char val_entiere[10]={0}; //valeur entiere de la longitude, on reserve 6 cases par s?curite.
char val_decimal[10]={0}; //valeur decimale de la longitude, on reserve 6 cases par s?curite.
float sexages_value=0;
float float_val=0;
80 mamorales
198 mamorales
// 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
197 mamorales
211 mamorales
while (value[i]!='.') // on s'arrete au point dans la chaine de caract?re qui marque la separation entre partie reelle et decimale
80 mamorales
{
198 mamorales
val_entiere[j]=value[i];
197 mamorales
j++; // stock la partie entiere
80 mamorales
i++;
}
197 mamorales
val_entiere_taille = j;
198 mamorales
j=0; //reinitialise j
i++; // on ne stock pas le point dans les 2 chaines

while (value[i]!='\0')
80 mamorales
{
198 mamorales
val_decimal[j]=value[i]; // stock la partie decimale
197 mamorales
j++;
80 mamorales
i++;
}
197 mamorales
val_decimale_taille = j;
80 mamorales
198 mamorales
// stockage de la valeur sexagesimale
sexages_value = decode_nombre(val_entiere,val_entiere_taille) + 0.0001* decode_nombre(val_decimal,val_decimale_taille);
197 mamorales
211 mamorales
//conversion en decimal
198 mamorales
int float_deg=sexages_value/100;
float float_minutes=0;
197 mamorales
198 mamorales
float_minutes = (sexages_value-float_deg*100)/60;
float_val = float_deg + float_minutes;
197 mamorales
198 mamorales
return float_val;
80 mamorales
}

198 mamorales
//fonction convertissant la latitude et longitude en reels.
int decode_trame(char* trame,Position *p)
80 mamorales
{
int i=0;
int j=0;
int nbr_virgule=0;
198 mamorales
char lat[15]={0};
char longit[15]={0};
if (trame_cmp(trame,"GPGGA")==0)
{
return 0;
}
//calcul latitude
while (nbr_virgule<3) // on compte jusqu'a la troisieme virgule
{
while (nbr_virgule<2) // on compte jusqu'a la deuxieme virugle (troisieme champs)
{
if (trame[i]==',')
{
nbr_virgule = nbr_virgule+1;
}
i++;
}
80 mamorales
198 mamorales
lat[j]=trame[i];
j++;
i++;
80 mamorales
if (trame[i]==',')
{
nbr_virgule = nbr_virgule+1;
}
198 mamorales
80 mamorales
}
197 mamorales
198 mamorales
p->latitude = sexagesimal_to_float(lat); // transformation en flottant

211 mamorales
if ((p->latitude>90)||(p->latitude<(-90))) // verifie validite de la latitude
{
return 0;
}

198 mamorales
j=0; //reinitialise j
i++; // une it?ration de i pour avoir i!=','

// calcul longitude
while (nbr_virgule<5) // on compte jusqu'a la troisieme virgule
80 mamorales
{
198 mamorales
while (nbr_virgule<4) // on compte jusqu'a la deuxieme virugle (cinquieme champs)
{
if (trame[i]==',')
{
nbr_virgule = nbr_virgule+1;
}
i++;
}

longit[j]=trame[i];
197 mamorales
j++;
80 mamorales
i++;
198 mamorales
if (trame[i]==',')
{
nbr_virgule = nbr_virgule+1;
}

80 mamorales
}

198 mamorales
p->longitude = sexagesimal_to_float(longit); // transformation en flottant
80 mamorales
211 mamorales
if ((p->longitude>180)||(p->longitude<(-180))) // verifie validite de la longitude
{
return 0;
}

return 1; //retour 1 si tout est OK
80 mamorales
}
211 mamorales
//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
***************************
*/
232 mamorales
Position p; // position au temps t
Position p_prec; // position ? t-1 (1 seconde avant t)
1 jalaffon
211 mamorales
//Fonction traitement
1 jalaffon
void traitement(char * trame)
46 mamorales
{
211 mamorales
float distance_zone=0;
int num_zone=-1;
232 mamorales
float vitesse=0;
211 mamorales
static int cpt = 0;
57 mamorales
cpt++;
211 mamorales
198 mamorales
if (decode_trame(trame,&p))
57 mamorales
{
printf ("> %s\n",trame);
198 mamorales
printf("latitude en reel : %f\n",p.latitude);
211 mamorales
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);

232 mamorales
if ((vitesse > zones[num_zone].vitmax)&&(distance_zone<10))
{
printf("********\nalarm on\n********\n\n");
}
else
{
printf("alarm off\n\n");
}
211 mamorales
}


}
p_prec=p;
1 jalaffon
211 mamorales
}

/*
**************************
TESTS UNITAIRES
**************************
*/

48 mamorales
void tests_unitaires(void){

if (5!=5){
1 jalaffon
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");
63 mamorales
exit(-1);
}
80 mamorales
if (decode_int('0')!=0)
63 mamorales
{
printf ("Erreur Test unitaire decode_int.\n");
exit(-1);
80 mamorales
}
if (decode_int('1')!=1)
{
printf ("Erreur Test unitaire decode_int.\n");
exit(-1);
}
if (decode_int('2')!=2)
{
printf ("Erreur Test unitaire decode_int.\n");
exit(-1);
}
if (decode_int('3')!=3)
{
printf ("Erreur Test unitaire decode_int.\n");
exit(-1);
}
if (decode_int('4')!=4)
{
printf ("Erreur Test unitaire decode_int.\n");
exit(-1);
}
if (decode_int('5')!=5)
{
printf ("Erreur Test unitaire decode_int.\n");
exit(-1);
}
if (decode_int('6')!=6)
{
printf ("Erreur Test unitaire decode_int.\n");
exit(-1);
}
if (decode_int('7')!=7)
{
printf ("Erreur Test unitaire decode_int.\n");
exit(-1);
}
if (decode_int('8')!=8)
{
printf ("Erreur Test unitaire decode_int.\n");
exit(-1);
}
if (decode_int('9')!=9)
{
printf ("Erreur Test unitaire decode_int.\n");
exit(-1);
}
if (decode_int('A')!=-1)
{
printf ("Erreur Test unitaire decode_int.\n");
exit(-1);
}
if (decode_nombre("7541",2)!=75)
{
printf ("Erreur Test unitaire decode_nombre.\n");
exit(-1);
}
if (decode_nombre("7541",3)!=754)
{
printf ("Erreur Test unitaire decode_nombre.\n");
exit(-1);
}
if (decode_nombre("123",3)!=123)
{
printf ("Erreur Test unitaire decode_nombre.\n");
exit(-1);
}
if (decode_nombre("987654321",2)!=98)
{
printf ("Erreur Test unitaire decode_nombre.\n");
exit(-1);
48 mamorales
}
198 mamorales
if ((sexagesimal_to_float ("3723.2475")<=37.387458)||(sexagesimal_to_float ("3723.2475")>=37.387459))
80 mamorales
{
printf ("Erreur Test unitaire sexagesimal_to_float.\n");
exit(-1);
198 mamorales
}
if ((sexagesimal_to_float ("00306.6036")<=3.11006)||(sexagesimal_to_float ("00306.6036")>=3.11007))
{
printf ("Erreur Test unitaire sexagesimal_to_float.\n");
exit(-1);
211 mamorales
}

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;
1 jalaffon
}
211 mamorales

/*
***************************
FONCTION PRINCIPALE
***************************
*/
1 jalaffon
// 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;
}