Discussion :

[fenderthrice]

Bonjour messieur dame , c'est mon premier message et je vous dis bonjour à tous.
Je suis à l'heure actuel en stage jusque fin septembre .

Je fais un master handi nouvelle technologie
( il faut comprendre de la nouvelle technologie au service des personnes handicapées en fait)

Le but de mon travail faire deux programmes en C++ sous environnement VS2005.

un programme pour diriger un bras robot sur une base mobile
( base comportant un pc windows portable)
un autre programme sur un pocket pc ( programmation windows mobile)

La communication se fait par liaison bluetooth

vous vous doutez bien que si je vous ecris c'est que pour le moment je n'ai ni votre connaissance, ni la solution à mon probleme

le programme conçu pour recevoir les infos sur la base mobile est un pc portable windows qui m'affirme que tout mes ports sont invalides ...(this port is unvaluable)

Le port de transit est censer etre le port com4(port bluetooth).

La ligne suivante: T_COM2->WriteOnCom("$");

a pour but de renvoyer un flag pour ré-autoriser l'envoye d'un nouvel ordre depuis le pocket pc.

En effet si on envoye un deuxieme ordre avant la fin de l'execution du premier le bras plante .

C'est la premiere fois que je poste sur ce type de forum j'espere que mon poste n'est pas encore trop "lourd"

Je suis à l'attente de vos conseils et je vous remercie de m'avoir lu , toutes vos observation seront bonnes à prendre à mes yeux .

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
 
 
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	int wmId, wmEvent;
	PAINTSTRUCT ps;
HINSTANCE hInstance2=NULL;
Communication* T_COM=NULL;//COM_read=NULL;
Communication* T_COM2=NULL;//COM_write=NULL;
unsigned char** Data=NULL;
wchar_t* port=NULL;
wchar_t* DataToPrint=NULL;
DWORD dwIndex; 
 
 
 LPMEASUREITEMSTRUCT lpmis; 
    LPDRAWITEMSTRUCT lpdis; 
    TEXTMETRIC tm; 
    HDC hdc; 
    int x; 
    int y;
	HRESULT hr;
	size_t * pcch; 
 
 
 
