realisation d une dll de lecture de memoire RAM

Version imprimable

Bonjour et bonne annee à tous.
Je suis ennuyé: je realise un banc de test de carte gps sous labview et il y a une fonction que je ne peux pas faire sous ce dernier.
Je pense faire une dll.
La fonction est la suivante: lire à une adresse définie et sur un espace defini la memoire RAM du pc.
J'ai un bout de code ( que je ne metrise pas) et j ai VisualC++6 mais je ne sais pas faire de dll ( et tres peu de c a vrai dire)
Je vous mets le bout de code
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 /////////////////////////// // Attente mutex dwWaitResult = WaitForSingleObject(hMutexIHMIn,10L); if (dwWaitResult==WAIT_OBJECT_0) { // Transfert des donnees depuis la memoire partagee memcpy (&to_ihm_data, ToIHMPtr, sizeof(t_to_ihm)); // Relachement du mutex if (!ReleaseMutex(hMutexIHMIn) ) { printf ("IO : fail to release mutex IHM In.\n") ; } } else { printf ("IO : fail to obtain mutex IHM In.\n") ; } ////////////////////////////////
Merci d'avance à ceux qui m 'aiderons
Cordialement

04/01/2007, 15h33
nico-pyright(c)

merci de penser à la balise code...

Le problème est que tu n'arrives pas à faire une dll ? c'est ca ?
il faut utiliser le template de projet win32 dll, créer un point d'entrée et une/plusieurs fonctions à exporter.

Bonjour et merci de ta reponse.
Je crois que c'est ce que j ai fais mais je ne sais pas aller plus loin!
pour l'instant j ai ca dans VC++6 :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 // ReadMem.cpp : Defines the entry point for the DLL application. // #include "stdafx.h" BOOL APIENTRY DllMain( HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved ) { return TRUE; }
Mais je ne sais pas aller plus loin!

Dans l arborescence il y a :

ReadMem classes
->Globals
-->DllMain(HANDLE hModule,DWORD ul_reason_for_call,LPVOID lpReserved)

qu'est ce que je dois coder et ou?
Merci de vos reponses.

04/01/2007, 15h48
nico-pyright(c)
et bien il faut exporter des fonctions maintenant
Code:

1 2 3 4 5 extern "C" void __stdcall doSomething() { // faire qqchose }

est ce que cela irait?
sachant que les variable seront passé en paramétres par labviex, faut il tout de meme que je les declare dans la dll, Je pense que oui mais pas sur.

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
 
// ReadMem.cpp : Defines the entry point for the DLL application.
//
 
#include "stdafx.h"
 
BOOL APIENTRY DllMain( HANDLE hModule, 
                       DWORD  ul_reason_for_call, 
                       LPVOID lpReserved
					 )
{
    return TRUE;
}
 
extern "C" void __stdcall RecupMemoirePartagee()
{
    // Attente mutex
	dwWaitResult = WaitForSingleObject(hMutexIHMIn,10L);
	if (dwWaitResult==WAIT_OBJECT_0)
		{
		// Transfert des donnees depuis la memoire partagee
		memcpy (&to_ihm_data, ToIHMPtr, sizeof(t_to_ihm));			
 
		// Relachement du mutex
		if (!ReleaseMutex(hMutexIHMIn) )
			{	      
			printf ("IO : fail to release mutex IHM In.\n") ;	     
			}			            
		}
    else 
		{
		printf ("IO : fail to obtain mutex IHM In.\n") ;
		}
}

04/01/2007, 16h36
nico-pyright(c)

bien sur, il faut adapter le prototype de ta fonction à tes besoins, mais attention, ne connaissant pas labview, je ne sais pas comment il passe les paramètres, mais stdcall devrait aller

Bonjour, est ce qu'il faut remplir quelquechose dans la partie cree lors de la creation du patern? à savoir:
Code:

1 2 3 4 5 6 7 8 BOOL APIENTRY DllMain( HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved ) { return TRUE; }
merci de votre reponse.

À moins que ta DLL contienne des ressources, tu n'en auras pas besoin.

Si elle contient des ressources et qu'elle devra les charger elle-même (cad: Des fonctions de la DLL accèdent à des ressources de la DLL), je te conseille de créer un HMODULE en variable globale et de l'affecter comme suit:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 HMODULE g_hModule; BOOL APIENTRY DllMain( HMODULE hModule, // Il y avait une erreur ici DWORD ul_reason_for_call, // LPVOID lpReserved // ) { //On mémorise le HMODULE. if(ul_reason_for_call == DLL_PROCESS_ATTACH) g_hModule = hModule; return TRUE; }

bonjour et merci de ta reponse.
Je voudrais etre sur de comprendre ce que je fais car je metrise tres peu ce code et le c.
Le bute de ce code est de reserver un jeton de semaphore et de lire un espace partagé en memoire ram pour echange des information entre 2 application.
Je vais essayer de mettre ce que j ai compris et j aimerais ta critique dessus.
Merci d avance

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
 
extern "C" void __stdcall RecupMemoirePartagee() 
// donc la c est le nom d une fonction contenue dans la dll 
//et que je pourrai utiliser indépendament
{
    // Attente mutex
	dwWaitResult = WaitForSingleObject(hMutexIHMIn,10L);
// Je mets dans un variable le resultat de "WaitForSingleObject" 
// qui a en paramètre "hMutexIHMIn" et "10L". Il me semble
// que hMutexIHMIn" est le jeton du semaphore
// de gestion mon espace partagé et "10L" et le timeout
// Que veux dire 10L?
	if (dwWaitResult==WAIT_OBJECT_0) //si c'est ok alors
		{
		// Transfert des donnees depuis la memoire partagee
		memcpy (&to_ihm_data, ToIHMPtr, sizeof(t_to_ihm));	
// copier bloc memoire (destination, source, taille)
// par contre ->"&"<- to_ihm_data? 
// (dans mon code j 'ai en init : static t_to_ihm *ToIHMPtr ;)
// ToIHMPtr?
// t_to_ihm?
// En clair je ne sais pas ce que je dois recuppérer et sous quel forme
// Un tableau serai sympa		
 
		// Relachement du mutex
		if (!ReleaseMutex(hMutexIHMIn) )
			{	      
			printf ("IO : fail to release mutex IHM In.\n") ;	     
			}			            
		}
    else 
		{
		printf ("IO : fail to obtain mutex IHM In.\n") ;
		}
}

J'ai également un bout de code pour la creation du mutex de hMutexIHMIn

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
extern "C" void __stdcall RecupMemoirePartagee() 
// donc la c est le nom d une fonction contenue dans la dll 
//et que je pourrai utiliser indépendament
{
	// Attente mutex
	dwWaitResult = WaitForSingleObject(hMutexIHMIn,10L);
	// Je mets dans un variable le resultat de "WaitForSingleObject" 
	// qui a en paramètre "hMutexIHMIn" et "10L". Il me semble
	// que hMutexIHMIn" est le jeton du semaphore
	// de gestion mon espace partagé et "10L" et le timeout
	// Que veux dire 10L?
	/* Médinoc:
		hMutexIHMIn est le handle du mutex utilisé (un mutex étant un sémaphore binaire).
		10L indique un timeout de 10 millisecondes, 
		L signifiant que c'est un entier long (inutile ici sous un Windows 32 bits).
 
		Au fait, dwWaitResult devrait être une variable locale, pas globale 
		(pour le handle, ça peut se pardonner (en rajoutant le préfixe g_ à son nom),
		 mais pour le résultat, c'est impardonnable).
	 */
	/* Médinoc: Pas d'espace entre un if (ou une fonction) et sa parenthèse s'il te plait, c'est illisible. */
	if(dwWaitResult==WAIT_OBJECT_0) //si c'est ok alors
	{
		// Transfert des donnees depuis la memoire partagee
		memcpy(&to_ihm_data, ToIHMPtr, sizeof(t_to_ihm));	
		// copier bloc memoire (destination, source, taille)
		// par contre ->"&"<- to_ihm_data? 
		// (dans mon code j 'ai en init : static t_to_ihm *ToIHMPtr ;)
		// ToIHMPtr?
		// t_to_ihm?
		// En clair je ne sais pas ce que je dois recuppérer et sous quel forme
		// Un tableau serai sympa
		/* Médinoc: 
			il semblerait que to_ihm_data et ToIHMPtr soient tous les deux des variables globales.
			to_ihm_data doit être de type t_to_ihm et ToIHMPtr est de type t_to_ihm*
 
			(Si tu ne sais pas à quoi sert l'opérateur &, replonge-toi dans tes cours de C avant de continuer).
			memcpy() recoit donc deux pointeurs vers des données de type t_to_ihm, ainsi que la bonne taille, c'est OK.
 
			Mais dans une application à toi, tu fais ce que tu veux tant que tu as le mutex...
		*/
 
		// Relachement du mutex
		if( !ReleaseMutex(hMutexIHMIn) )
		{	      
		printf("IO : fail to release mutex IHM In.\n") ;	     
		}			            
	}
	else 
	{
	printf("IO : fail to obtain mutex IHM In.\n") ;
	}
}
/* Médinoc:
	Conseil: Faire retourner une valeur à la fonction, pour dire si la copie a réussi ou échoué, 
	et pourquoi (erreur ou timeout). Tu peux par exemple, retourner directement dwWaitResult
	(mais ça n'indique pas l'erreur éventuelle sur ReleaseMutex()...)
*/