Projet en C (information traffic bus)

**Originaldev** · 23/05/2013, 00h16

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ;
}

**Metalman** · 23/05/2013, 06h57

Créer un parser avec des strcmp/strncmp ? et découper avec des strncpy/strndup ?

**Bktero** · 23/05/2013, 09h37

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().

**Originaldev** · 23/05/2013, 11h57

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

**Originaldev** · 24/05/2013, 00h46

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

**Metalman** · 24/05/2013, 06h41

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.

**kwariz** · 24/05/2013, 08h41

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

**Originaldev** · 25/05/2013, 19h10

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

**kwariz** · 25/05/2013, 19h42

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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)) ?

**Originaldev** · 25/05/2013, 22h10

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

**Originaldev** · 25/05/2013, 22h19

Mais en fait j'avais pas vue qu'il y avait une partie système embarqué

**Bktero** · 26/05/2013, 10h38

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é).

**Originaldev** · 06/06/2013, 20h12

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ;
}

**Metalman** · 06/06/2013, 21h09

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 !

**Originaldev** · 11/06/2013, 13h49

Ok merci

Projet en C (information traffic bus)

C

Discussions similaires

Partager

Partager