int i=0,j=0;
int nbTag=0;
	switch (message)
	{
	case WM_COMMAND:
		wmId    = LOWORD(wParam);
		wmEvent = HIWORD(wParam);
		// Parse the menu selections:
		if (wParam == 524288){// || wParam==262144){
			initcb(hWnd);
		}
 
		switch (wmId)
		{
		case IDM_ABOUT:
			DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
			break;
 
 
		case IDM_NEW:	
			lsthWnd = CreateWindowEx(WS_EX_CLIENTEDGE, L"LISTBOX", L"Treeview", WS_VISIBLE|WS_CHILD|LBS_SORT|LBS_NOTIFY|\
			WS_HSCROLL|WS_VSCROLL, 10, 10, 750, 500, hWnd, NULL, hInst, NULL);
				CB = CreateWindowEx(WS_EX_OVERLAPPEDWINDOW, L"COMBOBOX", L"", WS_VISIBLE|WS_CHILD|CBS_AUTOHSCROLL|\
            CBS_DISABLENOSCROLL|CBS_HASSTRINGS|CBS_SORT|CBS_DROPDOWN, 760, 10 , 150, 200, hWnd, NULL,
            hInst, NULL);
 
			if (lsthWnd == NULL || CB == NULL)
			{
 
				MessageBox(hWnd, L"Erreur lors de la création de la ListBox.", L"Erreur", MB_OK);
				return 0;
 
			}
			UpdateWindow(hWnd);
			SendMessage(CB, CB_ADDSTRING, 0, (LPARAM)(LPCTSTR)L"COM1");
			 SendMessage(CB, CB_ADDSTRING, 0, (LPARAM)(LPCTSTR)L"COM2");
			 SendMessage(CB, CB_ADDSTRING, 0, (LPARAM)(LPCTSTR)L"COM3");
			 SendMessage(CB, CB_ADDSTRING, 0, (LPARAM)(LPCTSTR)L"COM4");
			 SendMessage(CB, CB_ADDSTRING, 0, (LPARAM)(LPCTSTR)L"COM5");
			 SendMessage(CB, CB_ADDSTRING, 0, (LPARAM)(LPCTSTR)L"COM6");
			 SendMessage(CB, CB_ADDSTRING, 0, (LPARAM)(LPCTSTR)L"COM7");
			 SendMessage(CB, CB_ADDSTRING, 0, (LPARAM)(LPCTSTR)L"COM8");
			 SendMessage(CB, CB_ADDSTRING, 0, (LPARAM)(LPCTSTR)L"COM9");
			 // Sélectionne le premier par défaut
			 SendMessage(CB, CB_SETCURSEL, (WPARAM)0, 0);
			 UpdateWindow(CB);
 
		break;
 
 
 
		case IDM_EXIT:
			DestroyWindow(hWnd);
			break;
		default:
			return DefWindowProc(hWnd, message, wParam, lParam);
		}
		break;
 
	case WM_SNIF:
			port=(wchar_t*)wParam;
			T_COM=new Communication( _T("COM4"),READ);//avant GENERIC_READ
			T_COM2=new Communication( _T("COM4"),WRITE);//avant GENERIC_WRITE
			T_COM2->initCOMConnection();//ajout
			T_COM->initCOMConnection();//ajout
			if(T_COM->GetCOMStatut()!=MS_CTS_ON)
				if(T_COM->initCOMConnection()!=0)//!=NULL marche pas non plus.
				{
					MessageBox(hWnd,L"This Port is unavailable",L"reading error",0);//le pb acteul c'est
					break;//que je passe systematiquement dans cette boucle
				}
			while(1){
				if(i==100){
				Data=(unsigned char**)realloc(Data,sizeof(unsigned char[5])*nbTag+1);
					for(j=0;j<5;i++){
					Data[j]=NULL;
						if(T_COM->ReadOnCom(Data[j])==0){
						nbTag++;
						}
					}
				}
				else{
					i++;
				}
				T_COM2->WriteOnCom("$");	
			}
 
	break;

[farscape]

salut,
je ne vois pas trop ce que l'on peut dire ,on ignore tout de la classe Communication.
le seul point qui me semble discutable c'est l'ouverture de deux objets sur le même port série un en lecture et en ecriture.
a mon avis ça ne fonctionne pas....
un seul objet en lecture/ecriture devrait fonctionner sous reserve de cette classe Communication.

[fenderthrice]

bonjour , et merçi de ta reponse "farscape" en effet je n'ai pas présenté la classe communication il me semble que ceci doit etre le bonheur concerné en question la classe communication sauf erreur de ma part :

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
class Communication{
	public:
 
		// This Constructor call the init() method and try to create a socket.
 
		Communication(wchar_t*,DWORD=GENERIC_READ | GENERIC_WRITE);
		// DESTRUCTOR 
		~Communication();
 
		// Initialize the communication with a call of  WSAStartup() and verify the version of Winsock. 
		int initCOMConnection();
 
		/**********************************************************************************************/
		/**********************************************************************************************/
 
		int WriteOnCom(char* );
		int ReadOnCom(unsigned char* );
		int CloseCom();
		DWORD GetCOMStatut();
 
protected:
	/* Data used to deal with virtual port COM */
	HANDLE hPort;
	LPCWSTR lpszPortName;
	DWORD iomode;
};

en fait je vais etre honnete je me base sur un travail qui au départ à pour but de lire des tags FRID ( les trucs en fer tout carré ) , l'info des tags doivent etre lut et envoyé sur des pc fixes , je détourne le projet car il est interressant dans le fait qu'il communique en bluetooth par pda WM5 vers pc , le but faire une interface IHM pour qu'une personne handicapée puisse se service d'un pda comme une sorte de télécommande fiable vers un bras robot controlé par un pc .

Merçi pour toute l'attention que vous pourriez m'apporter . jerome

[farscape]

salut,
je ne vois pas trop ce que l'on peut dire ,on ignore tout de la classe Communication.
le seul point qui me semble discutable c'est l'ouverture de deux objets sur le même port série un en lecture et en ecriture.
a mon avis ça ne fonctionne pas....
un seul objet en lecture/écriture devrait fonctionner sous réserve de cette classe Communication.

ok mais le reste ?, au vu de la définition ta classe par défaut elle ouvre le port en read,write.
alors je le redis: il te faut utiliser un seul objet sur le même port en lecture/écriture.

[fenderthrice]

bon je crois que le plus simple c'est que je mette tout les sources .... j'espere que ça va pas faire trop lourd :

d'abord communication.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
 
#ifndef __COMMUNICATION_H__
#define __COMMUNICATION_H__
#endif
/************************ INCLUDE FOR THE COMMUNICATION CLASS *************/
#include "Deffile.h"
#include <tchar.h>
 
// ----------------------------------------------------------------------- \\
//! A constructor.
    /*!
      A more elaborate description of the constructor.
    */
 
class Communication{
	public:
 
		// This Constructor call the init() method and try to create a socket.
 
		Communication(wchar_t*,DWORD=GENERIC_READ | GENERIC_WRITE);
		// DESTRUCTOR 
		~Communication();
 
		// Initialize the communication with a call of  WSAStartup() and verify the version of Winsock. 
		int initCOMConnection();
 
		/**********************************************************************************************/
		/**********************************************************************************************/
 
		int WriteOnCom(char* );
		int ReadOnCom(unsigned char* );
		int CloseCom();
		DWORD GetCOMStatut();
 
protected:
	/* Data used to deal with virtual port COM */
	HANDLE hPort;
	LPCWSTR lpszPortName;
	DWORD iomode;
};

voila je pense ne rien oublier en fichier merçi pour tout en tout cas

[fenderthrice]

ensuite dans la logique des choses communication.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
#include "stdafx.h"
#include "C:/Documents and Settings/stage/Mes documents/Visual Studio 2005/Projects/reception/Communication.h"
 
 
Communication::Communication(wchar_t* port,DWORD mode){
	/* CONSTRUCTOR */
		lpszPortName = port;			
		iomode=mode;
}
 
Communication::~Communication(){/* DESTRUCTOR */
		}
 
		int Communication::initCOMConnection(){
 
 
			hPort = CreateFile (
							lpszPortName,					//Pointer to the name of the port
							iomode,					//accès en lecture ou en écriture
							FILE_SHARE_READ,                //Share mode
							NULL,                           //Pointer to the security attribute
							OPEN_EXISTING,                  //Cela indique que l'instance sera créée à condition que le port 
															//de communication demandé existe et donc soit connu de l'OS
							0,                              //Port attributes
							NULL);                          //Handle to port with attribute to copy
 
			if ( hPort == INVALID_HANDLE_VALUE ){
				return 103;
			}
 
			DCB PortDCB;
 
			//Récupération des informations enregistées du port série dans votre structure.
			GetCommState (
							hPort,			// instance d'accès de votre port série
							&PortDCB);      // Structure de configuration
 
			/* mise à jour de la structure
			PortDCB.DCBlength = sizeof (DCB); 
			PortDCB.BaudRate = 9600; 
			PortDCB.fBinary = TRUE; 
			PortDCB.fParity = FALSE; 
			PortDCB.fOutxCtsFlow = FALSE; 
			PortDCB.fOutxDsrFlow = FALSE; 
			PortDCB.fDtrControl = DTR_CONTROL_HANDSHAKE; 
			PortDCB.fDsrSensitivity = FALSE; 
			PortDCB.fTXContinueOnXoff = TRUE; 
			PortDCB.fOutX = FALSE; 
			PortDCB.fInX = FALSE; 
			PortDCB.fErrorChar = FALSE; 
			PortDCB.fNull = FALSE; 
			PortDCB.fRtsControl = RTS_CONTROL_ENABLE; 
			PortDCB.fAbortOnError = FALSE; 
			PortDCB.ByteSize = 8; 
			PortDCB.Parity = NOPARITY; 
			PortDCB.StopBits = ONESTOPBIT; 
*/
			//Renvoie des nouvelles informations dans le registre de votre port série
			//if (!SetCommState (hPort, &PortDCB))
			// {
			 //  return 104;
			 //}
		return 0;
		}
		/******************************************************/
		/******************************************************/
		/*int Communication::WriteOnCom(s_Tag* data,int start,int end){
 
			DWORD dwNumBytesWritten;
			int err=0;int i=0;
			int* nbByteToWrite;
 
			for(i=start;i<end;i++){
				////BYTE Byte = 'a';
				*nbByteToWrite=sizeof(data->uid)/sizeof(char);
				WriteFile (hPort,nbByteToWrite,1,&dwNumBytesWritten,NULL);
				err=WriteFile (hPort,data[i].uid,*nbByteToWrite,&dwNumBytesWritten,NULL);
 
				*nbByteToWrite=sizeof(data->afi)/sizeof(char);
				WriteFile (hPort,nbByteToWrite,1,&dwNumBytesWritten,NULL);
				err=WriteFile (hPort,data[i].afi,*nbByteToWrite,&dwNumBytesWritten,NULL);
				if (err==0)
				{
					DWORD Err=GetLastError();
					return UNABLE_TO_WRITE;
				}
				SendMessage(HWND_BROADCAST,WM_TAGUID,(WPARAM)&data[i],0);
				BYTE Byte ='\n';
				WriteFile (hPort,&Byte,1,&dwNumBytesWritten,NULL);  
			}		  
			return 0;
		}*/
 
		int Communication::WriteOnCom( char* data){
 
			DWORD dwNumBytesWritten;
			int err=0;int i=0;
			int* nbByteToWrite;
 
			*nbByteToWrite=sizeof(data)/sizeof(char);
			WriteFile (hPort,nbByteToWrite,1,&dwNumBytesWritten,NULL);
			err=WriteFile (hPort,data,*nbByteToWrite,&dwNumBytesWritten,NULL);
 
			if (err==0)
			{
				DWORD Err=GetLastError();
				return UNABLE_TO_WRITE;
			}
			SendMessage(HWND_BROADCAST,WM_TAGUID,(WPARAM)&data[i],0);				 
 
			return 0;
		}
 
 
 
 
		int Communication::ReadOnCom(unsigned char* data){
 
			DWORD dwBytesTransferred;
			DWORD dwEvtMask;
			int i=0;
			int* nbByteToRead=NULL;     
			//Cette fonction définit les évènements pour lesquels ont va réagir par rapport à notre instance
			SetCommMask (hPort,EV_RXCHAR );		//ici EV_RXCHAR indique que l'on va détecter la réception          
										//de données (cette entrée est de type DWORD)
 
			PurgeComm(hPort,PURGE_RXCLEAR);
			 WaitCommEvent (hPort,&dwEvtMask,0); 
			 ReadFile (hPort,(LPVOID)nbByteToRead,1,&dwBytesTransferred,0);  
			 if(dwBytesTransferred==1){
					//Cette fonction est bloquante, elle va attendre des événements définit par le mask et
					//Elle stockera le type d'événement qui l'aura réveillée dans une variable.
					WaitCommEvent (	hPort,&dwEvtMask,0);
					data=(unsigned char*)realloc((void*)data,sizeof(char)*(*nbByteToRead));
					//Cette fonction permet la lecture du buffer d'entrée du port série
					ReadFile (hPort,(LPVOID) data,*nbByteToRead,&dwBytesTransferred,0);                
					SendMessage(HWND_BROADCAST,WM_TAGUID,(WPARAM)data,0);
			}			
			return 0;
 
		}
		int Communication::CloseCom(){
			return CloseHandle(hPort);
		}
		DWORD Communication::GetCOMStatut(){
			LPDWORD lpModemStat=NULL;
			GetCommModemStatus(hPort,lpModemStat);
			return (DWORD)lpModemStat;
		}

[fenderthrice]

et le programme qui fait usage de tout cela s'appel recup_on_pc:

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
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
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
// Recup_on_pc.cpp : Defines the entry point for the application.
//
#include "stdafx.h"
#include "C:/Documents and Settings/stage/Mes documents/Visual Studio 2005/Projects/reception/Deffile.h"
 
#include "Recup_on_pc.h"
 
#include <iostream>
#include <memory>
#define MAX_LOADSTRING 100
 
// Global Variables:
HINSTANCE hInst;								// current instance
TCHAR szTitle[MAX_LOADSTRING];					// The title bar text
TCHAR szWindowClass[MAX_LOADSTRING];			// the main window class name
HWND lsthWnd;
HWND CB;
DWORD ThreadReadId;
 
char achTemp[256];
// Forward declarations of functions included in this code module:
ATOM				MyRegisterClass(HINSTANCE hInstance);
BOOL				InitInstance(HINSTANCE, int);
LRESULT CALLBACK	WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK	About(HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK WndProc2(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
int initcb(HWND);
 
int APIENTRY _tWinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPTSTR    lpCmdLine,
                     int       nCmdShow)
{
	UNREFERENCED_PARAMETER(hPrevInstance);
	UNREFERENCED_PARAMETER(lpCmdLine);
 
 	// TODO: Place code here.
	MSG msg;
	HACCEL hAccelTable;
 
	// Initialize global strings
	LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
	LoadString(hInstance, IDC_RECUP_ON_PC, szWindowClass, MAX_LOADSTRING);
	MyRegisterClass(hInstance);
 
	// Perform application initialization:
	if (!InitInstance (hInstance, nCmdShow))
	{
		return FALSE;
	}
 
	hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_RECUP_ON_PC));
int i=0;
	// Main message loop:
	while (GetMessage(&msg, NULL, 0, 0))
	{
		if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
		{
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
	}
 
	return (int) msg.wParam;
}
 
 
 
//
//  FUNCTION: MyRegisterClass()
//
//  PURPOSE: Registers the window class.
//
//  COMMENTS:
//
//    This function and its usage are only necessary if you want this code
//    to be compatible with Win32 systems prior to the 'RegisterClassEx'
//    function that was added to Windows 95. It is important to call this function
//    so that the application will get 'well formed' small icons associated
//    with it.
//
ATOM MyRegisterClass(HINSTANCE hInstance)
{
	WNDCLASSEX wcex;
 
	wcex.cbSize = sizeof(WNDCLASSEX);
 
	wcex.style			= CS_HREDRAW | CS_VREDRAW;
	wcex.lpfnWndProc	= WndProc;
	wcex.cbClsExtra		= 0;
	wcex.cbWndExtra		= 0;
	wcex.hInstance		= hInstance;
	wcex.hIcon			= LoadIcon(hInstance, MAKEINTRESOURCE(IDI_RECUP_ON_PC));
	wcex.hCursor		= LoadCursor(NULL, IDC_ARROW);
	wcex.hbrBackground	= (HBRUSH)(COLOR_WINDOW+1);
	wcex.lpszMenuName	= MAKEINTRESOURCE(IDC_RECUP_ON_PC);
	wcex.lpszClassName	= szWindowClass;
	wcex.hIconSm		= LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));
 
	return RegisterClassEx(&wcex);
}
 
