Projet en C (information traffic bus)

Version imprimable

Bonjour voila mon probleme j'ai un projet à rendre à la fin de l'année. Dans ce projet je m'occupe de la partie message.
Je reçois la trame d'un GPS je la découpe, je sauvegarde et traite les mots pour dire si le bus est station, si il est parti ou si il arrive.
J'ai la fonction qui decoupe et sauvegarde mes je vois pas comment faire la comparaison

Voici ce que j'ai deja fait :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
 
 
 
char **DecoupeMots (char *chaine_entrante, const char *separateur)
{
   char **tab = NULL; //On crée un tableau principal et un sous-jaccent
 
   if (chaine_entrante != NULL && separateur != NULL)
   {
      int i;
      char *chaine_sortante = NULL;
      size_t size = 1;
 
/* (1) */
      for (i = 0; (chaine_sortante = strtok (chaine_entrante, separateur)); i++)
      {
         if (size <= i + 1)
         {
            char *tmp = NULL;
 
/* (2) */
            size <= 1;
            tmp = realloc (tab, sizeof (*tab) * size);
            if (tmp != NULL)
            {
               tab = tmp;
            }/* le tableau principal (tab) possede deux tableaux sous-jaccent */
            else
            {
               fprintf (stderr, "Memoire insuffisante\n");
               free (tab);
               tab = NULL;
               exit (EXIT_FAILURE);
            }
         }
/* (3) */
         tab[i] = chaine_sortante;
         printf("%s\n",tab[i]);
         chaine_entrante = NULL;
      }
      tab[i] = NULL;
 
   }
   return tab;
}
 
 
/*******************************************************************************/
char *TraiteMots (char *pointeur,char *Mots)
{
	if (pointeur == Mots)
	{
		printf("\n Bus en station !!!");
	}
	else
	{
		printf("\nVotre BUS n'est pas encore arrive !!\n");
	}
	return 0;
}
 
 
 
 
/*******************************************************************************/
 
 
int main ()
{
	char *buffer;
	char Chaine_Entrante[]="Il etait une fois dans la ville de foix une marchande de foie";
	char Mots[]="Il etait une fois dans la ville de foix une marchande de foie";
 
	buffer = strdup( Chaine_Entrante );
 
 
		while(1)
	{
 
		if (buffer != NULL)
 
		{
	char **pointeur;
	char separateur[] = " ";
	char **CompareMots;
 
	printf("%s\n",buffer);
 
	pointeur=DecoupeMots (buffer,separateur);
 
	printf("\n%s \n",pointeur[2]); //verifie les données sauvegardé
 
	TraiteMots (pointeur,Mots);
 
 
		}
 
 getchar (); // Pause dans en mode console
 
	}
 
	return 0 ;
}

23/05/2013, 06h57
Metalman

Créer un parser avec des strcmp/strncmp ? et découper avec des strncpy/strndup ?
23/05/2013, 09h37
Bktero
Bonjour,

+1 Metalman : des chaines de caractères ne se comparent pas avec == mais avec strcmp() !

Quelques remarques :
- L19 : sais-tu que strtok() modifie son paramètre ? Es-tu sûr que ce n'est pas un problème dans ton code ?
- L27 : realloc() ? Je n'ai pas vu de malloc()...
- L27 : pour allouer dynamiquement un tableau 2D : http://c.developpez.com/faq/?page=al...LOC_tableau_2D
- L34 : pour afficher la cause réelle d'une erreur, tu peux utiliser errno, perror(), strerror().
23/05/2013, 11h57
Originaldev

OK merci donc je prends en considération vos arguments et je vous fait signe après.

Merci mes strncpy/strndup je suis obliger de compter pour séparer alors que strtok sépare par rapport au séparateur

Pour strcmp me permet de comparer mes quand je change la 2nde phrase il ne m'affiche pas la condition else

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
 
