Problème ntdll, Gestion mémoire..

Version imprimable

Bonjour,

Je suis débutant en c++ et j'ai un problème avec une classe qui calcul un checksum...
Il n'y a pas de souci lorsque l'appel la méthode de calcul du checksum qu'une seule fois mais lorsque que je l'appel un certains nombre de fois, ça bug à un moment donné.
J'ai ce message en console : process returned -1073741819 (0xc0000005).
Et une erreur windows lié à ntdll.dll.:euh:
Le problème c'est que si je lance en debug, ça ne plante jamais.. 8O , j'ai vu qu'il y avait peut être une surallocation de la mémoire pour le mode debug.

Voici mon code :

le .h

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
 
#ifndef CHECKSUM_H
#define CHECKSUM_H
 
#include <string>
#include <cstring>
#include <iostream>
#include <sstream>
#include <vector>
#include <math.h>
 
 
 
class Checksum
{
    public:
        Checksum();
        Checksum(std::string strChaineRecue);
        virtual ~Checksum();
 
        bool calcChecksum();
 
    protected:
    private:
        std::string chaine;
        std::string checksum;
 
        std::vector<std::string> cutString(std::string trame, int n);
};
 
#endif // CHECKSUM_H

le cpp

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
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
 
#include "Checksum.h"
 
using namespace std;
 
/*------------------------------------------------------------------------
*                 CONSTRUCTEURS ET DESTRUCTEUR DE LA CLASSE
* Parametres :
* string chaineRecue
*
* Exemple :
* Checksum sum("55AA70010071");
* bool isGood = sum.calcChecksum();
*------------------------------------------------------------------------	*/
 
Checksum::Checksum(string strChaineRecue)
{
    chaine = "";
    chaine.assign(strChaineRecue);
    cout << "Dans checksum --> " + chaine << endl; //DEBUG
    //MessageBox(NULL,"BONJOUR","CHECKSUM",MB_OK|MB_ICONEXCLAMATION); //DEBUG
}
 
Checksum::Checksum()
{
    chaine = "";
    checksum = "";
}
 
Checksum::~Checksum()
{
    //MessageBox(NULL,"AU REVOIR","CHECKSUM",MB_OK|MB_ICONEXCLAMATION); //DEBUG
    cout << "Quit checksum " << endl;
}
 
/*------------------------------------------------------------------------
*                 Méthode de calcul du checksum
*
* Parametres :
*
* Retour : un boolean egal à 0 si erreur.
*------------------------------------------------------------------------	*/
bool Checksum::calcChecksum()
{
    int i = 0;
    int nbEssai = 0; //Nombre de boucles max pour calculer le checksum
    int tmpHex = 0;//
    int sumHex = 0; //Somme en hexa
    int verifSum = 0; //Checksum a vérifier (dernier octet)
    int lastOctet = 0; // Dernier octet envoyé (Checksum)
    bool endCalc = false; //Booléen indiquenat le fin du calcul
    int tailleVector = 0;
    ostringstream oss; //Flux de sortie
    string result = "";
    vector<string> vChaineToCalc; //Chaine à calculer le checksum
 
    vChaineToCalc.clear();
    // réserver (allouer) de la place pour au moins n éléments
    vChaineToCalc.reserve(50);
 
    //Vérification que la chaine est un nombre pair : Si result = 721 alors on met result = 0721 (Pour le calcul de la somme des octets)
    if((chaine.size() % 2) == 0){
        // nb pair, on ne fait rien
    }else{
         // nb impair, on ajoute un 0 au début
         chaine = "0" + chaine;
    }
 
    //Découpe la chaine par paire de lettre :
    vChaineToCalc = cutString(chaine, 2);
    /*---------------------------------------------------------------------*/
    // On recherche le checkum dans la trame (dernier octet)
    /*---------------------------------------------------------------------*/
    tailleVector = vChaineToCalc.size(); //Taille de la trame
    if(tailleVector>0){
        lastOctet = tailleVector - 1; //Indice du dernier octet (Checksum)
    }else{
        lastOctet = tailleVector; //Indice du dernier octet (Checksum)
    }
 
    /*---------------------------------------------------------------------*/
    // Conversion string -> hexa de l'octet du checksum
    /*---------------------------------------------------------------------*/
    cout << lastOctet << endl;
    cout << vChaineToCalc[lastOctet] << endl;
 
    stringstream iss(vChaineToCalc[lastOctet]);
    iss >> hex >> verifSum;
    iss.clear(); //Vide le buffer
 
    /*---------------------------------------------------------------------*/
 
    //cout << "verifsum : "; //DEBUG
    //cout << verifSum << endl; //DEBUG
 
    /*---------------------------------------------------------------------*/
    // Conversion string -> hexa + calcul de la somme des octets sans l'octet du checksum
    /*---------------------------------------------------------------------*/
 
    for(i=0; i < tailleVector - 1; i++)
    {
        stringstream iss(vChaineToCalc[i]);
        iss >> hex >> tmpHex;
        sumHex += tmpHex;
        iss.clear(); //Vide le buffer
    }
 
    /*---------------------------------------------------------------------*/
 
    //cout << "sumhex : "; //DEBUG
    //cout << sumHex << endl; //DEBUG
 
    while(endCalc == false)
    {
        //Si le nombre est sur plus de 1 octet (FF) on recalcul la somme des octets restant
        if(sumHex > 255)
        {
            // On incrémente le nombre d'essai
            nbEssai++;
            if(nbEssai>5)
            {
                return 0; //ERREUR
            }
 
            // écrire un nombre dans le flux
            oss << hex << sumHex;
            result = oss.str();
            oss.clear(); // Vide le buffer
 
            //Vérification que le résulat est un nombre pair : Si result = 721 alors on met result = 0721 (Pour le calcul de la somme des octets)
            if ((result.length() % 2) == 0){
                // nb pair, on ne fait rien
            } else {
                 // nb impair, on ajoute un 0 au début
                 result = "0" + result;
            }
            //vChaineToCalc.clear();
            vChaineToCalc = cutString(result, 2);
            //On réinitialise sumHex :
            sumHex = 0;
 
            /*---------------------------------------------------------------------*/
            // Conversion string -> hexa + calcul de la somme des octets
            /*---------------------------------------------------------------------*/
            tailleVector = vChaineToCalc.size();
            for(i=0; i < tailleVector; i++)
            {
                stringstream iss(vChaineToCalc[i]);
                iss >> hex >> tmpHex;
                sumHex += tmpHex;
                iss.clear(); //Vide le buffer
            }
 
        }
        else
        {
            endCalc = true;
        }
    }
 
    cout << sumHex << endl;
    cout << verifSum << endl;
    cout.clear();
 
    //Vérification si la somme est bien égal au checksum envoyé :
    if(sumHex == verifSum && sumHex != 0)
    {
        return (1); //CHEKSUM VALIDE
    }
    else
    {
        return (0); //CHEKSUM INVALIDE
    }
}
 
/*------------------------------------------------------------------------
*                 Méthode de découpage d'une chaine de caractères
*
* Parametres
* int n 		    : Intervalle entre les découpages
*
* Retour : un vecteur de string avec la trame où il faut calculer le checksum
*------------------------------------------------------------------------	*/
vector<string> Checksum::cutString(string trame, int n)
{
    unsigned int k;
    vector<string> vectChaine;
 
    //Vérification si la taille de la trame est paire :
    if((trame.size() % 2) == 0)
    {
        for(k=0; k < trame.size() - 1; k+=n)
        {
            cout << "cutString --> 0x" + trame.substr(k, n) << endl; //DEBUG
            vectChaine.push_back("0x" + trame.substr(k, n));
        }
    }
 
    return vectChaine;
}

le code qui appel la classe :

...

Code:

1
2
3
 
Checksum sum(chaine);
isGood = sum.calcChecksum();

...

12/05/2011, 13h50
fregolo52