//
//   FUNCTION: InitInstance(HINSTANCE, int)
//
//   PURPOSE: Saves instance handle and creates main window
//
//   COMMENTS:
//
//        In this function, we save the instance handle in a global variable and
//        create and display the main program window.
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   HWND hWnd;
 
   hInst = hInstance; // Store instance handle in our global variable
 
   hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
      CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);
 
   if (!hWnd)
   {
      return FALSE;
   }
 
   ShowWindow(hWnd, nCmdShow);
   UpdateWindow(hWnd);
 
 
   return TRUE;
}
 
//
//  FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
//
//  PURPOSE:  Processes messages for the main window.
//
//  WM_COMMAND	- process the application menu
//  WM_PAINT	- Paint the main window
//  WM_DESTROY	- post a quit message and return
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	int wmId, wmEvent;
	PAINTSTRUCT ps;
HINSTANCE hInstance2=NULL;
Communication* T_COM=NULL;//COM_read=NULL;
Communication* T_COM2=NULL;//COM_write=NULL;
unsigned char** Data=NULL;
wchar_t* port=NULL;
wchar_t* DataToPrint=NULL;
DWORD dwIndex; 
 
 
 LPMEASUREITEMSTRUCT lpmis; 
    LPDRAWITEMSTRUCT lpdis; 
    TEXTMETRIC tm; 
    HDC hdc; 
    int x; 
    int y;
	HRESULT hr;
	size_t * pcch; 
 
 
 
