realisation d une dll de lecture de memoire RAM

**mat26400** · 04/01/2007, 15h25

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 :

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

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

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.

**mat26400** · 04/01/2007, 15h40

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 :

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

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.

**nico-pyright(c)** · 04/01/2007, 15h48

et bien il faut exporter des fonctions maintenant

Code :

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

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

**mat26400** · 04/01/2007, 16h32

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 :

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
 
// 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") ;
		}
}

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

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

**mat26400** · 05/01/2007, 09h22

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

Code :

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

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.

**Médinoc** · 05/01/2007, 09h36

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

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

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;
}

**mat26400** · 05/01/2007, 10h28

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 :

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

**Médinoc** · 05/01/2007, 11h23

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
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()...)
*/

realisation d une dll de lecture de memoire RAM

Visual C++

Discussions similaires

Partager

Partager