Discussion :

[abyass]

Bonjour tout le monde, oui c'est encore moi !!

J'ai besoin de vos aides SVP. Je ne sait pas si je suis dans la bonne section ou je dois me diriger vers le forum d'EDI.

En fait, je suis entrain de développer un programme en C qui se communique avec une carte électrique sur le port UART pour récupérer le contenu de ces registres, qui seront par la suite traitées et stockées dans une base de données. J'étais sur Code::blocks et j'ai presque finalisé l'écriture et la lecture sur la carte.
Sauf que je me suis trouvée obligée de changer l'EDI vers Visual Studio pour concevoir une IHM. et c'est ma première fois que je travaille sur ce EDI.


J'ai copié mon code qui marchait très bien avec Code::Blocks, quand je build, la lecture plante. Et je n'arrive pas à comprendre pourquoi.


Voici le code de lecture d'un seul registre.

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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
 
/*************************************
pour utiliser printf et sprintf correctement
*************************************** */
#define _CRT_SECURE_NO_WARNINGS
 
/*******************************
Déclaration des includes 
***************************** */
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <string.h>
#include <malloc.h>
 
/* *******************************
Fonctions du modules
******************************* */
 
 
#include "Struct_TrameSending.h"
#include"Struct_Conf.h"
#include "DumpHex.h"
#include "Ecriture.h"
#include "Lecture.h"
#include"Str_To_uint32.h"
#include "Jeu_Octets.h"
/* *******************************
Fonctions de conversion
******************************* */
 
 
#include "V_INST.h"
 
/* *************************************
Définition des constantes
************************************* */
#define MAX_WAIT_READ  500   // timeout de 5000ms
#define TX_TAILLE 5
#define RX_TAILLE 5
/* *************************************
Définition des vitesses de communication
************************************** */
#define V9600 9600
#define V115200 115200
 
/* *************************************
Définition de nombre de bits
************************************** */
#define BITS_7 7
#define BITS_8 8
 
 
int main(void)
{
    DCB dcb; //Variable dcb contenant la configuration du port
    HANDLE hCom; //Handle du port COM
    BOOL fSuccess; // Tout est bien passé 
    COMMTIMEOUTS tTimeout;
    int TimeoutRead; 
 
	char *message_VINST, 
        //Déclaration des msg de TX
	char  *msgVINST;	
	//Déclaration des Buffer de RX
	char   *inBuffer_VINST;
 
	//Dcélaration des structures
	struct TrameSending V_INST;
	struct Conf_Comm Conf;
 
	//Allocation mémoire  des msg de TX
 
	message_VINST =(char*) malloc(TX_TAILLE);
 
	//Allocation mémoire  des Buffer de RX
    inBuffer_VINST= (char*)malloc(RX_TAILLE);
 
 
 
 
    //Déclaration des trames à envoyer:
 
	//V_INST
	V_INST.c1=0x30; V_INST.crc=0xE7; V_INST.c2=0xFF; V_INST.c3=0xFF; V_INST.c4=0xFF;
 
	//Déclaration des paramètres de la trame
        Conf.Parite="Aucune";
	Conf.StopBit="1";
 
 
   // demande du numéro du port COM
   printf("Entrez le numero du port COM : ");
   scanf("%d", &nPort);
   sprintf(cPort, "\\\\.\\COM%d", nPort);
 
 
    //Ouverture du port Comm
    hCom= CreateFile ( cPort,
                      GENERIC_READ|GENERIC_WRITE, //accés lecture/ecriture
                      0, //pas de partage possible du port une fois ouvert
                      NULL, //pas d'héritage
                      OPEN_EXISTING, //doit etre open_existing
                      0, // pas d'overlopped I/O
                      NULL //hTemplate doit etre null
                 );
    // Vérifier si handle ouvre correctement
    if (hCom ==INVALID_HANDLE_VALUE)
    {
        //Manipuler l'erreur
        printf("Create file failed with error %d\n", GetLastError());
    }
    //Lecture de configuration actuelle
    fSuccess = GetCommState (hCom, &dcb);
    if (!fSuccess)
    {
         //Manipuler l'erreur
        printf("GetCommState failed with error %d\n", GetLastError());
    }
    //Configuration du port:
 
    // gestion de vitesse . (atoi:Convertir String to integer)
    dcb.BaudRate= V9600;
 
    //gestion de la taille
    dcb.ByteSize= BITS_8;
 
 
    // Gestion de la partité
    if (strcmp (Conf.Parite, "Aucune")==0) //strcmp : si égaux renvoie 0
        dcb.Parity=NOPARITY; // pas de parité
    if (strcmp (Conf.Parite, "Paire")==0)
        dcb.Parity=EVENPARITY;
    if (strcmp (Conf.Parite, "Impaire")==0)
        dcb.Parity=ODDPARITY;
 
 
    //Gestion bit de Stop
    if (strcmp (Conf.StopBit, "1")==0)
        dcb.StopBits= ONESTOPBIT; // 1 bit stop
    if (strcmp (Conf.StopBit, "1.5")==0)
        dcb.StopBits= ONE5STOPBITS; // 1.5 bit stop
    if (strcmp (Conf.StopBit, "2")==0)
        dcb.StopBits= TWOSTOPBITS; // 2 bit stop
 
    //Configurer le port
    fSuccess = SetCommState(hCom, &dcb);
    if (!fSuccess)
    {
        //Manipuler l'erreur
        printf("SetCommState failed with error %d\n", GetLastError());
    }
    else
    {
        printf("périphérique initialisé correctement \n \n");
    }
 
    fSuccess = GetCommTimeouts(hCom,  &tTimeout); 
    if (!fSuccess)
    {
         //Manipuler l'erreur
        printf("GetCommTimeouts failed with error %d \n", GetLastError());
    }
 
    //Définition des timeouts
 
    TimeoutRead= MAX_WAIT_READ;
    tTimeout.ReadIntervalTimeout= TimeoutRead;
    tTimeout.ReadTotalTimeoutMultiplier=0;
    tTimeout.ReadTotalTimeoutConstant=TimeoutRead;
    tTimeout.WriteTotalTimeoutMultiplier=0;
    tTimeout.WriteTotalTimeoutConstant=0;
 
    //Configuration du Timeout
    fSuccess = SetCommTimeouts(hCom, &tTimeout);
    if (!fSuccess)
    {
        //Manipuler l'erreur
        printf("SetCommTimeouts failed with error %d\n", GetLastError());
    }
 
 
    //V_INST:
    sprintf(message_VINST, "%c", V_INST.c1);
    sprintf(message_VINST+1, "%c", V_INST.c2);
    sprintf(message_VINST+2, "%c",  V_INST.c3);
    sprintf(message_VINST+3, "%c", V_INST.c4);
    sprintf(message_VINST+4, "%c",  V_INST.crc);
    Ecriture (message_VINST,hCom );
    msg =Lecture(inBuffer,hCom, fSuccess ); //recevoir n'importe quoi
    //fermer le port
    CloseHandle(hCom);
 
    // Traiter V_INST:
    uint32_t VI=Str_To_uint32 (msgVINST);
    uint32_t VI1 =Jeu_Octets(VI);
    float V__INST=VINST (VI1);
    printf("V_INST= %f \n", V__INST);
 
        //Libérer la mémoire
 
    free(message_VINST);
 
    return (fSuccess);
    }