int i=0,j=0;
int nbTag=0;
	switch (message)
	{
	case WM_COMMAND:
		wmId    = LOWORD(wParam);
		wmEvent = HIWORD(wParam);
		// Parse the menu selections:
		if (wParam == 524288){// || wParam==262144){
			initcb(hWnd);
		}
 
		switch (wmId)
		{
		case IDM_ABOUT:
			DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
			break;
 
 
		case IDM_NEW:	
			lsthWnd = CreateWindowEx(WS_EX_CLIENTEDGE, L"LISTBOX", L"Treeview", WS_VISIBLE|WS_CHILD|LBS_SORT|LBS_NOTIFY|\
			WS_HSCROLL|WS_VSCROLL, 10, 10, 750, 500, hWnd, NULL, hInst, NULL);
				CB = CreateWindowEx(WS_EX_OVERLAPPEDWINDOW, L"COMBOBOX", L"", WS_VISIBLE|WS_CHILD|CBS_AUTOHSCROLL|\
            CBS_DISABLENOSCROLL|CBS_HASSTRINGS|CBS_SORT|CBS_DROPDOWN, 760, 10 , 150, 200, hWnd, NULL,
            hInst, NULL);
 
			if (lsthWnd == NULL || CB == NULL)
			{
 
				MessageBox(hWnd, L"Erreur lors de la création de la ListBox.", L"Erreur", MB_OK);
				return 0;
 
			}
			UpdateWindow(hWnd);
			SendMessage(CB, CB_ADDSTRING, 0, (LPARAM)(LPCTSTR)L"COM1");
			 SendMessage(CB, CB_ADDSTRING, 0, (LPARAM)(LPCTSTR)L"COM2");
			 SendMessage(CB, CB_ADDSTRING, 0, (LPARAM)(LPCTSTR)L"COM3");
			 SendMessage(CB, CB_ADDSTRING, 0, (LPARAM)(LPCTSTR)L"COM4");
			 SendMessage(CB, CB_ADDSTRING, 0, (LPARAM)(LPCTSTR)L"COM5");
			 SendMessage(CB, CB_ADDSTRING, 0, (LPARAM)(LPCTSTR)L"COM6");
			 SendMessage(CB, CB_ADDSTRING, 0, (LPARAM)(LPCTSTR)L"COM7");
			 SendMessage(CB, CB_ADDSTRING, 0, (LPARAM)(LPCTSTR)L"COM8");
			 SendMessage(CB, CB_ADDSTRING, 0, (LPARAM)(LPCTSTR)L"COM9");
			 // Sélectionne le premier par défaut
			 SendMessage(CB, CB_SETCURSEL, (WPARAM)0, 0);
			 UpdateWindow(CB);
 
		break;
 
 
 
		case IDM_EXIT:
			DestroyWindow(hWnd);
			break;
		default:
			return DefWindowProc(hWnd, message, wParam, lParam);
		}
		break;
 
	case WM_SNIF:
			port=(wchar_t*)wParam;
			T_COM=new Communication( _T("COM4"),READ);//avant GENERIC_READ
			T_COM2=new Communication( _T("COM4"),WRITE);//avant GENERIC_WRITE
			T_COM2->initCOMConnection();//ajout
			T_COM->initCOMConnection();//ajout
			if(T_COM->GetCOMStatut()!=MS_CTS_ON)
				if(T_COM->initCOMConnection()!=0)//!=NULL marche pas non plus.
				{
					MessageBox(hWnd,L"This Port is unavailable",L"reading error",0);//le pb acteul c'est
					break;//que je passe systematiquement dans cette boucle
				}
			while(1){
				if(i==100){
				Data=(unsigned char**)realloc(Data,sizeof(unsigned char[5])*nbTag+1);
					for(j=0;j<5;i++){
					Data[j]=NULL;
						if(T_COM->ReadOnCom(Data[j])==0){
						nbTag++;
						}
					}
				}
				else{
					i++;
				}
				T_COM2->WriteOnCom("$");	
			}
 
	break;
 
	case WM_TAGUID:		
				DataToPrint=(wchar_t*)wParam;// datatoprint est la variable qui contient l'ensemble des caractere envoyer parle pda
				SendMessage(lsthWnd, LB_INSERTSTRING , 0, (LPARAM)DataToPrint);
				UpdateWindow(hWnd);
		break;
	case WM_PAINT:
		hdc = BeginPaint(hWnd, &ps);
		// TODO: Add any drawing code here...
		EndPaint(hWnd, &ps);
		break;
	case WM_DESTROY:
		PostQuitMessage(0);
		break;
	default:
		return DefWindowProc(hWnd, message, wParam, lParam);
	}
	return 0;
}
 
