Problème ntdll, Gestion mémoire..

**krapo13** · 12/05/2011, 13h19

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

, 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 :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
#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 :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
 
#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 :

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

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

...

**fregolo52** · 12/05/2011, 13h50

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

**krapo13** · 12/05/2011, 14h20

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

**krapo13** · 24/05/2011, 16h15

J'arrive à ce que le code ne plante plus

Checksum.cpp :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
 
#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 :

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

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

Eh ben ça replante comme avant

D'où cela peut-il bien venir ??

**themadmax** · 26/05/2011, 12h33

Compilation VS2008, execution WinXP : no problem
Passage de Intel inspecteur qui n'a po trouver de problème de mémoire.

**krapo13** · 26/05/2011, 15h29

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)

!
Par contre si dans la méthode "cutString" j'enlève la ligne

Code :

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

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

et que je la remplace par par exemple

Code :

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

vectChaine.push_back("0x00");

là ça ne plante plus ! Je ne comprends plus rien

.

Je débute en c++ et j'ai du mal a débugger

!

**jblecanard** · 26/05/2011, 17h20

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.

**krapo13** · 26/05/2011, 17h32

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

Code :

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

char *rep(0);

c'est initialiser le pointeur "rep" ?

**jblecanard** · 26/05/2011, 17h36

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

Code :

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

char * rep = NULL;

Mais la tienne est tout à fait correcte.

**krapo13** · 26/05/2011, 17h51

Merci pour ce petit logiciel qu'est cppCheck !

J'ai une erreur quand je scanne mon répertoire de travail :

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

Le code :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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];

**Lucien63** · 26/05/2011, 18h14

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

**jblecanard** · 26/05/2011, 18h29

Envoyé par krapo13

Merci pour ce petit logiciel qu'est cppCheck !

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

Envoyé par krapo13

Merci pour ce petit logiciel qu'est cppCheck !

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.

**krapo13** · 26/05/2011, 18h35

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

Code :

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

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

..

Petite précision, c'est une librairie dynamique que je tente de développer..

**jblecanard** · 26/05/2011, 18h41

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 ?

**krapo13** · 26/05/2011, 18h52

Voilà le résultat de CppCheck :

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

**jblecanard** · 26/05/2011, 19h05

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

.

**krapo13** · 26/05/2011, 19h14

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é

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
 
#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 :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
 
#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 :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
 
#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 :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
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 :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
#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 :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
 
#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;
}

**Lucien63** · 26/05/2011, 19h33

Code :

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

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

**krapo13** · 26/05/2011, 20h46

Pff... Honte sur moi..

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 :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
#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)..

Par contre si je "court-circuite" le calcul du checksum en commentant la ligne

Code :

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

isGood = sum.calcChecksum();

dans BdgCom.cpp le programme ne plante plus.

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 !

**jblecanard** · 27/05/2011, 14h32

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 :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
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.

Problème ntdll, Gestion mémoire..

C++

Discussions similaires

Partager

Partager