char **DecoupeMots (char *chaine_entrante, const char *separateur)
{
   char **tab = NULL; //On crée un tableau principal et un sous-jaccent
 
   if (chaine_entrante != NULL && separateur != NULL)
   {
      int i;
      char *chaine_sortante = NULL;
      size_t size = 1;
 
/* (1) */
      for (i = 0; (chaine_sortante = strtok (chaine_entrante, separateur)); i++)
      {
         if (size <= i + 1)
         {
            char *tmp = NULL;
 
/* (2) */
            size <= 1;
            tmp = realloc (tab, sizeof (*tab) * size);
            if (tmp != NULL)
            {
               tab = tmp;
            }/* le tableau principal (tab) possede deux tableaux sous-jaccent */
            else
            {
            	fprintf (stderr, "Memoire insuffisante\n");
               free (tab);
               tab = NULL;
               exit (EXIT_FAILURE);
            }
         }
/* (3) */
         tab[i] = chaine_sortante;
         printf("%s\n",tab[i]);
         chaine_entrante = NULL;
      }
      tab[i] = NULL;
 
   }
   return tab;
}
 
 
 
/*******************************************************************************/
char *TraiteMots (char *pointeur,char *Mots)
{
	if (strcmp (pointeur,Mots))
	{
		printf("\n Bus en station !!!");
	}
	else
	{
		printf("\nVotre BUS n'est pas encore arrive !!\n");
	}
	return 0;
}
 
 
 
 
/*******************************************************************************/
 
 
int main ()
{
	char *buffer;
	char Chaine_Entrante[]="Il etait une fois dans la ville de foix une marchande de foie";
	char Mots[]="Il etait une fois dans la ville de foix une marchande de foie";
 
	buffer = strdup( Chaine_Entrante );
 
 
		while(1)
	{
 
		if (buffer != NULL)
 
		{
	char **pointeur;
	char separateur[] = " ";
	char **CompareMots;
 
	printf("%s\n",buffer);
 
	pointeur=DecoupeMots (buffer,separateur);
 
	printf("\n%s \n",pointeur[2]); //verifie les données sauvegardé
 
	TraiteMots (pointeur,Mots);
 
 
 
		}
 
 getchar (); // Pause dans en mode console
 
	}
 
	return 0 ;
}

j'ai pas encore changé la partie qui traite du tableau dynamique.

24/05/2013, 06h41
Metalman

C'est au niveau du : tab[i] = chaine_sortante; que tu devrais faire un : tab[i] = strdup(chaine_sortante); à chaque tour de boucle.

Ainsi, tu ne dépendra plus de la phrase initiale qui est allouée dans un seul malloc, mais chaque mot sera dans sa propre case.

Bonjour,