int initcb(HWND hWnd){
 
	int SelIndex=0;  // Indexe de l'item
int SelLen=0;    // Nombre de caractère de l'item
char *buffer=NULL;  // Variable temporaire
int i=0;
	 // Récupère l'indexe de l'item sélectionner
                        SelIndex = SendMessage(CB, CB_GETCURSEL, 0, 0);
                        // Si l'item est vraiment sélectionner
 
 
                              // Récupère le nombre de caractères
                              SelLen = SendMessage(CB, CB_GETLBTEXTLEN, (WPARAM)SelIndex, 0);
                              // S'il en contient(plus de zéro)
                              if (SelLen)
                              {
 
                                    // Alloue de la mémoire pour stocker l'item
                                   buffer =new char[100];
                                    // Récupère l'item
                                    SelLen = SendMessage(CB, CB_GETLBTEXT, (WPARAM)SelIndex, (LPARAM)buffer);
 
                                    // Si aucune erreur
                                    if (SelLen)
                                    {
	                                     // Envoie le contenue de caption dans le caption de la fenêtre
                                          SetWindowText(lsthWnd,(LPCWSTR) buffer);
										  SendMessage(hWnd,WM_TAGUID,(WPARAM)buffer,0);
                                           SendMessage(hWnd,WM_SNIF,(WPARAM)buffer,0);
										   // Met à jour la fenêtre
                                         UpdateWindow(CB);
                                          // Libère la mémoire
                                         //free(caption);
 
                                    }
 
                                    // Libère la mémoire
 
									delete[] buffer;
							  }
							  return 0;
 
}
 