Hummm. Ca sent le pointeur nul (qui ne l'ai pas en debug) !!!

Tu compiles avec quoi ? gcc ou Visual ? parce qu'avec Visual, meme en release tu peux savoir où ca a planté.
12/05/2011, 14h20
krapo13

Citation:

Envoyé par fregolo52

Hummm. Ca sent le pointeur nul (qui ne l'ai pas en debug) !!!

Tu compiles avec quoi ? gcc ou Visual ? parce qu'avec Visual, meme en release tu peux savoir où ca a planté.

Salut fregolo52, je compile avec gcc...

J'arrive à ce que le code ne plante plus

Checksum.cpp :

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
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
 
#include "Checksum.h"
 
using namespace std;
 
/*------------------------------------------------------------------------
*                 CONSTRUCTEURS ET DESTRUCTEUR DE LA CLASSE
* Descriptif :
* Fonction permettant de calculer le checksum pour la communication sur port série avec la sonde
* BDG09
* Parametres :
* string chaineRecue
*
* Exemple :
* Checksum sum("55AA70010071");
* bool isGood = sum.calcChecksum();
*------------------------------------------------------------------------	*/
 
Checksum::Checksum(string strChaineRecue)
{
    chaine = "";
    chaine.assign(strChaineRecue);
    cout << "Dans checksum --> " + chaine << endl; //DEBUG
}
 
Checksum::Checksum()
{
    chaine = "";
}
 
Checksum::~Checksum()
{
    cout << "Quit checksum " << endl; //DEBUG
}
 
/*------------------------------------------------------------------------
*                 Méthode de calcul du checksum
*
* Parametres :
*
* Retour : un boolean egal à 0 si erreur.
*------------------------------------------------------------------------	*/
bool Checksum::calcChecksum()
{
    unsigned int i = 0;
    unsigned int nbEssai = 0; //Nombre de boucles max pour calculer le checksum
    unsigned int sumHex = 0; //Somme en hexa
    unsigned int verifSum = 0; //Checksum a vérifier (dernier octet)
    unsigned int lastOctet = 0; // Dernier octet envoyé (Checksum)
    unsigned int tailleVector = 0;
    bool endCalc = false; //Booléen indiquenat le fin du calcul
    ostringstream oss; //Flux de sortie
    string result = "";
    vector<string> vChaineToCalc; //Chaine à calculer le checksum
 
    // réserver (allouer) de la place pour au moins n éléments
    vChaineToCalc.reserve(chaine.size());
    vChaineToCalc.rbegin();
 
    //Vérification que la chaine est un nombre pair : Si result = 721 alors on met result = 0721 (Pour le calcul de la somme des octets)
    if(!(chaine.size() % 2) == 0)
        chaine = "0" + chaine;
 
    //Découpe la chaine par paire de lettre :
    vChaineToCalc = cutString(chaine, 2);
    /*---------------------------------------------------------------------*/
    // On recherche le checkum dans la trame (dernier octet)
    /*---------------------------------------------------------------------*/
    tailleVector = vChaineToCalc.size(); //Taille de la trame
    if(tailleVector>0){
        lastOctet = tailleVector - 1; //Indice du dernier octet (Checksum)
    }else{
        lastOctet = tailleVector; //Indice du dernier octet (Checksum)
    }
 
    /*---------------------------------------------------------------------*/
    // Conversion string -> hexa de l'octet du checksum
    /*---------------------------------------------------------------------*/
    verifSum = Ascii::stringToHexa(vChaineToCalc.at(lastOctet));
 
    /*---------------------------------------------------------------------*/
 
 
    /*---------------------------------------------------------------------*/
    // Conversion string -> hexa + calcul de la somme des octets sans l'octet du checksum
    /*---------------------------------------------------------------------*/
 
    for(i=0; i < tailleVector - 1; i++)
    {
        sumHex += Ascii::stringToHexa(vChaineToCalc.at(i));
    }
 
    /*---------------------------------------------------------------------*/
 
    while(endCalc == false)
    {
        //Si le nombre est sur plus de 1 octet (FF) on recalcul la somme des octets restant
        if(sumHex > 255)
        {
            // On incrémente le nombre d'essai
            nbEssai++;
            if(nbEssai>5)
                return 0; //ERREUR
 
            // écrire un nombre dans le flux
            oss << hex << sumHex;
            result = oss.str();
            oss.clear(); // Vide le buffer
 
            //Vérification que le résulat est un nombre pair : Si result = 721 alors on met result = 0721 (Pour le calcul de la somme des octets)
            if (!(result.length() % 2) == 0){
                 // nb impair, on ajoute un 0 au début
                 result = "0" + result;
            }
 
            // Si le tableau n'est pas vide on le vide :
            if(!vChaineToCalc.empty())
                vChaineToCalc.clear();
 
            //Découpage de la chaine :
            vChaineToCalc = cutString(result, 2);
            //On réinitialise sumHex :
            sumHex = 0;
 
            /*---------------------------------------------------------------------*/
            // Conversion string -> hexa + calcul de la somme des octets
            /*---------------------------------------------------------------------*/
            tailleVector = vChaineToCalc.size();
            for(i=0; i < tailleVector; i++)
            {
                sumHex += Ascii::stringToHexa(vChaineToCalc.at(i));
            }
        }
        else
        {
            endCalc = true;
        }
    }
 
    //cout << sumHex << endl; //DEBUG
    //cout << verifSum << endl; //DEBUG
 
    //Vérification si la somme est bien égal au checksum envoyé :
    if(sumHex == verifSum && sumHex != 0)
    {
        cout << "Checksum valide" << endl; //DEBUG
        return (1); //CHEKSUM VALIDE
    }
    else
    {
        cout << "Checksum NON valide" << endl; //DEBUG
        return (0); //CHEKSUM INVALIDE
    }
}
 
/*------------------------------------------------------------------------
*                 Méthode de découpage d'une chaine de caractères
*
* Parametres
* int n 		    : Intervalle entre les découpages
*
* Retour : un vecteur de string avec la trame où il faut calculer le checksum
*------------------------------------------------------------------------	*/
vector<string> Checksum::cutString(string trame, int n)
{
    unsigned int k;
    vector<string> vectChaine;
    vectChaine.reserve(trame.size());
    vectChaine.rbegin();
 
    //Vérification si la taille de la trame est paire :
    if((trame.size() % 2) == 0)
    {
        for(k=0; k < trame.size() - 1; k+=n)
        {
            cout << "cutString --> 0x" + trame.substr(k, n) << endl; //DEBUG
            vectChaine.push_back("0x" + trame.substr(k, n));
        }
    }else{
        vectChaine.push_back("0x00");
    }
 
    return vectChaine;
}

Mais il y a un truc bizarre, si j'enlève la ligne de la méthode "cutStrting" (ligne 176) :

Code:

1
2
 
cout << "cutString --> 0x" + trame.substr(k, n) << endl; //DEBUG

Eh ben ça replante comme avant :mur::scarymov:
D'où cela peut-il bien venir ??

26/05/2011, 12h33
themadmax

Compilation VS2008, execution WinXP : no problem
Passage de Intel inspecteur qui n'a po trouver de problème de mémoire.
26/05/2011, 15h29
krapo13

Oui alors ça doit venir de plus haut...
En fait j'appelle cette classe est appelée en boucle dans mon programme.
J'ai essayé de simuler cette classe toute seule(en boucle) et c'est vrai je n'ai pas de problèmes, maintenant, une fois intégré dans le reste de mon programme, ça plante(ntdll) :cry: !
Par contre si dans la méthode "cutString" j'enlève la ligne

Code:

vectChaine.push_back("0x" + trame.substr(k, n));

et que je la remplace par par exemple

Code:

vectChaine.push_back("0x00");

là ça ne plante plus ! Je ne comprends plus rien :marteau: .

Je débute en c++ et j'ai du mal a débugger :marteau: !
26/05/2011, 17h20
jblecanard

Citation:

Envoyé par fregolo52

Hummm. Ca sent le pointeur nul (qui ne l'ai pas en debug) !!!

Au contraire justement, ça sent le pointeur non initialisé qui n'est pas nul et pointe n'importe où dans la mémoire, alors que le mode debug les initialisent automatiquement. krapo13, commence par vérifier que tu initialises tous les pointeurs que tu crées. A partir de là, on pourra avancer plus sereinement...

Edit : pour gagner du temps, tu peux utiliser CppCheck qui t'aidera à trouver les variables et pointeurs non initialisés.
26/05/2011, 17h32
krapo13

Je débute en c++, est ce que par exemple écrire

Code:

char *rep(0);

c'est initialiser le pointeur "rep" ?
26/05/2011, 17h36
jblecanard

C'est exact. Personnellement, je préfère la syntaxe :

Code:

char * rep = NULL;

Mais la tienne est tout à fait correcte.

Merci pour ce petit logiciel qu'est cppCheck ! :ccool:
J'ai une erreur quand je scanne mon répertoire de travail :

Array 'rep[7]' index 7 out of bounds

Le code :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
    const char *query(0);
    char *rep(0); 
    char *repInit(0); 
    char *allRep(0); 
 
    int repSize = 7; //Taille de la trame contenant la réponse à retourner
    int repInitSize = 5; //Taille de la trame contenant le début de la trame
    int allRepSize = 12; //Taille de la trame contenant toute la trame
 
    bool isGood; //Réponse du checksum
    string trameToCheck; //Trame à vérifier (checksum)
 
 
    rep = new char[repSize];
    repInit = new char[repInitSize];
    allRep = new char[allRepSize]; 
    query = new char[sizeTrameDerQuery];

26/05/2011, 18h14
Lucien63

L'erreur signifie que tu accedes à ton tableau avec l'indice 7 quelque part dans ton programme, alors que dans le cas de ton tableau les indices vont de 0 à 6
26/05/2011, 18h29
jblecanard

Citation:

Envoyé par krapo13

Merci pour ce petit logiciel qu'est cppCheck ! :ccool:

Je ne sais pas si on peut dire petit, c'est quand même un sacré outil :mrgreen:

Citation:

Envoyé par krapo13

Merci pour ce petit logiciel qu'est cppCheck ! :ccool:
J'ai une erreur quand je scanne mon répertoire de travail :

Array 'rep[7]' index 7 out of bounds

Excellent, c'est une erreur classique dont les symptômes correspondent aux tiens. En C++, les tableaux vont de 0 à (taille du tableau -1). Qu'est ce que ça donne si tu nous corriges cela ?

En général, on détecte plutôt ce genre d'erreurs avec Valgrind ou DrMemory car elle ne sont pas forcément trouvable de manière statique.
26/05/2011, 18h35
krapo13

Si j'enlève la variable "repsize" et que j'initialise directement rep à 7

Code:

rep = new char[7];

Je n'ai plus l'erreur dans CppCheck.
Est ce que toutes les réponses de ce très utile logiciel sont pertinentes ?
Où peuvent-elles en cacher d'autres ?
J'ai l'impression que ça me mène sur une fausse piste vu que mon problème reste (même si j'augmente considérablement la taille du char)...
Je ne sais pas trop quoi faire :aie: ..

Petite précision, c'est une librairie dynamique que je tente de développer..
26/05/2011, 18h41
jblecanard

Citation:

Envoyé par krapo13

Est ce que toutes les réponses de ce très utile logiciel sont pertinentes ?
Où peuvent-elles en cacher d'autres ?
J'ai l'impression que ça me mène sur une fausse piste vu que mon problème reste (même si j'augmente considérablement la taille du char)...

Difficile à dire sans voir les erreurs en question. Tu peux poster le résultat et je pourrais te dire ce qui est pertinent ici et ce qui ne l'est pas.

Donc le bug est toujours là ? Si tous tes pointeurs sont correctement initialisés, il va falloir chercher autrement. Est-ce qu'on peut voir un code complet qui produit le plantage ?
26/05/2011, 18h52
krapo13

Voilà le résultat de CppCheck :

http://imageshack.us/photo/my-images/199/capturedh.png/

http://imageshack.us/photo/my-images/199/capturedh.png/
26/05/2011, 19h05
jblecanard

C'est pas mal propre tout ça. Les autres points ne sont pas responsables de ton problème.

Est ce que tu peux nous faire un code complet qui produit l'erreur ?

PS : J'ai découvert grâce à toi que CppCheck avait une interface graphique, je l'ai toujours utilisé en ligne de commande :mrgreen:.

Je crois que c'est ce que tu me demandes...
Voici tout mon code (Un peu d'indulgence c'est mon premier en c++ et les pointeurs sont pour moi une nouveauté :calim2:) :
En gros je développe une dll qui servira à faire la communication avec une sonde. Il y a 2 classes que je n'ai pas mise, qui je pense ne pose pas de problèmes, une pour communiquer avec le port série et une pour convertir un int en caractere héxadecimal !
Je compil avec codeblock(mingw)..

--> main (entrée de la librairie)
main.h

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
 
#ifndef __MAIN_H__
#define __MAIN_H__
 
#include <windows.h>
#include <iostream>
#include <stdio.h>
#include <string>
 
#include "BdgCom.h"
 
/*  To use this exported function of dll, include this header
 *  in your project.
 */
 
#ifdef BUILD_DLL
    #define DLL_EXPORT __declspec(dllexport) __stdcall
#else
    #define DLL_EXPORT __declspec(dllimport) __stdcall
#endif
 
//char derResult; //ded
char derResult;
char serialResult; // No série
char addressResult; //Adresse sonde
char tempResult; //Température sonde
 
BdgCom bdg;
 
#ifdef __cplusplus
extern "C"
{
#endif
 
/*=============================================================================
Fonctions exporter de la bibliothèque
=============================================================================*/
bool DLL_EXPORT openCOMDLL(); //Ouverture du port
bool DLL_EXPORT closeCOMDLL(); //Fermeture du port
char* DLL_EXPORT derQueryDLL();//Par défaut la sonde est à l'adresse 1
char* DLL_EXPORT serialQueryDLL();//Par défaut la sonde est à l'adresse 1
char* DLL_EXPORT tempQueryDLL();//Par défaut la sonde est à l'adresse 1
 
#ifdef __cplusplus
}
#endif
 
#endif // __MAIN_H__

main.cpp

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
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
 
#include "main.h"
 
using namespace std;
 
BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
{
    switch (fdwReason)
    {
        case DLL_PROCESS_ATTACH:
            // attach to process
            // return FALSE to fail DLL load
            break;
 
        case DLL_PROCESS_DETACH:
            // detach from process
            break;
 
        case DLL_THREAD_ATTACH:
            // attach to thread
            break;
 
        case DLL_THREAD_DETACH:
            // detach from thread
            break;
    }
    return TRUE; // successful
}
 
bool openCOMDLL()
{
    bool isOpen = false;
    isOpen = bdg.openCOMDLL("COM4");
    return isOpen;
}
 
bool closeCOMDLL()
{
    bool isClose = false;
    isClose = bdg.closeCOMDLL();
    return isClose;
}
 
/*------------------------------------------------------------------------
*                 DER QUERY
* Descriptif :
* Fonction permettant de récupérer le débit de dose calculé par la sonde
* BDG09
* Parametres :
* int adresse de la sonde
*
* Retour :
* Chaîne de caractères avec le débit de dose et l'erreur statistique séparés par un point virgule
* Null si erreur
*----------------------------------------------------------------------*/
char* derQueryDLL()
{
    //On envoie l'adresse du pointeur où sera stocké le ded :
    try
    {
        Sleep(50);
        return bdg.derQuery(&derResult);
    }
    catch (const std::exception &e)
    {
        cout << "ERROR derquery DLL : " << endl;
        cerr << e.what() << endl;
        return (0);
    }
}
 
/*------------------------------------------------------------------------
*                 SERIAL QUERY
* Descriptif :
* Fonction permettant de récupérer le numéro de série de la sonde
* BDG09
* Parametres :
* char *serialResult --> contient la chaine de retour
 
* Retour :
* Chaîne de caractères avec le numéro de série de la sonde
* ----------------------------------------------------------------------*/
char* serialQueryDLL()
{
    //On envoie l'adresse du pointeur où sera stocké le No de série :
    try
    {
        Sleep(50);
        return bdg.serialQuery(&serialResult);
    }
    catch (const std::exception &e)
    {
        cout << "ERROR serialQueryDLL : " << endl;
        cerr << e.what() << endl;
        return (0);
    }
}
 
/*------------------------------------------------------------------------
*                 TEMPERATURE QUERY
* Descriptif :
* Fonction permettant de récupérer la température de la sonde
* BDG09
* Parametres :
* char *tempResult --> contient la chaine de retour
 
* Retour :
* Chaîne de caractères avec la température de la sonde
* ----------------------------------------------------------------------*/
char* tempQueryDLL()
{
    //On envoie l'adresse du pointeur où sera stocké la température :
    try
    {
        Sleep(50);
        return bdg.tempQuery(&tempResult);
    }
    catch (const std::exception &e)
    {
        cout << "ERROR tempQueryDLL : " << endl;
        cerr << e.what() << endl;
        return (0);
    }
}
 
/*------------------------------------------------------------------------
*                 ADRESSE QUERY
* Descriptif :
* Fonction permettant de récupérer la température de la sonde
* BDG09
* Parametres :
* char newAddress --> Nouvelle adresse de la sonde
* int respDelay --> délai de réponse du changement d'adresse
* Retour :
* Booléen, changement oui ou non
* ----------------------------------------------------------------------*/

--> bdgcom
Directement relié au main, c'est lui qui lui renvoi les données voulu... (Pour le moment je n'utilise que la méthode derQuery, les autres lui ressemble, je finirai quand celle-ci n'aura plus de bugs)

bdgCom.h

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
 
#ifndef BDGCOM_H
#define BDGCOM_H
 
#include <string>
#include <cstring>
#include <iostream>
 
#include "SerialPort.h"
#include "Checksum.h"
#include "Ascii.h"
 
 
class BdgCom
{
    public:
 
        BdgCom(const char *addr="01");
        virtual ~BdgCom();
 
        char hexToChar(char first, char second);
        bool openCOMDLL(const char *port,const char *parite="Aucune",int vitesse=19200,int data=8,const char *stopBit="1",int timeOut=40); //Ouverture du port
        bool closeCOMDLL(); //Fermeture du port
        char* readCOMDLL(int nbCharRx=0); //Lecture du port
        bool writeCOMDLL(const char *chaine,int nbCharTx=0); //Ecriture sur le port, chaine à envoyer + taille de la chaine
 
        char* derQuery(char *derResult); //Débit de dose
        char* serialQuery(char *serialResult); //No de série
        char* tempQuery(char *tempResult); //Température
        //bool addressQuery(); //Changement adresse
 
    protected:
 
        std::string strDerQuery; //Trame du DerQuery
        int sizeTrameDerQuery; //Taille de la trame à envoyer
 
        std::string strSerialQuery; //Trame du serialQuery
        int sizeTrameSerialQuery; //Taille de la trame
 
        std::string strTemperatureQuery; //Trame de temperatureQuery
        int sizeTrameTempQuery; //Taille de la trame
 
        std::string strAddressQuery; //Trame de addressQuery
        int sizeTrameAddressQuery; //Taille de la trame
 
        bool checksumdDLL(const std::string chaine); //Calcul du checksum
 
        char chaineRecue; //Chaine de reception sur le port série
 
    private:
 
        SerialPort com; //Classe composée de la classe SerialPort
 
};
 
#endif // BDGCOM_H

bdgCom.cpp

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
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
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
 
#include "BdgCom.h"
 
using namespace std;
 
/*------------------------------------------------------------------------
*                 CONSTRUCTEURS ET DESTRUCTEUR DE LA CLASSE
* Descriptif :
* Fonction permettant de communiquer avec la sonde BDG09.
* Chaque instaance de cette classe représente une nouvelle sonde
*
* Parametres :
* const char *address : Adresse de la sonde
*
* Exemple :
*
*------------------------------------------------------------------------	*/
BdgCom::BdgCom(const char *addr /*=1 par défaut*/)
{
    cout << "Bonjour bdgCom " << endl; //DEBUG
    //address = addr;
 
    chaineRecue = '\0';
 
    //Trame pour le débit de dose :
    strDerQuery = hexToChar('5','5');
    strDerQuery += hexToChar('A','A');
    strDerQuery += hexToChar('7','0');
    strDerQuery += hexToChar(addr[0],addr[1]);
    strDerQuery += hexToChar('0','0');
    strDerQuery += hexToChar('7','1');
    //Taille de la trame à envoyer :
    sizeTrameDerQuery = 6;
 
    //Trame pour le numéro de série :
    strSerialQuery = hexToChar('5','5');
    strSerialQuery += hexToChar('A','A');
    strSerialQuery += hexToChar('7','0');
    strSerialQuery += hexToChar(addr[0],addr[1]);
    strSerialQuery += hexToChar('0','5');
    strSerialQuery += hexToChar('7','6');
    //Taille de la trame à envoyer :
    sizeTrameSerialQuery = 6;
 
    //Trame pour la température de la sonde :
    strTemperatureQuery = hexToChar('5','5');
    strTemperatureQuery += hexToChar('A','A');
    strTemperatureQuery += hexToChar('7','0');
    strTemperatureQuery += hexToChar(addr[0],addr[1]);
    strTemperatureQuery += hexToChar('0','8');
    strTemperatureQuery += hexToChar('7','9');
    //Taille de la trame à envoyer :
    sizeTrameTempQuery = 6;
 
    //Trame pour le changement d'adresse de la sonde :
    strAddressQuery = hexToChar('5','5');
    strAddressQuery += hexToChar('A','A');
    strAddressQuery += hexToChar('7','0');
    strAddressQuery += hexToChar(addr[0],addr[1]);
    strAddressQuery += hexToChar('0','6');
    strAddressQuery += hexToChar('7','7');
    //Taille de la trame à envoyer :
    sizeTrameAddressQuery = 6;
}
 
BdgCom::~BdgCom()
{
    cout << "Quit bdgCom " << endl; //DEBUG
}
 
/*------------------------------------------------------------------------
*                 Méthode de conversion d'une chaine de 2 caractères
*                (représention héxadécimal) en caractére ascii
*
* Exemple : hexToChar('5', '5') --> U
*
* Parametres
*
* Retour :
*------------------------------------------------------------------------	*/
char BdgCom::hexToChar(char first, char second)
{
	char hex[5], *stop;
	hex[0] = '0';
	hex[1] = 'x';
	hex[2] = first;
	hex[3] = second;
	hex[4] = 0;
	return strtol(hex, &stop, 16);
}
 
/*------------------------------------------------------------------------
*                 Fonction d'ouverture du port série
*
* Parametres
* char *port		: "COM1" pour Port1, "COM2" pour port2
* parite            : "Aucune", "Paire", "Impaire"
* vitesse           : 9600, 19200..
* data              : data bit 8...
* stopBit           : 1, 1.5  ou 2
* timeOut           : en ms
*
* Retour : un boolean egal à 0 si erreur.
*------------------------------------------------------------------------	*/
bool BdgCom::openCOMDLL(const char *port,const char *parite,int vitesse,int data,const char *stopBit,int timeOut)
{
    return com.connectCOM(port,parite,vitesse,data,stopBit,timeOut);
}
 
/*------------------------------------------------------------------------
*                 Fonction de fermeture du port série
*
* Retour : un boolean egal à 0 si erreur.
*------------------------------------------------------------------------	*/
bool BdgCom::closeCOMDLL()
{
    return com.closeCOM();
}
 
 
 
/*------------------------------------------------------------------------
*                 Fonction d’écriture sur un port série
*
* Parametres
*  char *chaine	:chaine à envoyer sur le port
*  int nbCharTx	:longueur de la tame envoyé en octet (par défaut 0)
*
* Retour : un entier egal à 0 si erreur.
*------------------------------------------------------------------------	*/
bool BdgCom::writeCOMDLL(const char *chaine,int nbCharTx)
{
    return com.writeCOM(chaine, nbCharTx);
}
 
/*-----------------------------------------------------------------------
* 					Fonction de lecture sur le port série
*
* Retour : une chaine de caractères.
* ----------------------------------------------------------------------*/
 
char* BdgCom::readCOMDLL(int nbCharRx)
{
    return com.readCOM(&chaineRecue, nbCharRx);
}
 
/*------------------------------------------------------------------------
*                 CALCUL CHECKSUM
* Descriptif :
* Fonction permettant de calculer le checksum pour la communication sur port série avec la sonde
* BDG09
* Parametres :
* string chaineRecue
*
* Exemple :
* Checksum sum("55AA70010071");
* bool isGood = sum.calcChecksum();
*
* Retour : 1 si vrai 0 si faux
* ----------------------------------------------------------------------*/
bool BdgCom::checksumdDLL(const string chaine)
{
    bool isGood = false;
    Checksum sum(chaine);
    try
    {
        isGood = sum.calcChecksum();
    }
    catch (const std::exception &e)
    {
        cout << "ERROR ChecksumDLL : " << endl;
        cerr << e.what();
    }
    return isGood;
}
 
/*------------------------------------------------------------------------
*                 DER QUERY
* Descriptif :
* Fonction permettant de récupérer le débit de dose calculé par la sonde
* BDG09
* Parametres :
* char *derResult --> contient la chaine de retour
 
* Retour :
* Chaîne de caractères avec le débit de dose et l'erreur statistique séparés par un point virgule
* ----------------------------------------------------------------------*/
char* BdgCom::derQuery(char *derResult)
{
    const char *query(0);
    char *rep(0); //Réponse (les valeurs de débit de dose, erreur...)
    char *repInit(0); //Réponse Initial 55 AA..
    char *allRep(0); //Réponse entière pour le calcul du checksum
 
    int repSize = 7; //Taille de la trame contenant la réponse à retourner
    int repInitSize = 5; //Taille de la trame contenant le début de la trame
    int allRepSize = 12; //Taille de la trame contenant toute la trame
 
    bool isGood; //Réponse du checksum
    string trameToCheck; //Trame à vérifier (checksum)
 
 
    rep = new char[repSize];
    repInit = new char[repInitSize];
    allRep = new char[allRepSize]; //Taille de la réponse
    query = new char[sizeTrameDerQuery];
 
    rep[repSize] = '\0';
    repInit[repInitSize] = '\0';
    allRep[allRepSize] = '\0';
 
    isGood = false;
    sprintf(derResult,"%s",""); //Initialisation de la variable de retour
    sprintf(rep,"%s",""); //Initialisation de la variable de retour
    sprintf(repInit,"%s",""); //Initialisation de la variable de retour
    sprintf(allRep,"%s",""); //Initialisation de la variable de retour
 
    //On repasse la string en const char*, création de la trame de demande :
    query = strDerQuery.c_str();
 
    com.clrDTR();
    //Demande du DerQuery sur le port série :
    if(writeCOMDLL(query,sizeTrameDerQuery))
    {
        com.setDTR();
        com.purgeClearCOM();
        //---------------------------------------------------------------
        // Lecture de la réponse sur le port série :
        // Vérification du début de la trame : 55 AA 70 ...
        // On cast rep pour la comparaison avec le buffer en "unsigned char" pour aller jusqu'à 0xFF
        //---------------------------------------------------------------
        rep = readCOMDLL(1);
        repInit[0] = rep[0];
        if((unsigned char)repInit[0]==0x55) //55
        {
            rep = readCOMDLL(1);
            repInit[1] = rep[0];
            if((unsigned char)repInit[1]==0xAA) //AA
            {
                rep = readCOMDLL(1);
                repInit[2] = rep[0];
                if((unsigned char)repInit[2]==0x70) //70
                {
                    rep = readCOMDLL(1);
                    repInit[3] = rep[0];
                    if((unsigned char)repInit[3]<0xFF) //Adresse sonde (0 à 255)
                    {
                        rep = readCOMDLL(1);
                        repInit[4] = rep[0];
                        if((unsigned char)repInit[4]==0x01) //Réponse derQuery = 1
                        {
                            rep = readCOMDLL(repSize);
 
                            //-----------------------
                            //Calcul du checksum
                            //-----------------------
                            sprintf(allRep,"%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X",
                                    (unsigned char)repInit[0],(unsigned char)repInit[1],
                                    (unsigned char)repInit[2],(unsigned char)repInit[3],(unsigned char)repInit[4],
                                    (unsigned char)rep[0],(unsigned char)rep[1],
                                    (unsigned char)rep[2],(unsigned char)rep[3],(unsigned char)rep[4],
                                    (unsigned char)rep[5],(unsigned char)rep[6]);
                            trameToCheck.assign(allRep);
                            try
                            {
                                cout << "Trame avant checksum --> "; //DEBUG
                                cout << allRep << endl; //DEBUG
                                isGood = checksumdDLL(trameToCheck);
                            }
                            catch (const std::exception &e)
                            {
                                cout << "ERROR CHECKSUM " << endl;
                                cerr << e.what();
                                //return (0);
                            }
                            sprintf(derResult,"%c%c%c",rep[0],rep[4],'\0');
                        }else
                        {
                            return(0);
                        }
                    }else
                    {
                        return(0);
                    }
                }else
                {
                    return(0);
                }
            }else
            {
                return(0);
            }
        }else
        {
            return(0);
        }
        //---------------------------------------------------------------
        com.clrDTR();
 
        if(query!=NULL)
        {
            cout << "suppression query" << endl;
            query = NULL;
            delete[] query;
        }
        if(repInit!=NULL)
        {
            cout << "suppression repInit" << endl;
            repInit = NULL;
            delete[] repInit;
        }
        if(allRep!=NULL)
        {
            cout << "suppression allRep" << endl;
            allRep = NULL;
            delete[] allRep;
        }
        if(rep!=NULL)
        {
            cout << "suppression rep" << endl;
            rep = NULL;
            delete[] rep;
        }
        cout << "retour der result" << endl;
        return derResult;
    }else{
        return(0);
    }
}
 
...

-->Checksum
Permet de calculer le checksum d'une trame sur le port série :

checksum.h

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
 
#ifndef CHECKSUM_H
#define CHECKSUM_H
 
#include <string>
#include <cstring>
#include <iostream>
#include <sstream>
#include <vector>
#include <math.h>
 
class Checksum
{
    public:
 
        Checksum();
        Checksum(const std::string strChaineRecue);
        virtual ~Checksum();
 
        bool calcChecksum();
 
    protected:
 
        std::string chaine;
        std::string checksum;
 
    private:
 
        std::vector<std::string> cutString(const std::string trame, int n);
};
 
#endif // CHECKSUM_H

checksum.cpp

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
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
 
#include "Checksum.h"
 
using namespace std;
 
/*------------------------------------------------------------------------
*                 CONSTRUCTEURS ET DESTRUCTEUR DE LA CLASSE
* Parametres :
* string chaineRecue
*
* Exemple :
* Checksum sum("55AA70010071");
* bool isGood = sum.calcChecksum();
*------------------------------------------------------------------------	*/
 
Checksum::Checksum(const string strChaineRecue)
{
    chaine = "";
    chaine.assign(strChaineRecue);
    cout << "Dans checksum --> " + chaine << endl; //DEBUG
    //MessageBox(NULL,"BONJOUR","CHECKSUM",MB_OK|MB_ICONEXCLAMATION); //DEBUG
}
 
Checksum::Checksum()
{
    chaine = "";
    checksum = "";
}
 
Checksum::~Checksum()
{
    //MessageBox(NULL,"AU REVOIR","CHECKSUM",MB_OK|MB_ICONEXCLAMATION); //DEBUG
    cout << "Quit checksum " << endl;
}
 
/*------------------------------------------------------------------------
*                 Méthode de calcul du checksum
*
* Parametres :
*
* Retour : un boolean egal à 0 si erreur.
*------------------------------------------------------------------------	*/
bool Checksum::calcChecksum()
{
    int i = 0;
    int nbEssai = 0; //Nombre de boucles max pour calculer le checksum
    int tmpHex = 0;//
    int sumHex = 0; //Somme en hexa
    int verifSum = 0; //Checksum a vérifier (dernier octet)
    int lastOctet = 0; // Dernier octet envoyé (Checksum)
    bool endCalc = false; //Booléen indiquenat le fin du calcul
    int tailleVector = 0;
    ostringstream oss; //Flux de sortie
    string result = "";
    vector<string> vChaineToCalc; //Chaine à calculer le checksum
 
    // réserver (allouer) de la place pour au moins n éléments
    vChaineToCalc.reserve(chaine.size());
 
    //Vérification que la chaine est un nombre pair : Si result = 721 alors on met result = 0721 (Pour le calcul de la somme des octets)
    if((chaine.size() % 2) == 0){
        // nb pair, on ne fait rien
    }else{
         // nb impair, on ajoute un 0 au début
         chaine = "0" + chaine;
    }
 
    //Découpe la chaine par paire de lettre :
    //vChaineToCalc = cutString(chaine, 2);
    vChaineToCalc = cutString(chaine, 2);
    /*---------------------------------------------------------------------*/
    // On recherche le checkum dans la trame (dernier octet)
    /*---------------------------------------------------------------------*/
    tailleVector = vChaineToCalc.size(); //Taille de la trame
    if(tailleVector>0){
        lastOctet = tailleVector - 1; //Indice du dernier octet (Checksum)
    }else{
        lastOctet = tailleVector; //Indice du dernier octet (Checksum)
    }
 
    /*---------------------------------------------------------------------*/
    // Conversion string -> hexa de l'octet du checksum
    /*---------------------------------------------------------------------*/
    //cout << lastOctet << endl; //DEBUG
    //cout << vChaineToCalc.at(lastOctet) << endl; //DEBUG
 
    stringstream iss(vChaineToCalc.at(lastOctet));
    iss >> hex >> verifSum;
    iss.clear(); //Vide le buffer
 
    /*---------------------------------------------------------------------*/
 
    /*---------------------------------------------------------------------*/
    // Conversion string -> hexa + calcul de la somme des octets sans l'octet du checksum
    /*---------------------------------------------------------------------*/
 
    for(i=0; i < tailleVector - 1; i++)
    {
        stringstream iss(vChaineToCalc.at(i));
        iss >> hex >> tmpHex;
        sumHex += tmpHex;
        iss.clear(); //Vide le buffer
    }
 
    /*---------------------------------------------------------------------*/
 
    while(endCalc == false)
    {
        //Si le nombre est sur plus de 1 octet (FF) on recalcul la somme des octets restant
        if(sumHex > 255)
        {
            // On incrémente le nombre d'essai
            nbEssai++;
            if(nbEssai>5)
            {
                return 0; //ERREUR
            }
 
            // écrire un nombre dans le flux
            oss << hex << sumHex;
            result = oss.str();
            oss.clear(); // Vide le buffer
 
            //Vérification que le résulat est un nombre pair : Si result = 721 alors on met result = 0721 (Pour le calcul de la somme des octets)
            if ((result.length() % 2) == 0){
                // nb pair, on ne fait rien
            } else {
                 // nb impair, on ajoute un 0 au début
                 result = "0" + result;
            }
            //vChaineToCalc.clear();
            vChaineToCalc = cutString(result, 2);
            //On réinitialise sumHex :
            sumHex = 0;
 
            /*---------------------------------------------------------------------*/
            // Conversion string -> hexa + calcul de la somme des octets
            /*---------------------------------------------------------------------*/
            tailleVector = vChaineToCalc.size();
            for(i=0; i < tailleVector; i++)
            {
                stringstream iss(vChaineToCalc.at(i));
                iss >> hex >> tmpHex;
                sumHex += tmpHex;
                iss.clear(); //Vide le buffer
            }
 
        }
        else
        {
            endCalc = true;
        }
    }
 
    //cout << sumHex << endl; //DEBUG
    //cout << verifSum << endl; //DEBUG
 
    //Vérification si la somme est bien égal au checksum envoyé :
    if(sumHex == verifSum && sumHex != 0)
    {
        cout << "CHECKSUM VALIDE" << endl; //DEBUG
        return (1); //CHEKSUM VALIDE
    }
    else
    {
        cout << "CHECKSUM NON VALIDE" << endl; //DEBUG
        return (0); //CHEKSUM INVALIDE
    }
}
 
/*------------------------------------------------------------------------
*                 Méthode de découpage d'une chaine de caractères
*
* Parametres
* int n 		    : Intervalle entre les découpages
*
* Retour : un vecteur de string avec la trame où il faut calculer le checksum
*------------------------------------------------------------------------	*/
vector<string> Checksum::cutString(const string trame, int n)
{
    unsigned int k;
    vector<string> vectChaine;
 
    k=0;
    vectChaine.reserve(trame.size());
 
    //Vérification si la taille de la trame est paire :
    if((trame.size() % 2) == 0)
    {
        for(k=0; k < trame.size() - 1; k+=n)
        {
            cout << "cutString --> 0x" + trame.substr(k, n) << endl; //DEBUG
            vectChaine.push_back("0x" + trame.substr(k, n));
            //vectChaine.push_back("0x00");
        }
    }
    return vectChaine;
}

26/05/2011, 19h33
Lucien63
Code:

1 2 3 4 5 rep = new char[repSize]; //... rep[repSize] = '\0';
Ton tableau va de 0 à repSize-1
rep[repSize] est en dehors de ton tableau, tu ecris donc en dehors de ton tableau

IDEM pour repInit et allRep

Pff... Honte sur moi.. :oops:
Je changerai ça demain matin, je n'ai plus la sonde sous le coude pour tester.
Par contre ça c'est un truc que j'ai ajouté dernièrement ne sachant quoi faire pour trouver mon bug... Je vous direz demain.
En tout cas merci pour vos réponses et pour l'utilitaire très bien (Quand je regarde mes anciennes versions de code j'ai effectivement des erreurs de pointeur non initilalisés).. Ce qui est bizarre c'est que ça plante pas au premier tour de boucle...

Mon code pour tester la librairie :
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 #include <iostream> #include <sstream> #include <stdio.h> #include <stdlib.h> #include <windows.h> using namespace std; int main(int argc, char *argv[]) { HINSTANCE DLLHandle; DLLHandle = LoadLibrary("bdglib_win.dll"); typedef bool(*Type_Pointeur_De_Fonction3)(); Type_Pointeur_De_Fonction3 openCom; openCom = (Type_Pointeur_De_Fonction3)GetProcAddress(DLLHandle,"openCOMDLL"); typedef bool(*Type_Pointeur_De_Fonction4)(); Type_Pointeur_De_Fonction4 closeCom; closeCom = (Type_Pointeur_De_Fonction4)GetProcAddress(DLLHandle,"closeCOMDLL"); typedef char*(*Type_Pointeur_De_Fonction1)(); Type_Pointeur_De_Fonction1 ded; ded = (Type_Pointeur_De_Fonction1)GetProcAddress(DLLHandle,"derQueryDLL"); typedef char*(*Type_Pointeur_De_Fonction2)(); Type_Pointeur_De_Fonction2 serial; serial = (Type_Pointeur_De_Fonction2)GetProcAddress(DLLHandle,"serialQueryDLL"); //char *recuNum; char *recuDed; int i=0; openCom(); /* recuNum = serial(); cout << "No SERIE ----> "; cout << recuNum << endl; */ while(i<100) { cout << "BOUCLE ----> "; cout << i << endl; recuDed = ded(); cout << "DED ----> "; cout << recuDed << endl; i++; cout.clear(); } //closeCom(); //printf("Appuyez sur une touche pour continuer..."); //getchar(); FreeLibrary(DLLHandle); return 0; }
Le problème reste le même (Crash ntdll)..:cry:
Par contre si je "court-circuite" le calcul du checksum en commentant la ligne

Code:

isGood = sum.calcChecksum();

dans BdgCom.cpp le programme ne plante plus. :calim2:
Par contre si je teste la classe checksum indépendamment du reste, elle fonctionne très bien...
Dans tous les cas j'ai pu observer dans le gestionnaire des tâches que j'ai une "fuite mémoire" car l'utilisation mémoire du programme augmente... Doucement mais constamment !

On va régler les problèmes dans l'ordre. Tu as en effet une belle fuite, il suffit de lire le code pour la voir. Tu as bien pensé à détruire tes tableaux... mais à l'intérieur du if. Du coup, si la condition n'est pas remplie et que tu ne rentres pas dans le if, les tableaux ne sont pas détruits -> fuite.

Cela vient du fait que tu utilises des tableaux dynamique en C++ pur. Un peu dangereux pour un débutant. Vu la taille de tes tableaux, et puisque qu'elle est fixe, je t'invite à adopter plutôt une allocation sur le tas :
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 void initialiser_tableau_de_char(char tableau[], size_t taille) { for(size_t i = 0; i < taille ; i++) tableau[i] = 'a'; // <- Choix complètement arbitraire } int _tmain(int argc, _TCHAR* argv[]) { const size_t repSize = 7; //Taille de la trame contenant la réponse à retourner const size_t repInitSize = 5; //Taille de la trame contenant le début de la trame const size_t allRepSize = 12; char rep[repSize]; //Réponse (les valeurs de débit de dose, erreur...) initialiser_tableau_de_char(rep,repSize); char repInit[repInitSize]; //Réponse Initial 55 AA.. initialiser_tableau_de_char(repInit,repInitSize); char allRep[allRepSize]; //Réponse entière pour le calcul du checksum initialiser_tableau_de_char(allRep,allRepSize); return 0; }
De cette manière, tu n'auras pas à détruire tes tableaux, ils le seront dès que l'exécution sortira du scope où ils se trouvent. Ca va t'éviter d'aller sur le terrain glissant des pointeurs, pour un gain nul en l'occurrence.

Sinon, tu peux aussi t'orienter vers l'utilisation de std::vector.

27/05/2011, 14h52
krapo13

Salut jblecanard. :ccool:
Le souci c'est que lorsque je lit sur le port série :

Code:

rep = readCOMDLL(1);

Cela me renvoie un char*.

C'est pour ça que j'ai malheureusement utilisé ce type de données. Ma communication sur le port série fonctionne bien, j'aimerais si possible ne pas la modifier (là actuellement j'utilise la bibliothèque windows pour communiquer sur le port série et je prends ce qu'elle me renvoie)...
Sinon peut-on convertir facilement du char* vers char ??

Je comprend encore mieux la fuite !

La fonction alloue elle même le résultat qu'elle t'envoie et du coup, le tableau que tu as alloué part dans les choux ! Pire, le delete risque de partir au tas aussi. Tu n'utilises pas rep et readCOM correctement. Là j'ai une réunion mais je t'explique comment faire en revenant.

Re

Alors on va reprendre un peu le code de la fonction concernée. Je te met mes corrections (non testées), il y a peut être de légères erreurs et je t'explique.

Tout d'abord, le coeur du problème, le fameux rep. Ton erreur relève d'une incompréhension du fonctionnement des pointeurs. En effet, quand tu appelle readCOMDLL, celle-ci te renvoie un pointeur vers une zone mémoire qu'elle a elle même allouée. Ton pointeur ne contient plus l'adresse renvoyé par ton "new", et cette zone est donc perdue. Pour corriger cela, il ne faut pas allouer rep mais laisser la fonction le faire, et ne pas oublier de faire le ménage derrière. Par contre, on ne sait pas comment cette mémoire est allouée, c'est la documentation de la fonction qui le dira. Comme c'est une fonction C, je pense que la mémoire est allouée par malloc, et il faut donc la libérer avec free. C'est peut être une hypothèse sur laquelle il faudra revenir.

Il faut aussi rallonger les tableaux pour accueillir le '\0'.

J'ai transformé tes cast C-Style en casts C++.

J'ai viré ta série de "else" inutile. Voir la technique avec le code de retour.

Je remarque quand dans ton implémentation, derResult n'est jamais lu avant d'être écrit. Son passage en argument est donc inutile.

Je pense également que la série de if n'est pas utile et qu'un seul appel bien senti à readCOMDLL devrait suffire.

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
108
109
110
111
char* BdgCom::derQuery(char *derResult)
{
  char * retour = NULL; // <- Tu va voir il est important pour l'élégance
 
  const size_t repSize = 7; //Taille de la trame contenant la réponse à retourner
  const size_t repInitSize = 6; //Taille de la trame contenant le début de la trame
  const size_t allRepSize = 13; //Taille de la trame contenant toute la trame
 
  const char *query = NULL;
  char *rep = NULL; //Réponse (les valeurs de débit de dose, erreur...)
  char repInit[repInitSize]; //Réponse Initial 55 AA..
  char allRep[allRepSize]; //Réponse entière pour le calcul du checksum
 
  bool isGood; //Réponse du checksum
  string trameToCheck; //Trame à vérifier (checksum)
 
  repInit[repInitSize - 1] = '\0'; // -1 très important ici et ne pas oublier que ce '\0' occupe une place !
  allRep[allRepSize - 1] = '\0'; // -1 très important ici
 
  isGood = false;
 
  // Je sais pas ce que faisais ce code mais sûrement rien d'utile. De plus sprintf c'est du C
  /* sprintf(derResult,"%s",""); //Initialisation de la variable de retour
  sprintf(rep,"%s",""); //Initialisation de la variable de retour
  sprintf(repInit,"%s",""); //Initialisation de la variable de retour
  sprintf(allRep,"%s",""); //Initialisation de la variable de retour*/
 
  //On repasse la string en const char*, création de la trame de demande :
  query = strDerQuery.c_str(); // la mémoire sera libérée par strDerQuery, on s'en préoccupe pas
 
  com.clrDTR();
  //Demande du DerQuery sur le port série :
  if(writeCOMDLL(query,sizeTrameDerQuery))
  {
    com.setDTR();
    com.purgeClearCOM();
    //---------------------------------------------------------------
    // Lecture de la réponse sur le port série :
    // Vérification du début de la trame : 55 AA 70 ...
    // On cast rep pour la comparaison avec le buffer en "unsigned char" pour aller jusqu'à 0xFF
    //---------------------------------------------------------------
    rep = readCOMDLL(1);
    if(rep && 0x55 == static_cast<unsigned char>(*rep))
    {
      repInit[0] = *rep;
      free(rep);
 
      rep = readCOMDLL(1);
      if(rep && 0xAA == static_cast<unsigned char>(*rep))  
      {
        repInit[1] = *rep;
        free(rep);
 
        rep = readCOMDLL(1);
        if(rep && 0x70 == static_cast<unsigned char>(*rep))
        {
          repInit[2] = *rep;
          free(rep);
 
          rep = readCOMDLL(1);
          if(rep && 0xFF > static_cast<unsigned char>(*rep))
          {
            repInit[3] = *rep;
            free(rep);
 
            rep = readCOMDLL(1);
            if(rep && 0x01 == static_cast<unsigned char>(*rep) )
            {
              repInit[4] = *rep;
              free(rep);
 
              rep = readCOMDLL(repSize);
              if(rep)
              {
                //-----------------------
                //Calcul du checksum
                //-----------------------
                sprintf(allRep,"%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X",
                  (unsigned char)repInit[0],(unsigned char)repInit[1],
                  (unsigned char)repInit[2],(unsigned char)repInit[3],(unsigned char)repInit[4],
                  (unsigned char)rep[0],(unsigned char)rep[1],
                  (unsigned char)rep[2],(unsigned char)rep[3],(unsigned char)rep[4],
                  (unsigned char)rep[5],(unsigned char)rep[6]);
                trameToCheck.assign(allRep);
                try
                {
                  cout << "Trame avant checksum --> "; //DEBUG
                  cout << allRep << endl; //DEBUG
                  isGood = checksumdDLL(trameToCheck);
                }
                catch (const std::exception &e)
                {
                  cout << "ERROR CHECKSUM " << endl;
                  cerr << e.what();
                  //return (0);
                }
                sprintf(retour,"%c%c%c",rep[0],rep[4],'\0');
 
                free(rep);
                rep = NULL;
              }
            }
          }
        }
      }
    }
    com.clrDTR();
  }
 
  return retour;
}

Je n'ai pas testé le code mais je t'ai donné les clés pour le corriger (normalement). Bon courage et n'hésite pas à poser des questions (j'ai pas le temps de détailler plus mais je pourrais le faire plus tard).

27/05/2011, 18h05
krapo13

Merci pour cette réponse très constructive, j'ai un peu mieux compris certaine zone obscur du monde des pointeurs:mouarf:..
Ça bug sur le free(), la mémoire ne doit pas être alloué comme tu l'as dit.
J'ai peut être fait n'importe quoi,lorsque je lis sur le port série je fais

Code:

return com.readCOM(&chaineRecue, nbCharRx);

où chaine reçu est une variable de classe de la classe BdgCom...8O

En tout cas merci !
27/05/2011, 18h08
jblecanard

Hum d'accord je regarderais ça dès que j'ai l'occaze, là c'est le week end, tu devrais y aller aussi :mrgreen:
27/05/2011, 18h08
krapo13

Citation:

Envoyé par jblecanard

Hum d'accord je regarderais ça dès que j'ai l'occaze, là c'est le week end, tu devrais y aller aussi :mrgreen:

Merci et bon week end !
27/05/2011, 18h09
Lucien63
Dans ton code d'origine :
Code:

1 2 rep = NULL; delete[] rep;
Tu mettais le pointeur à NULL avant le delete !

La tu delete un pointeur null mais surement pas le bloc à liberer.
30/05/2011, 11h41
jblecanard
Essaye de faire tourner le bousin sans les free. Ca fera peut être une fuite de mémoire, mais au moins tu verras si ça plante ou pas.

Citation:

Envoyé par krapo13

J'ai peut être fait n'importe quoi,lorsque je lis sur le port série je fais

Code:

return com.readCOM(&chaineRecue, nbCharRx);

où chaine reçu est une variable de classe de la classe BdgCom...8O

Pour t'aider sur ce point, il faudrait nous montrer le header SerialPort.h, éventuellement le code mais je suppose que tu ne l'as pas et que tu linkes sur une librairie.
Citation:
Envoyé par Lucien63

Dans ton code d'origine :

Code:

1 2 rep = NULL; delete[] rep;

Tu mettais le pointeur à NULL avant le delete !
Exact très grosse erreur mais qui provoque une fuite de mémoire et pas un crash normalement.

Salut !
Alors ça y'est, je n'ai plus de problèmes de crash même en release...
Je me suis inspiré de ce jblecanard à fait... Au début j'avais toujours les crash ntdll je me suis inspiré de la variable query en créant une variable strRep de type string et en mettant la variable rep en const char * et en faisant :

Code:

rep = strRep.c_str();

Si j'ai bien compris, lorsqu'on va sortir de la méthode, rep sera supprimé...:calim2:
Du moment que j'ai fait ça plus de souci, même avec le calcul du checksum...

Le code :

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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
 
char* BdgCom::derQuery(char *derResult)
{
    const size_t repSize = 8; //Taille de la trame contenant la réponse à retourner
    const size_t repInitSize = 6; //Taille de la trame contenant le début de la trame
    const size_t allRepSize = 13; //Taille de la trame contenant toute la trame
 
    char* retour = NULL; // <- Tu va voir il est important pour l'élégance
    retour = new char(allRepSize);
    const char* query = NULL;
    const char *rep = NULL; //Réponse (les valeurs de débit de dose, erreur...)
    char repInit[repInitSize]; //Réponse Initial 55 AA..
    char allRep[allRepSize]; //Réponse entière pour le calcul du checksum
 
    bool isGood; //Réponse du checksum
    string trameToCheck; //Trame à vérifier (checksum)
    string strRep;
 
    trameToCheck.assign("");
    strRep.assign("");
 
    repInit[repInitSize - 1] = '\0'; // -1 très important ici et ne pas oublier que ce '\0' occupe une place !
    allRep[allRepSize - 1] = '\0'; // -1 très important ici
 
    isGood = false;
 
    //On repasse la string en const char*, création de la trame de demande :
    query = strDerQuery.c_str(); // la mémoire sera libérée par strDerQuery, on s'en préoccupe pas
    rep = strRep.c_str();
 
    com.clrDTR();
    //Demande du DerQuery sur le port série :
    if(writeCOMDLL(query,sizeTrameDerQuery))
    {
        com.setDTR();
        com.purgeClearCOM();
        //---------------------------------------------------------------
        // Lecture de la réponse sur le port série :
        // Vérification du début de la trame : 55 AA 70 ...
        // On cast rep pour la comparaison avec le buffer en "unsigned char" pour aller jusqu'à 0xFF
        //---------------------------------------------------------------
        rep = readCOMDLL(1);
        if(rep && 0x55 == static_cast<unsigned char>(*rep))
        {
            repInit[0] = *rep;
            rep = NULL;
            delete[] rep;
 
            rep = readCOMDLL(1);
            if(rep && 0xAA == static_cast<unsigned char>(*rep))
            {
                repInit[1] = *rep;
                rep = NULL;
                delete[] rep;
 
                rep = readCOMDLL(1);
                if(rep && 0x70 == static_cast<unsigned char>(*rep))
                {
                    repInit[2] = *rep;
                    rep = NULL;
                    delete[] rep;
 
                    rep = readCOMDLL(1);
                    if(rep && 0xFF > static_cast<unsigned char>(*rep))
                    {
                        repInit[3] = *rep;
                        rep = NULL;
                        delete[] rep;
 
                        rep = readCOMDLL(1);
                        if(rep && 0x01 == static_cast<unsigned char>(*rep) )
                        {
                            repInit[4] = *rep;
                            rep = NULL;
                            delete[] rep;
 
                            rep = readCOMDLL(repSize - 1);
 
                            if(rep)
                            {
                                //-----------------------
                                //Calcul du checksum
                                //-----------------------
 
                                sprintf(retour,"%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X",
                                (unsigned char)repInit[0],(unsigned char)repInit[1],
                                (unsigned char)repInit[2],(unsigned char)repInit[3],(unsigned char)repInit[4],
                                (unsigned char)rep[0],(unsigned char)rep[1],
                                (unsigned char)rep[2],(unsigned char)rep[3],(unsigned char)rep[4],
                                (unsigned char)rep[5],(unsigned char)rep[6]);
 
                                trameToCheck.assign(retour);
                                try
                                {
                                    cout << "Trame avant checksum --> "; //DEBUG
                                    cout << retour << endl; //DEBUG
                                    isGood = checksumdDLL(trameToCheck);
                                }
                                catch (const std::exception &e)
                                {
                                    cout << "ERROR CHECKSUM " << endl;
                                    cerr << e.what();
                                }
 
                                sprintf(retour,"%02X%c%02X%c",(unsigned char)rep[0],'_',(unsigned char)rep[4],'\0');
                                cout << "DED dans BDgCom --> "; //DEBUG
                                cout << retour << endl; //DEBUG
                                rep = NULL;
                                delete[] rep;
                            }
                        }
                    }
                }
            }
        }
    }
    if(rep != NULL)
    {
        rep = NULL;
        delete[] rep;
    }
    com.clrDTR();
    return retour;
}

J'ai la classe SerialPort, je l'ai trouvé sur un autre site et je l'ai un peu adapté.
Sinon j'ai oublié de dire, j'ai toujours une petite fuite mémoire, mais ça viens surement d'un autre endroit du code... En tout cas cela ne crash plus !

le .h :

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
 
#ifndef SerialPort_H
#define SerialPort_H
 
#include <windows.h>
#include <iostream>
#include <stdio.h>
 
class SerialPort
{
    public:
        SerialPort();
        SerialPort(DWORD rx, DWORD tx, int sizeRxMax, int sizeTxMax);
        virtual ~SerialPort();
 
        bool connectCOM(const char *port,const char *parite,int vitesse,int data,const char *stopBit,int timeOut);
        bool closeCOM();
        bool writeCOM(const char *chaine,int nbCharTx=0); //Chaine à envoyer + taille de la chaine
        char* readCOM(char *chaineRecue, int nbCharRx=0);
        bool purgeClearCOM();
        bool purgeAbortCOM();
        bool purgeAllCOM();
        bool clrDTR();
        bool setDTR();
 
    private:
        DCB dcb;						// déclarer une variable contenant la configuration du port
        HANDLE hCom;					// déclarer un handle
        COMMTIMEOUTS tTimeout;          //Temps de latence
        bool fWaitingOnRead;
        DWORD rxBuffer;                 //Taille du buffer d'entrée en octets
        DWORD txBuffer;                 //Taille du buffer de sortie en octets
        int sizeMsgRx;                  //Taille du message à recevoir en nb de caractères
        int sizeMsgTx;                  //Taille du message à envoyer en nb de caractères
};
 
#endif // SerialPort_H

le .cpp :

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
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
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
 
#include "SerialPort.h"
 
using namespace std;
 
/*------------------------------------------------------------------------
*                 CONSTRUCTEURS ET DESTRUCTEUR DE LA CLASSE
* Parametres
* DWORD rx		    : Taille du buffer de reception
* DWORD tx          : Taille du buffer d'emission
* int sizeRx        : Nombre de caractères du message de reception
* int sizeTx        : Nombre de caractères du message d'emission
*------------------------------------------------------------------------	*/
SerialPort::SerialPort()
{
    fWaitingOnRead = false;
    rxBuffer = 4096;
    txBuffer = 4096;
    sizeMsgRx = 4096;
    sizeMsgTx = 4096;
    //MessageBox(NULL,"BONJOUR","SERIAL",MB_OK|MB_ICONEXCLAMATION);
}
 
SerialPort::SerialPort(DWORD rx, DWORD tx, int sizeRxMax, int sizeTxMax)
{
    fWaitingOnRead = false;
    rxBuffer = rx;
    txBuffer = tx;
    sizeMsgRx = sizeRxMax;
    sizeMsgTx = sizeTxMax;
    //MessageBox(NULL,"BONJOUR","SERIAL",MB_OK|MB_ICONEXCLAMATION); //DEBUG
}
 
SerialPort::~SerialPort()
{
    if(hCom!=NULL)
    {
        //MessageBox(NULL,"AU REVOIR, hcom not null","SERIAL",MB_OK|MB_ICONEXCLAMATION); //DEBUG
        purgeAllCOM();
        closeCOM();
    }
    //MessageBox(NULL,"AU REVOIR hcom null","SERIAL",MB_OK|MB_ICONEXCLAMATION); //DEBUG
}
 
 
/*------------------------------------------------------------------------
*                 Fonction d'ouverture du port SerialPort
*
* Parametres
* char *port		: "COM1" pour Port1, "COM2" pour port2
* parite            : "Aucune", "Paire", "Impaire"
* vitesse           : 9600, 19200..
* data              : data bit 8...
* stopBit           : 1, 1.5  ou 2
* timeOut           : Temps avant d'arrêter le process de communication au bout de x (ms)
*
* Retour : un boolean egal à 0 si erreur.
*------------------------------------------------------------------------	*/
bool SerialPort::connectCOM(const char *port,const char *parite,int vitesse,int data,const char *stopBit,int timeOut)
{
    cout << "Ouverture port (serial) : " << endl; //DEBUG
    DWORD dwError;					// n° de l’erreur
	bool fSuccess;					// tout c’est bien passé
 
	/*--------------------------------------------------------*/
	/*                 Ouverture du port de Com               */
	/*--------------------------------------------------------*/
	hCom = CreateFile(
		port,                         	// Choix du port « COMx »
		GENERIC_READ | GENERIC_WRITE, 	// accès pour lire et écrire sur le port
		0,                            	// accès exclusif au port de COM
		NULL,                         	// sécurité par défaut
		OPEN_EXISTING,                	//Doit être à cette valeur car se n’est pas un fichier
		0,			                    //FILE_FLAG_OVERLAPPED,
		NULL);							// mode synchrone
 
	/*-----------------------------------------------------------*/
	/*         Vérifier si handle ouvert correctement            */
	/*-----------------------------------------------------------*/
	if (hCom == INVALID_HANDLE_VALUE)
    {
        dwError = GetLastError();
        MessageBox(NULL,"Erreur lors de l'ouverture du port","ERREUR",MB_OK|MB_ICONEXCLAMATION);
        closeCOM();
    }
 
	/*-----------------------------------------------------------*/
	/* Lecture Configuration initiale                            */
	/*-----------------------------------------------------------*/
	fSuccess = GetCommState(hCom, &dcb);
 
	if (!fSuccess)
    {
        MessageBox(NULL,"Erreur lors de la configuration du port","ERREUR",MB_OK|MB_ICONEXCLAMATION);
		closeCOM();
    }
 
	/*-------------------------------------------------------------------*/
	/* 					Configuration du port                            */
	/*-------------------------------------------------------------------*/
	// Gestion de la vitesse
	dcb.BaudRate = vitesse;
 
	// Gestion du nombre de bits
	dcb.ByteSize = data;
 
	// Gestion de la parité
	if (strcmp(parite,"Aucune")==0)
		dcb.Parity = NOPARITY;
 
	if (strcmp(parite,"Paire")==0)
		dcb.Parity = EVENPARITY;
 
	if (strcmp(parite,"Impaire")==0)
		dcb.Parity = ODDPARITY;
 
	//Gestion du Stop Bit
	if (strcmp(stopBit,"2")==0)
		dcb.StopBits = TWOSTOPBITS;
 
	else if (strcmp(stopBit,"1.5")==0)
		dcb.StopBits = ONE5STOPBITS;
 
	else
		dcb.StopBits = ONESTOPBIT;
 
    dcb.fParity=TRUE;
    dcb.fBinary=TRUE; //Autoriser le binaire et pas seulement l'ascii, no EOF check
    dcb.fNull=FALSE; //Autoriser l'octet 0x00
    dcb.fErrorChar=FALSE;
    dcb.fAbortOnError=FALSE; // 1 --> Arrêt si erreur
    dcb.fInX=FALSE;
    dcb.fOutX=FALSE;
    dcb.fOutxCtsFlow=FALSE;
    dcb.fOutxDsrFlow=FALSE;
    dcb.fDsrSensitivity=FALSE;
    dcb.fTXContinueOnXoff=TRUE;
    dcb.fRtsControl=RTS_CONTROL_ENABLE;
    dcb.fDtrControl=DTR_CONTROL_ENABLE;
 
	 /*----------------------------------*/
	 /*    Définition des timeouts       */
	 /*----------------------------------*/
	tTimeout.ReadIntervalTimeout = 20; //Temps en ms en entrée entre 2 caractères
	tTimeout.ReadTotalTimeoutMultiplier = 0;
	tTimeout.ReadTotalTimeoutConstant = timeOut; // pas de time out = 0
	tTimeout.WriteTotalTimeoutMultiplier = 0;
	tTimeout.WriteTotalTimeoutConstant = 0;
 
	// affectation taille des tampons d'émission et de réception
    SetupComm(hCom,rxBuffer,txBuffer);
 
	/*-----------------------------------------------*/
	/* Configurer le port	                          */
	/*-----------------------------------------------*/
	/* configuration du port COM */
    if(!SetCommTimeouts(hCom, &tTimeout) || !SetCommState(hCom, &dcb))
    {
        MessageBox(NULL,"Erreur lors de la configuration du port","ERREUR",MB_OK|MB_ICONEXCLAMATION);
        closeCOM();
        return false;
    }else
    {
        fSuccess = true;
    }
 
	if(fSuccess)
	{
        /* on vide les tampons d'émission et de réception, mise à 1 DTR */
        purgeAllCOM();
        setDTR();
        return fSuccess;
	}else{
        MessageBox(NULL,"Erreur lors de la configuration du port","ERREUR",MB_OK|MB_ICONEXCLAMATION);
        closeCOM();
        return false;
	}
}
 
/*------------------------------------------------------------------------
*                 Fonction de fermeture du port SerialPort
*
* Retour : un boolean egal à 0 si erreur.
*------------------------------------------------------------------------	*/
bool SerialPort::closeCOM()
{
    cout << "Fermeture port (serial) : " << endl; //DEBUG
    /* fermeture du port COM */
    if(hCom!=NULL)
    {
        CloseHandle(hCom);
    }
    return true;
}
 
/*------------------------------------------------------------------------
*                 Fonction d’écriture sur un port SerialPort
*
* Parametres
*  char *chaine	:chaine à envoyer sur le port
*  int nbCharTx	:longueur de la tame envoyé en octet (par défaut 0)
*
* Retour : un entier egal à 0 si erreur.
*------------------------------------------------------------------------	*/
bool SerialPort::writeCOM(const char *chaine, int nbCharTx)
{
	BOOL fSuccess = false;
	unsigned long nBytesWrite;
 
	//Cas ou nbCharTx n'est pas renseigné :
	if(nbCharTx==0)
	{
	    nbCharTx = sizeof(chaine);
	}
 
	// écrire dans le fichier
	fSuccess = WriteFile(hCom,chaine,nbCharTx,&nBytesWrite,NULL);
 
	return fSuccess;
}
 
/*-----------------------------------------------------------------------
* 					Fonction de lecture sur le port série
*
* Parametres
* char *chaineRecue	: chaine recu sur le port
*
* Retour : une chaine de caractères
* ----------------------------------------------------------------------*/
char* SerialPort::readCOM(char *chaineRecue, int nbCharRx)
{
	BOOL fSuccess = false;
	BOOL bResult = false;
	unsigned long nBytesRead;
	char *inBuffer;
 
	//Cas ou nbCharRx n'est pas renseigné :
	if(nbCharRx<1)
	{
	    nbCharRx = sizeMsgRx;
	}
 
	/*-------------------------------------*/
	/* Initialisation des variables        */
	/*-------------------------------------*/
	inBuffer = NULL;
	inBuffer  = new char[nbCharRx+1]; // réservation mémoire pour le buffer de réception
	sprintf(inBuffer,"%s","");
	nBytesRead=0;
 
	/*-------------------------------------------------------------*/
	/* boucle d'attente de lecture des octets                      */
	/* Sortie de la boucle par timeout par exemple, si             */
	/* l’on suppose le format de la trame reçu est               */
	/* variable.                                                   */
	/*-------------------------------------------------------------*/
    if(!fWaitingOnRead)
    {
        bResult = ReadFile(hCom,inBuffer,nbCharRx,&nBytesRead,NULL);
        if(!bResult)
        {
            if (GetLastError() != ERROR_IO_PENDING)     // read not delayed?
                MessageBox(NULL,"Erreur lors de la lecture du buffer...","ERREUR",MB_OK|MB_ICONEXCLAMATION); //DEBUG
            else
                fWaitingOnRead = true;
        }
        fSuccess = true;
    }
	inBuffer[nBytesRead] = '\0';
 
    //sprintf(chaineRecue,"%s",inBuffer);
    // Copie du buffer dans la variable de retour
    for(int i=0; i<=nbCharRx; i++)
    {
        chaineRecue[i] = inBuffer[i];
    }
 
	// Libérer la mémoire
	inBuffer = NULL;
	delete[] inBuffer;
 
	return chaineRecue;
}
 
 
/*-----------------------------------------------------------------------
* 					Fonction de puge du port série (rxclear et txclear)
*
* Efface le tampon d'entrée et sortie
*
*
* Retour : un entier egal à 0 si erreur.
* ----------------------------------------------------------------------*/
bool SerialPort::purgeClearCOM()
{
    bool purge = false;
 
    if(hCom==NULL)
    {
        return false;
    }
    // flush the port
    purge = PurgeComm(hCom, PURGE_RXCLEAR | PURGE_TXCLEAR);
    return purge;
}
 
/*-----------------------------------------------------------------------
* 					Fonction de puge du port série (rxabort et txabort)
*
* Termine toutes les opérations de lecture/écriture en circulation
* même si les opérations de lecture/écriture n'ont pas été achevées.
*
*
* Retour : un entier egal à 0 si erreur.
* ----------------------------------------------------------------------*/
bool SerialPort::purgeAbortCOM()
{
    bool purge = false;
 
    if(hCom==NULL)
    {
        return false;
    }
    // flush the port
    purge = PurgeComm(hCom, PURGE_RXABORT | PURGE_TXABORT);
    return purge;
}
 
/*-----------------------------------------------------------------------
* 					Fonction de puge du port série
*
* Efface le tampon et termine les opérations de lecture/écriture
*
* Retour : un entier egal à 0 si erreur.
* ----------------------------------------------------------------------*/
bool SerialPort::purgeAllCOM()
{
    bool purge = false;
 
    if(hCom==NULL)
    {
        return false;
    }
    // flush the port
    purge = PurgeComm(hCom, PURGE_RXABORT | PURGE_TXABORT | PURGE_RXCLEAR | PURGE_TXCLEAR);
    return purge;
}
 
/*-----------------------------------------------------------------------
* 					Fonction de d'effacememt du DTR(Data Terminal Ready)
*
*
* Retour : un entier egal à 0 si erreur.
* ----------------------------------------------------------------------*/
bool SerialPort::clrDTR()
{
    bool clr = false;
 
    if(hCom==NULL)
    {
        return false;
    }
    clr = EscapeCommFunction(hCom,CLRDTR);
    return clr;
}
 
/*-----------------------------------------------------------------------
* 					Fonction de d'envoie du DTR(Data Terminal Ready)
*
*
* Retour : un entier egal à 0 si erreur.
* ----------------------------------------------------------------------*/
bool SerialPort::setDTR()
{
    bool set = false;
 
    if(hCom==NULL)
    {
        return false;
    }
    set = EscapeCommFunction(hCom,SETDTR);
    return set;
}

Hello !

Alors là... ça ne va pas du tout :mrgreen: J'ai compris pourquoi ça marche et c'est du hasard et de la chance. Ton code n'est pas écrit correctement.

Tout d'abord, tu fais dans SerialPort::readCOM l'erreur soulevée par Lucien. Tu met le pointeur à NULL avant le delete. C'est très mal, ça ne peut pas fonctionner ! Si ton pointeur est NULL, delete ne peut pas savoir où il doit effacer la mémoire, puisque ton pointeur ne contient plus aucune information exploitable. Il faut corriger celà, ça provoque des fuites de mémoire.

Ensuite, ta manière d'allouer rep ne convient pas. Je pense que tu connais mal le mécanisme d'allocation/destruction et c'est ce qui provoque des problèmes. Lorsque tu utilises le const char * renvoyé par std::string::c_str(), il doit pas être utilisé pour l'écriture, et c'est la raison pour laquelle il est const. Cela te donne accès à un tableau de char utilisé par la chaîne, mais il ne faut en aucun cas le manipuler. En revanche, tu peux l'utiliser en lecture si tu en as besoin, et tu n'as pas de delete à faire, car le delete de cette zone mémoire est encapsulé dans le destructeur de la std::string qui le possède.

Maintenant que j'ai le code de SerialPort, je comprend mieux ce qu'il se passe. Voici une proposition de code corrigé. Je remarque notamment que :
- Le char * de retour de readCOM est strictement inutile.
- La méthode readCOMDLL est inutile et au contraire source d'erreurs

Honnêtement, ton code mériterait d'être réécris entièrement :(, mais bon je vais pas tout te réécrire parce que ce serait long pour moi et surtout pas pédagogique. Je t'ai passé les manipulations de chaînes en C++ (tu faisais du C). Le format obtenu dans output n'est peut être pas le bon (je connais pas sprintf car c'est du C ça me sers jamais). Si c'est le cas, on peut l'arranger, encore et toujours en C++.
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 std::string BdgCom::derQuery(char *derResult) { const size_t repSize = 8; //Taille de la trame contenant la réponse à retourner const size_t repInitSize = 6; //Taille de la trame contenant le début de la trame std::string resultat; // <- Tu va voir il est important pour l'élégance const char* query = NULL; const char rep[repSize]; //Réponse (les valeurs de débit de dose, erreur...) char repInit[repInitSize]; //Réponse Initial 55 AA.. bool isGood; //Réponse du checksum string trameToCheck; //Trame à vérifier (checksum) rep[repSize - 1] = '\0'; repInit[repInitSize - 1] = '\0'; // -1 très important ici et ne pas oublier que ce '\0' occupe une place ! isGood = false; //On repasse la string en const char*, création de la trame de demande : query = strDerQuery.c_str(); // la mémoire sera libérée par strDerQuery, on s'en préoccupe pas rep = strRep.c_str(); com.clrDTR(); //Demande du DerQuery sur le port série : if(writeCOMDLL(query,sizeTrameDerQuery)) { com.setDTR(); com.purgeClearCOM(); //--------------------------------------------------------------- // Lecture de la réponse sur le port série : // Vérification du début de la trame : 55 AA 70 ... // On cast rep pour la comparaison avec le buffer en "unsigned char" pour aller jusqu'à 0xFF //--------------------------------------------------------------- com.readCOM(rep,5); if(0x55 == static_cast<unsigned char>(rep[0]) && 0xAA == static_cast<unsigned char>(rep[1]) && 0x70 == static_cast<unsigned char>(rep[2]) && 0xFF > static_cast<unsigned char>(rep[3]) && 0x01 == static_cast<unsigned char>(rep[4]) ) { for(size_t i = 0; i < 5; i++) repInit[i] = rep[i]; com.readCOM(repSize - 1); if(rep) { //----------------------- //Calcul du checksum //----------------------- std::ostringstream output; for(size_t i = 0; i < 5; i++) output << std::hex << static_cast<unsigned char>(repInit[i]); for(size_t i = 0; i < repSize - 1; i++) output << std::hex << static_cast<unsigned char>(rep[i]); trameToCheck = output.str(); try { cout << "Trame avant checksum --> "; //DEBUG cout << trameToCheck << endl; //DEBUG isGood = checksumdDLL(trameToCheck); } catch (const std::exception &e) { cout << "ERROR CHECKSUM " << endl; cerr << e.what(); } output << std::hex << static_cast<unsigned char>rep[0] << "_" << std::hex << static_cast<unsigned char>(rep[4]); resultat = output.str(); cout << "DED dans BDgCom --> "; //DEBUG cout << retour << endl; //DEBUG } } } com.clrDTR(); return retour; }

30/05/2011, 16h37
krapo13

Merci jblecanard pour toute cette aide...:ccool:
C'est vrai que je connais mal le mécanisme d'allocation/destruction et C / C++ en général. Je n'avais jamais fait de C ni de C++ avant ce programme là. Pour l'instant je codais en Java, Php et Vb.. Mais quand on m'a demandé de crée un DLL je me suis mis au C++.
Bon en tout cas c'est cool, j'ai l'impression d'en apprendre à chaque message.
Deux petits points que je ne comprends pas :cry: :

- Pourquoi avoir mis rep en const char ? (de plus j'ai une erreur à la compilation, pb d'initialisation ), et d'autre part readCOM attend un char *(Dois je le remplacer par un autre type ?)

- C'est vrai que j'utilisais sprintf
que j'avais trouvé sur le site www.cplusplus.com, mais ostringstream à l'air vraiment très bien par contre je n'arrive pas à l'utiliser pour avoir ce que je veux.. En gros je veux la valeur héxadécimal du caractère en entrée mais sous la forme de chaine.. le caractère 'U' doit me donner la chaine "55"...

Merci

Hello

C'est une erreur de ma part, il faut enlever la qualification const et surtout enlever la ligne :

Code:

rep = strRep.c_str();

Ensuite, pour le format, facile. Il faut utiliser std::hex et les caster en unsigned int et pas en unsigned char. Comme dans cet exemple :
Code:

1 2 3 4 5 6 7 8 int main(int argc, char* argv[]) { std::ostringstream resultat; char monChar = 0x55; resultat << std::hex << static_cast<unsigned int>(monChar); std::cout << resultat.str() << std::endl; return 0; }
D'une manière générale, je pense que tu devrais t'acheter un bon bouquin sur C++. Et surtout n'hésite pas à user et abuser de la FAQ du site. Va même y faire un tour comme ça pour voir, je suis sûr que tu apprendras des tas de choses.

PS : Méfie toi de cppfrance, les codes sources qu'on y trouve sont souvent de mauvaise qualité.

J'avais enlever la ligne :

Code:

rep = strRep.c_str();

Par contre pour la conversion il y a quelques soucis puisqu’elle est dans une boucle. Avec par exemple ce code :
Code:

1 2 3 4 5 6 7 8 9 10 11 std::ostringstream resultat; char monChar = 0x55; resultat << std::hex << static_cast<unsigned int>(monChar); std::cout << resultat.str() << std::endl; monChar = 0xAA; resultat << std::hex << static_cast<unsigned int>(monChar); std::cout << resultat.str() << std::endl; monChar = 0x01; resultat << std::hex << static_cast<unsigned int>(monChar); std::cout << resultat.str() << std::endl;
Première ligne j'ai bien "55".
Puis ensuite ça se concatène
Deuxième ligne --> "55ffffffaa"

Lorsque que monChar vaut par exemple 0x01, j'ai 1 en sortie alors que je voudrais 01...
Que faut-il faire ?

Voilà la technique :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
#include <iostream>
#include <sstream>
#include <iomanip>
 
int main(int argc, char* argv[])
{
  std::ostringstream resultat;
  char monChar = 0x01;
  resultat << std::hex << std::setw(2) << std::setfill('0') << static_cast<unsigned int>(monChar);
  std::cout << resultat.str() << std::endl;
  return 0;
}

30/05/2011, 18h25
krapo13

Merci jblecanard :ccool: !!!

Je crois que je vais bientôt pouvoir mettre résolu, je vais nettoyer un peu le code avec tout ce que tu m'as appris et faire encore quelques tests... En tout cas je n'ai plus de fuite mémoire :D !

Et voilà une petite astuce pour rendre le code plus sympa :

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
#include <iostream>
#include <sstream>
#include <iomanip>
 
inline std::ostream& __CLRCALL_OR_CDECL monFormat(std::ostream& _Iosbase)
{
  _Iosbase.setf(std::ios_base::hex, std::ios_base::basefield);
  _Iosbase.width(2);
  _Iosbase.fill('0');
  return (_Iosbase);
}
 
int main(int argc, char* argv[])
{
  std::ostringstream resultat;  
  char monChar = 0x01;
  char monChar2 = 0x02;
  char monChar3 = 0x03;
 
  resultat 
    << monFormat << static_cast<unsigned int>(monChar)
    << monFormat << static_cast<unsigned int>(monChar2)
    << monFormat << static_cast<unsigned int>(monChar3);
 
  std::cout << resultat.str() << std::endl;
  return 0;
}

Salut,

Tout à l'air de bien fonctionner et j'apprends à utiliser les flux qui sont très utiles (http://cpp.developpez.com/faq/cpp/?page=SL) ...
J'ai cependant toujours le même souci avec ostringstream...

Avec cet exemple, il y a des "ff" qui s'ajoutent :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 using namespace std; int main() { std::ostringstream resultat1, resultat2, resultat3; char monChar = 0x55; resultat1 << hex << setw(2) << setfill('0') << uppercase << static_cast<unsigned int>(monChar); std::cout << resultat1.str() << std::endl; monChar = 0xAA; resultat2 << hex << setw(2) << setfill('0') << uppercase << static_cast<unsigned int>(monChar); std::cout << resultat2.str() << std::endl; monChar = 0x01; resultat3 << hex << setw(2) << setfill('0') << uppercase << static_cast<unsigned int>(monChar); std::cout << resultat3.str() << std::endl; return 0; }
Si je ne me trompe pas ça vient du cast en int qui est sur 4 octets...
Comment faire ?

Hello

Hum en fait le casting d'un char vers un int place tout les bits manquants à 1 et pas à zéro.

Tu peux t'en sortir comme ça :

Code:

1
2
3
4
  int mask = 0x000000ff;
  std::ostringstream resultat2;  
  resultat2 << std::uppercase << std::hex << std::setw(2) << std::setfill('0') <<  (static_cast<int>(monChar) & mask);
  std::cout << resultat2.str() << std::endl;

Ca marche. Je cherche une autre solution mais j'ai pas trouvé pour le moment. Version factorisée :

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
#include <iostream>
#include <sstream>
#include <iomanip>
 
inline std::ostream& __CLRCALL_OR_CDECL monFormat(std::ostream& _Iosbase)
{
  _Iosbase.setf(std::ios_base::hex, std::ios_base::basefield);
  _Iosbase.width(2);
  _Iosbase.fill('0');
  _Iosbase.setf(std::ios_base::uppercase);
  return (_Iosbase);
}
 
inline int getHexaDecimalChar(char iChar)
{
  int mask = 0x000000ff;
  return (static_cast<int>(iChar) & mask);
}
 
 
int main(int argc, char* argv[])
{
  char monChar = 0xAA;
  std::ostringstream resultat;  
  resultat << monFormat << getHexaDecimalChar(monChar);
  std::cout << resultat.str() << std::endl;
 
  return 0;
}

31/05/2011, 17h59
krapo13

Résolu, merci à tous ;) ...