Projet

Général

Profil

Télécharger (5,91 ko) Statistiques
| Révision:

root/branch/NOYAU/sp4a12/main.c @ 411

1 jalaffon
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
119 annoyau
#include "trame.h"
#include <math.h>
1 jalaffon
//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",
119 annoyau
0};
// Fonction trame_cmp
103 annoyau
int trame_cmp (char * trame, char * type) {
3 jalaffon
103 annoyau
int i=0;
int verif = 0;
int j;

while (type[i] != '\0') {
i++;
}


for (j=0;j<i;j++){
if (trame[j+1] != type[j]){
verif = 0;
j=i;
}
else {
verif = 1;

}
}
return verif;
}
119 annoyau
// Fonction decode_int
int decode_int(char c)
{
int res;
if (c >= 48 && c<=57) {
res = c-48;
}
else {
res = -1;
}
return res;
}
// Fonction decode_nombre
411 annoyau
int decode_nombre (char * trame) {
256 annoyau
int i=0;
269 annoyau
int j=0,memoire=0;
411 annoyau
int res3=0;
256 annoyau
char tab[9];
411 annoyau
int res4=0;
256 annoyau
while (i<10)
{
if (decode_int(trame[i])!=(-1))
{
tab [j]=decode_int(trame[i]);
res3 = res3*10+tab[j];
269 annoyau
memoire++;
256 annoyau
}
i++;
j++;
}
269 annoyau
switch(trame[memoire+2])
{
case 'S' :
res3 = res3*(-1);
break;
case 'W' :
res3 = res3*(-1);
break;
256 annoyau
}


269 annoyau
return res3;
256 annoyau
129 annoyau
}
411 annoyau
int Conversion_sexagesimale(int nb_sexa)
129 annoyau
{
411 annoyau
int result=0, result_min=0;
129 annoyau
int degres=0;
411 annoyau
int result_vf=0;
119 annoyau
411 annoyau
298 annoyau
degres=nb_sexa/1000000;
result_min=(nb_sexa-(degres*1000000));
129 annoyau
411 annoyau
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_vf = (degres*600000)+(result_min*10000);


// printf("%ld\n",result_vf);

return result_vf;
129 annoyau
}


1 jalaffon
//Fonction ? modifier !!!!!
void traitement(char * trame)
94 annoyau
{
static int cpt=0 ;
411 annoyau
103 annoyau
cpt++ ;
411 annoyau
int i,j;
char tab_lat[11];
char tab_lon[12];
long resultat_l;
long resultat_L;
long conversion_L;
long conversion_l;
103 annoyau
if (trame_cmp(trame,"GPGGA")==1) {
411 annoyau
printf ("> %s\n",trame);
decode_trame(&tab_lat,&tab_lon,trame);
resultat_L = decode_nombre(&tab_lat);
resultat_l = decode_nombre(&tab_lon);
/* printf("Latitude %ld\n",resultat_L);
printf("Longitude : %ld\n",resultat_l); */
conversion_L = Conversion_sexagesimale(resultat_L);
conversion_l = Conversion_sexagesimale(resultat_l);
printf("Latitude %ld\n",conversion_L);
printf("Longitude : %ld\n",conversion_l);

}

103 annoyau
1 jalaffon
411 annoyau
}
void decode_trame(char * tab_lat, char * tab_lon, char *trame)
{
int i=17,j=29;
for (i=17;i<27;i++)
{
tab_lat[i-17] = trame[i];
}
for (j=29;j<40;j++)
{
tab_lon[j-29] = trame[j];
}


}


1 jalaffon
//Ajouter vos tests unitaires dans cette fonction.
void tests_unitaires(void){
if (5!=5){
printf ("Erreur Test unitaire basique.\n");
exit(-1);
}
103 annoyau
if (trame_cmp("$GPGGA suite chaine","GPGGA")!=1){
1 jalaffon
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);
119 annoyau
}
test_decode_int();
298 annoyau
test_decode_nombre();

119 annoyau
}
void test_decode_int(void) {
/* char i;
for (i=0;i>127;i++)
{
if (decode_int(i)==(-1))
{
printf("La conversion est pas bonne \n");
exit (-1);
}
}
if (decode_int('A')!=(-1)) {
printf("La conversion c'est mal pass? \n");
exit (-1);
}
if (decode_int('0')==(-1)) {
printf("La conversion c'est mal pass? \n");
exit (-1);
}
*/
}
void test_decode_nombre (void) {
411 annoyau
long resultat = decode_nombre("14343.0000,W");
256 annoyau
printf("Le resultat est : %d\n",resultat);
411 annoyau
unsigned long int resultat2 = Conversion_sexagesimale(resultat);
//printf("Le resultat de la conversion est : %ld\n",resultat2);
129 annoyau
}
411 annoyau
/*void test_matrice_valperso (void) {
129 annoyau
299 annoyau
/* D?claration */
298 annoyau
299 annoyau
// Matrice A de test : //
411 annoyau
/*double A[2][2]={{15,20},{9,99}};
299 annoyau
double B[2][2]={{21,36},{13,4}};

// Matrice contenant le resultat : //
double R[2][2];

// Resultat attendu pour A+B //
double R1[2][2]={{36,56},{22,103}};

// Resultat attendu pour A.B //
double R2[2][2]={{575,620},{1476,720}};

// Resultat attendu pour A-B //
double R3[2][2]={{-6,-16},{-4,95}};

// Resultat attendu pour A' //
double R4[2][2]={{15,9},{20,99}};

// Resultat attendu pour A^-1 //
411 annoyau
double R5[2][2]={{(11/145),(-4/261)},{(-1/145),(1/87}}; */
299 annoyau
/* Op?rations : */








411 annoyau
//}
1 jalaffon
// Ne pas modifier cette fonction
int main(int argc,char ** argv)
{

119 annoyau
tests_unitaires();
1 jalaffon
119 annoyau
1 jalaffon
// 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;
}