Projet

Général

Profil

« Précédent | Suivant » 

Révision 211

Ajouté par mamorales il y a presque 4 ans

implémentation de toutes les fonction du bloc traitement et de leurs test unitaires, code presque terminé.

Voir les différences:

main.c
#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",
......
"$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 {
......
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;
}
......
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]);
......
// 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
......
// 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;
......
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!=','
......
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){
......
{
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;

Formats disponibles : Unified diff