// Message handler for about box.
INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
	UNREFERENCED_PARAMETER(lParam);
	switch (message)
	{
	case WM_INITDIALOG:
		return (INT_PTR)TRUE;
 
	case WM_COMMAND:
		if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
		{
			EndDialog(hDlg, LOWORD(wParam));
			return (INT_PTR)TRUE;
		}
		break;
	}
	return (INT_PTR)FALSE;
}
 
LRESULT CALLBACK WndProc2(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	s_Tag* Data=NULL;
	DWORD err;
	switch (message)
      {
 
            case WM_DESTROY:
 
                  PostQuitMessage(0);
                  break;
 
            case WM_CLOSE:
 
                  DestroyWindow(hWnd);
                  break;
 
            case WM_COMMAND:
 
                  // Afficher l'item sélectionner dans le caption de la fenêtre
                  if ((LOWORD(wParam) == IDC_TREE) && (HIWORD(wParam) == LBN_SELCHANGE))
                  {
 
                        int SelIndex;  // Indexe de l'iteme waouu 
                        int SelLen;    // Nombre de caractère de l'item
                        char *buffer;  // Variable temporaire
                        char *caption=NULL; // Va contenir le texte à afficher dans le caption de la fenêtre
 
                        // Récupère l'indexe de l'item sélectionner
                        SelIndex = SendMessage(lsthWnd, LB_GETCURSEL, 0, 0);
                        // Si l'item est vraiment sélectionner
                        if (SendMessage(lsthWnd, LB_GETSEL, (WPARAM)SelIndex, 0))
                        {
 
                              // Récupère le nombre de caractères
                              SelLen = SendMessage(lsthWnd, LB_GETTEXTLEN, (WPARAM)SelIndex, 0);
                              // S'il en contient(plus de zéro)
                              if (SelLen)
                              {
 
                                    // Alloue de la mémoire pour stocker l'item
                                    buffer = new char[(SelLen + 2)];
                                    // Récupère l'item
                                    SelLen = SendMessage(lsthWnd, LB_GETTEXT, (WPARAM)SelIndex, (LPARAM)buffer);
 
                                    // Si aucune erreur
                                    if (SelLen)
                                    {
 
                                          // Alloue de la mémoire
                                          caption =(char*) realloc(caption,sizeof(char)*25+sizeof(buffer));
 
                                          // Copie dans caption
                                          strcpy(caption,(char*) L"Treeview [SelectedItem = ");
                                          // Ajoute dans caption
                                          strcat(caption, buffer);
                                          strcat(caption, " ]");
 
                                          // Envoie le contenue de caption dans le caption de la fenêtre
                                          SetWindowText(hWnd,(LPCWSTR) caption);
                                          // Met à jour la fenêtre
                                          UpdateWindow(hWnd);
                                          // Libère la mémoire
                                          free(caption);
 
                                    }
 
                                    // Libère la mémoire
                                    delete [] buffer;
 
                              }
 
                        }
 
                  }
 
                  break;
 
		case WM_TAGUID:
				Data=(s_Tag*) wParam;
				SendMessage(lsthWnd, LB_INSERTSTRING , 0, (LPARAM)L"-----------");
				if(Data->uid!=NULL) 
					SendMessage(lsthWnd, LB_INSERTSTRING , 0, (LPARAM)Data->uid);
				if(Data->afi!=NULL) 
					SendMessage(lsthWnd, LB_INSERTSTRING , 0, (LPARAM)Data->afi);
				if(Data->blockSize!=NULL) 
					SendMessage(lsthWnd, LB_INSERTSTRING , 0, (LPARAM)Data->blockSize);
				if(Data->numBlocks!=NULL) 
					SendMessage(lsthWnd, LB_INSERTSTRING , 0, (LPARAM)Data->numBlocks);
				if(Data->ReceiveData!=NULL) 
					SendMessage(lsthWnd, LB_INSERTSTRING , 0, (LPARAM)Data->ReceiveData);
				err=GetLastError();
				UpdateWindow(hWnd);
		break;
 
 
 
            default:
 
                  return DefWindowProc(hWnd, message, wParam, lParam);
                  break;
 
      }
 
 
      return 0;
}
 
DWORD WINAPI ThreadReadProc(LPVOID lpParam){
 
 
return 0;
}

voila je pense ne rien oublier en fichier merçi pour tout en tout cas.

Ne pas frapper sur ma tête je n'ai que un dut info en poche et il date de 5 ans snif . Alors pour moi vs 2005 c'est "mars" pour moi