Voilà la réponse sur Code::Blocks:


Alors que avec VS:


Je n'arrive pas à trouver le problème. Donc si quelqu'un pourra m'aider SVP.


Merci

[johntheripper]

1) Pour Codeblocks que j'utilise souvent, il faut telecharger la version avec le compilateur mingw. part sur le site de codeblocks et telecharge la version avec mingw, tu n'auras plus de probleme
2) tu peux utiliser l'editeur de code ATOM qui est mon preferée tu l'installe sur ta machine, apres avoir installlé tu doit installer le compilateur gcc sous ta machine et tout y est.
le plus abordable est que avec linux tout est moins compliqué.

[abyass]

Merci pour votre réponse.

Oui avec Code::Blocks, j'utilise le compilateur mingw et déjà tout marche bien. Mon problème apparait quand j'ai changé Visual Studio.
Sinon pour moi je préfère travailler avec Code::Bocks. Je l'utilise depuis un moment et tout marche bien. Mais, vu que je suis en stage et à l'entreprise ou je travaille utilise VS et surtout aussi que je dois faire une IHM qui lance la lecture des registres de la carte.


Merci

[johntheripper]

je ne peux te mentir mais VS je ne l'ai jamais utiliser moi j'utilise le plus ATOM et souvent Codeblocks mais essai d'envoyer l'erreur sur google et j'en suis sure que tu trouveras une reponse google est notre reference à tous

[Bktero]

A mon avis, ton code ne marchait pas très bien avec CodeBlocks mais simplement CodeBlocks ne faisait pas certaines vérifications que fait Visual Studio. Et là, il a détecté un problème qui était déjà dans ton code. Le message d'erreur me laisse penser que tu écris en dehors d'une zone que tu as alloué dans le tas (heap en anglais) mais Google devrait t'en dire plus sur la signification complète de l'erreur. Il s'avère que dans ton code, il y a effectivement des malloc() et free() donc ça ne semble pas déconnant.

En regardant ton code, je constate que tu fais un malloc() sur inBuffer_VINST mais que tu ne t'en sers pas. Y compris, tu ne libères pas la mémoire avec free().

Concernant message_VINST, qui est l'autre pointeur utilisant une zone fournie par malloc(), tu remplis la zone avec 5 caractères, ça à l'air OK mais ensuite tu la passes à la fonction Ecriture() qu'on ne connait pas et je me demande comment elle connait la taille...

Personnellement, je te conseille d'utiliser un débogueur mémoire comme expliqué ici https://www.developpez.net/forums/d1...ows-and-linux/

[abyass]

Merci pour votre réponse.

En regardant ton code, je constate que tu fais un malloc() sur inBuffer_VINST mais que tu ne t'en sers pas. Y compris, tu ne libères pas la mémoire avec free().

c'est juste une faute de frappe, car en fait j'ai modifié le long code pour le mettre ici. Mais en réalité inBuffer_VINST est passé dans la fonction Lecture :

Code :

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

msg =Lecture(inBuffer_VINST ,hCom, fSuccess );

Voilà ma fonction Ecriture:

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
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <winbase.h>
#include <conio.h>
#include <string.h>
#ifndef Ecriture_H
#define Ecriture_H
 
#define TX_TAILLE 5
 
 
 
BOOL Ecriture (char *message, HANDLE hCom )
{
 
 
    BOOL fSuccess;
    unsigned long nBytesWrite;
 
 
 
    //Ecrire dans le fichier
    fSuccess=WriteFile(hCom, message,TX_TAILLE, &nBytesWrite, NULL);
    if (!fSuccess)
    {
        //Manipuler l'erreur
        printf("WriteFile failed with error %d\n", GetLastError());
    }
    else
    {
        printf("Ecriture correcte \n");
    }
    free(message);
    return fSuccess;
}
#endif // Ecriture_H

Merci