reprenons ton code (as-tu fait attention aux warnings émis par ton compilateur ? essaye de toujours compiler avec un niveau élévé de warning, ce qui avec gcc se traduit par l'utilisation des options -Wall -Wextra).
Code:

1 2 3 4 5 6 7 8 9 10 11 char **DecoupeMots (char *chaine_entrante, const char *separateur) { char **tab = NULL; //On crée un tableau principal et un sous-jaccent if (chaine_entrante != NULL && separateur != NULL) { int i; char *chaine_sortante = NULL; size_t size = 1; /* (1) */ for (i = 0; (chaine_sortante = strtok (chaine_entrante, separateur)); i++) {
strtok peut être une fonction difficile à manipuler. Une alternative serait d'utiliser strtok_r, voire une combinaison de strspn/strncpy. Le net fourmille de doc sur le sujet.
Code:

1 2 if (size <= i + 1) {
Ici il y a une erreur. size vaut 1 et n'est jamais modifié par la suite, i est toujours plus grand que 0 donc cette condition s'évalue toujours à vrai : elle est inutile.
Je dis que c'est une erreur car je suppose que tu veux dynamiquement augmenter le taille de tab au fur et à mesure des mots trouvés, mais là tu t'y prends mal.
Code:

1 2 3 4 char *tmp = NULL; /* (2) */ size <= 1;
Je ne sais pas ce que tu as voulu faire ici. C'est une expression valide mais à quoi sert-elle ?
Code:

1 2 tmp = realloc (tab, sizeof (*tab) * size);
OK, un realloc avec un pointeur NULL agit exactement comme un malloc. Mais ici il y a deux problèmes :

tu réalloues toujours la même taille puisque size ne change jamais et vaut toujours 1. Je suppose que tu voulais utiliser une expression avec i comme i contient le tour, i+1 est le nombre de mots et i+2 serait la bonne valeur pour pouvoir rajouter un NULL terminal, enfin je suppose, c'est à vue de nez.
tu confonds certains types. tab est de type char** alors que tmp est de type char*. Comme tu n'utilises que la valeur des pointeurs et que tu ne les déréférences pas cela ne pose pas trop de problèmes au compilateur, mais cela en pose plus à mon oeil :)
Code:

1 2 3 if (tmp != NULL) { tab = tmp;
Ici en revanche le compilateur se pose des questions et émet un warning à cause des différences de type.
Code:

1 2 3 4 5 6 7 }/* le tableau principal (tab) possede deux tableaux sous-jaccent */ else { fprintf (stderr, "Memoire insuffisante\n"); free (tab); tab = NULL; exit (EXIT_FAILURE);
Au premier tour tu vas faire un free sur un NULL, normalement ça ne pose pas de problèmes (sauf sur certaines plateformes), mais ce n'est qu'un problème mineur.
Code:

1 2 3 4 5 } } /* (3) */ tab[i] = chaine_sortante;
tab n'aura jamais qu'une taille de 1 élément, si i>0 alors tu t'exposes à de sérieux problèmes.
Code:

1 2 3 4 5 6 7 8 9 printf("%s\n",tab[i]); chaine_entrante = NULL; } tab[i] = NULL; } return tab; }
Là rien de particulier à dire, continuons.
Code:

1 2 3 4 5 6 7 8 9 char *TraiteMots (char *pointeur,char *Mots) { if (strcmp (pointeur,Mots)) { printf("\n Bus en station !!!"); } else { printf("\nVotre BUS n'est pas encore arrive !!\n"); } return 0; }
Alors je ne peux que te conseiller de lire la man page (ou demander à google, ou relire tes cours, ou ...) de strcmp.
strcmp (comme la grande majorité des fonctions utilisées en C pour comparer deux objets) est une fonction qui va renvoyer 0 si les deux arguments sont considérés comme égaux. Malheureusement si c'est le cas ta condition vaut 'faux' et du coup ça fait le contraire de ce que tu avais l'intention de faire ...
Une utilisation correcte de strcmp ressemble toujours plus ou moins à :
Code:

1 2 3 4 5 6 7 8 9 10 if (strcmp(arg1,arg2)<0) { ici arg1 est situé lexicographiquement au sens ascii du terme (si tu utilises un autre encodage ça ne va pas fonctionner correctement surtout avec des lettres accentuées) avant arg2 : arg1 < arg2 } else if (strcmp(arg1,arg2)==0) { ici arg1 == arg2 } else /* donc forcément le cas strcmp(arg1,arg2)>0 */ { ici arg1>arg2 }
Reste la fonction main à étudier :

Code:

int main ()

Oui je m'arrête déjà :) mais c'est mineur encore une fois ... pour être réellement correct le prototype devrait être int main(void)
Code:

1 2 3 4 5 6 7 8 9 10 { char *buffer; char Chaine_Entrante[]="Il etait une fois dans la ville de foix une marchande de foie"; char Mots[]="Il etait une fois dans la ville de foix une marchande de foie"; buffer = strdup( Chaine_Entrante ); while(1) {
Pourquoi une boucle inifinie ???? Tu n'utilises pas de break, exit ou return ...
Code:

1 2 3 4 5 6 7 if (buffer != NULL) { char **pointeur; char separateur[] = " "; char **CompareMots;
Encore un détail : tu n'utilises jamais cette variable
Code:

1 2 3 4 5 6 7 8 9 printf("%s\n",buffer); pointeur=DecoupeMots (buffer,separateur); printf("\n%s \n",pointeur[2]); //verifie les données sauvegardé TraiteMots (pointeur,Mots);
TraiteMots attends comme premier argument un char* ... tu lui donnes un char** ... planche sur ton algo ce n'est certainement pas ce que tu as en tête.
Code:

1 2 3 4 5 6 } getchar (); // Pause dans en mode console } return 0; }
Voilà voilà ... Je suis peut-être passé à côté de quelques erreurs mais tu as déjà pas mal de lecture et de modifs.
Courage :)

EDIT: ah oui ... attention aux free que tu ne fais pas ... il faut toujours libérer ce qu'on alloue quand on en n'a plus besoin.

Donc la donne a changer je voudrais faire la même chose que précédemment mais faire une comparaison de 4 messages au max et mon problème c'est la fonction strcmp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
 
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
 
char **DecoupePhase (char *chaine_entrante, const char *separateur)
 
{
   /*Declaration*/
   /* char **tab = NULL; //On crée un tableau principal et un sous-jaccent */
   char **TEXTE = NULL;
   int i = 0;
   char *chaine_sortante = NULL;
   TEXTE = malloc(4 * sizeof(*TEXTE));
 
   /*Traitement*/
   if (chaine_entrante != NULL && separateur != NULL)
   {
 
      for (i = 0; i<4 ; i++)
      {
    	 chaine_sortante = strtok(chaine_entrante, separateur);
    	 TEXTE[i] = strdup(chaine_sortante);
         printf("%s\n",TEXTE[i]);
         chaine_entrante = NULL;
 
      }
      TEXTE[i] = NULL;
   }
 
   return TEXTE;
}
 
 
/*******************************************************************************/
 
char *TraiteMots (char* buffer,char* Mots)
{
	if (strcmp (buffer, Mots) ==0)
	{
		printf("\n Bus en station !!!");
	}
	else
	{
		printf("\nVotre BUS n'est pas encore arrive !!\n");
	}
	return 0;
}
 
 
/*******************************************************************************/
 
 
int main (void)
{
	char *buffer;
	char Chaine_Entrante[]="Bonjour et reste poli";
	char Mots[]="Il etait une fois";
 
	buffer = strdup( Mots );
 
 
		while(1)
	{
 
		if (buffer != NULL)
 
		{
	char separateur[] = " ";
 
	printf("%s\n", buffer);
 
	DecoupePhase (buffer, separateur);
 
	/* printf("\n%s \n",pointeur[2]); //verifie les données sauvegardé */
 
	TraiteMots (DecoupePhase, Mots);
 
		}
 
 getchar (); // Pause dans en mode console
 
	}
free(DecoupePhase);
	return 0 ;
}

La donne pour ceux qui viennent d'arriver c'est le premier message. Merci

Bonjour,

Juste une remarque afin que tu puisses modifier ton code pour qu'il soit un peu plus correct : quand une fonction renvoie une valeur, il faut récupérer cette valeur dans une variable pour pouvoir l'utiliser ensuite. Ton code :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 char **DecoupePhase (char *chaine_entrante, const char *separateur) { ... } int main(void) { ... DecoupePhase (buffer, separateur); TraiteMots (DecoupePhase, Mots); ... free(DecoupePhase); ... }
n'a aucune chance de fonctionner correctement. Il faudrait plutôt faire quelque chose comme :
Code:

1 2 3 4 5 6 7 8 9 10 int main(void) { char **resultat_decoupe_phrase; .. resultat_decoupe_phrase = DecoupePhase (buffer, separateur); TraiteMots (resultat_decoupe_phrase, Mots); ... free(resultat_decoupe_phrase); ... }
Il y a d'autres erreurs dans ton code ... mais celle-ci est particulièrement grave. Et pourquoi garder cette boucle infinie (le while(1)) ?

25/05/2013, 22h10
Originaldev

le "while" etait parce que c'est un programme a mettre dans un microcontroller embarqué donc une boucle pour que ssoit automatique et je voulais rajouter un timer.

Et encore Merci :ccool:
25/05/2013, 22h19
Originaldev

Mais en fait j'avais pas vue qu'il y avait une partie système embarqué
26/05/2013, 10h38
Bktero

Il faut dire qu'elle est un peu cachée ^^ Ce n'est pas une sous-partie du forum C. Beaucoup de gens postant ici n'ont en fait pas un problème de C mais un problème d'embarqué. Il faut donc décider si son problème concerne uniquement le langage (auquel cas il a sa place dans le forum C) ou si son problème est lié à des problématiques matérielles ou non existantes sur PC (auquel cas il a sa place dans le forum Embarqué).

Re-bonjour a tous

Merci pour vos réponse j'ai un nouveaux probleme voila. il recupere la trame il convertit les nombre mais je voudrais convertir un charactère comme une lettre en un charactère "+" ou "-". pour faire un calcul de distance par la suite.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
 
char **DecoupePhase (char *chaine_entrante, const char *separateur)
 
{
   /*Declaration*/
   char **TEXTE = NULL;
   int i = 0;
   char *chaine_sortante = NULL;
   TEXTE = malloc(5 * sizeof(*TEXTE));
   double m=0;
 
   /*Traitement*/
   if (chaine_entrante != NULL && separateur != NULL)
   {
 
      for (i = 0; i<5 ; i++)
      {
    	 chaine_sortante = strtok(chaine_entrante, separateur);
    	 TEXTE[i] = strdup(chaine_sortante);
         /*  printf("%s\n",TEXTE[i]); //permet de voir si la separation est faite */
         m = atof(TEXTE[i]);
         printf("%f\n",m)  ; //affiche valeur convertit
         chaine_entrante = NULL;
 
      }
      TEXTE[i] = NULL;
   }
 
   return TEXTE;
}
 
 
/*******************************************************************************/
 
/* char *TraiteMots (char* buffer,char* Mots) */
char Conversions(char **TEXTE)
{
	char Moins=-;
	strcpy(Moins,TEXTE[3]);
 
	printf("element converti en operateur : %c",Moins);
	return (0);
 
}
 
 
 
 
 
 
/*******************************************************************************/
 
 
int main (void)
{
	char *buffer;
	char Chaine_Entrante[]="$GPRMC,4042.6142,N,07400.4168,W,10.55";
	/* char Mots[]="Il etait une fois"; */
	char **resultat_decoupe_phrase;
 
	buffer = strdup( Chaine_Entrante );
	double Calcul=0;
	double X=0;
	char **TEXTE = NULL;
	char Moins;
 
		while(1)
	{
 
		if (buffer != NULL)
 
		{
	char separateur[] = ",";
 
	/* printf("%s\n", buffer); */
 
	/* resultat_decoupe_phrase=DecoupePhase (buffer, separateur); */
 
	/* printf("\n%s \n",pointeur[2]); //verifie les données sauvegardé */
 
	/* TraiteMots (resultat_decoupe_phrase, Mots); */
 
	/* Calcul=NombreAuCarre(X); */
	Calcul=Conversions(Moins,TEXTE);
		}
 free(resultat_decoupe_phrase);
 getchar (); // Pause dans en mode console
 
	}
 
	return 0 ;
}

Tu as juste à regarder le caractère qui t'intéresse, et le comparer comme un nombre cette fois ! ;)

Par exemple, si tu veux comparer le premier caractère, et rendre toute la chaîne restante positive ou négative :
Code:

1 2 3 4 5 6 7 char *str, *tmp; int nb; tmp = strdup(&(str[1])); /* recuperation du "reste" de la chaine */ nb = atoi(nb); /* transformation du nombre "texte" en nombre "entier" */ if (str[0] == '-') nb = nb * (-1);
Ceci est une version "simple" qui compare le premier caractère.
Rien ne t'empêche de mettre le signe à la fin, et limiter la recopie avec strndup.
Enfin amuses-toi bien avec tout ça !

11/06/2013, 13h49
Originaldev

Ok merci:ccool: