Discussion :

[ppfromero]

Bonjour,

Je suis en train de développer une application en C sur un compilateur CVI. Mon application a pour but de communiquer avec des instruments de mesure par intermédiaire des ports série ou autres ports quelconques dans le futur. J'aimerais créer une dll de communication qui gère, avec un protocole défini apriori, la communication. Je voudrais pour ce faire, que la dll de communication ce dedouble (dans le sens figuré du terme) et que se lance dans un thread indépendant pour chaque appareil et pour chaque port com.
Actuellement j'ai deja utilisé cette methode mais pour un seul appareil et un seul port com, et je voudrais savoir comment faire pour utiliser la même dll pour les autres port coms et independament?

Merci d'avance pour vos commentaires.

[ram-0000]

L'application principale énumère les ports/equipements avec lesquels elle peut communiquer
Pour chaque équipement,
elle créé un "contexte" (structure ou classe allouée dynamiquement) qui permet de référence de manière unique et non ambigüe l'équipement/port de communication
elle créé un thread et passe en paramètre à ce thread le contexte

Chaque thread est responsable de la gestion de l'équipement spécifié par le contexte au lancement du thread

[cmoibal]

ce que ta di rqm_000 est vrai, et c'est une solution tres utiliser, mais le probleme c'est dans ton point de vue des chose, je m'explique, si tu veut que votre DLL soit independant de l'application qu'il utilise, et en meme temps sans obliger le programme a suivre une structure bien definie pour uriliser ta dll. je pense que tu peut lancer les thread a partir de ton DLL.

Une methode simple, pour chaque application, le dll est charge avec des donnees specifiaue au application, donc, si tu a une variable qui represente le nombre d'appel du DLL tu peut cree le nombre de thread que tu souhaite, sans limitation pour le programmeur de l'application.

[ppfromero]

Merci les gars pour vos réponses, c'est bien intéressant ce que vous me conseillez.
Je vais essayer d'expliquer un peu plus les choses:
Ma dll serait composé pour le moment d'une fonction appelé (bien sur j'omets pour l'instant les appels stdcall et les types des fonctions pour ce concentrer sur le fonctionnement):

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
void Command(int comport,int read_write,int N_codes,int *codes,int *data_length,int *data_in) 
{
   copie des datas dans la structure comm
   allocation de mémoire
   acknowledge()
}
 
void acknowledge()
{
   programmation d'une interruption sur le port com pour fin_acknowledge()
   Envoi des codes d'acknolewdge
} 
 
void fin_acknowledge()
{
    lecture de réponse
    debut_com()
}
 
void debut_com()
{
   libération mémoire data_in 
   programmation d'une interruption sur le port com pour fin_com()    
   envoi des codes et datas
}
 
void fin_com()
{
   lecture des donnés
   raz des structures et buffers
   libération mémoire data_out
}

Alors sur cette architecture j'ai crée une structure de communication:

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
typedef struct
        {
            int comport;
            int read_write;
            int N_codes;
 
            int data_length[USER_MAX_CODES];
            SHORTINT codes[USER_MAX_CODES];
            SHORTINT N_bytes[USER_MAX_CODES];
            BYTE *data_in[USER_MAX_CODES];
            BYTE *data_out[USER_MAX_CODES];
 
            int flag_com_busy;
 
        } COMMUNICATION;

et bien sur j'alloue dynamiquement data_in et out(parce que si j'ai 10 instrument cela peut devenir lourd au niveau mémoire).

Alors je compte mettre ce petit module dans une dll et pour chaque instrument le lancer dans un thread, mais la ou je coince c'est savoir si j'appelle dans des threads differents en même temps la fonction command de la dll, comment cela va se débrouiller.

Un autre soucis c'est de récupérer l'information au niveau de l'application (j'avais penser passer en argument l'adresse d'une fonction a exécuter lors de la fin de comm)

Je voulais savoir ce que vous en pensiez de cette utilisation de l'allocation dynamique.

Merci les gars

[ram-0000]

Alors je compte mettre ce petit module dans une dll et pour chaque instrument le lancer dans un thread, mais la ou je coince c'est savoir si j'appelle dans des threads differents en même temps la fonction command de la dll, comment cela va se débrouiller.

La vraie question est plutôt "est ce que la fonction command() est réentrante" c'est à dire, peut elle être appelée simultanément depuis plusieurs threads. Si cette fonction n'utilise pas de variables globales ni ne fait des appels à des fonctions qui utilisent des variables globales(c'est moins facile d'être catégorique pour ce point), ta fonction est réentrante. Sinon, elle n'est pas réentrante et il faut alors la protéger avec une section critique par exemple de manière à garantir qu'un seul thread à la fois pourra l'exécuter. Les autres attendront.

[Médinoc]

Attention, thread-safe n'est pas la même chose que réentrant.

Une fonction peut être réentrante sans être thread-safe, et inversement.
Et aussi, il faut bien définir à quoi s'applique la thread-safety d'une fonction, si elle peut s'appliquer à plusieurs données.

[ram-0000]

Attention, thread-safe n'est pas la même chose que réentrant.

Quelle différence fais-tu entre thread-safe et réentrant ?

[Médinoc]

Une fonction peut être réentrante sans être thread-safe (par exemple, si elle utilise une variable globale et appelle une fonction callback tout en supportant d'être appelée à son tour par la callback), ou peut être thread-safe sans être réentrante (les implémentations Microsoft des fonctions non-réentrantes de la C Run-Time Library (CRT) utilisent toutes du Thread-Local Storage).

Voir aussi ceci.

[ram-0000]

Effectivement, il y a une petite nuance

[Médinoc]

Et bien sûr, il y a les fonctions qui ne sont ni réentrantes ni thread-safe, comme chdir() (ou même la versions bas niveau SetCurrentDirectory()), qui règlent le répertoire courant... pour le processus entier.

[ppfromero]

Salut les gars!

Désolé pour le manque de réponses, j'ai été noyé dans le travail ce dernier temps .

J'ai bien avancé dans la rédaction de ma dll de communication, mais j'ai quand même quelques lacunes dans ce qui concerne la gestion des dll, peut être vous pouvez m'éclaircir certains points.

1. Je voudrais savoir si le fait de lancer plusieurs fois ma commande:__stdcall Command, fait que la dll se lance plusieurs fois en créant plusieurs fonctions Command à des adresses différentes. Ce qui voudrais dire que les appels de la dll seraient indépendants. (En effet ram_0000 la fonction doit être appelé plusieurs fois et indépendamment mais je cherche une manière d'utiliser le même code dans des port coms différents).

Cette question fait allusion au fait que j'ai une structure globale (globale mais au sein de la dll) COMMUNICATION comm; avec un flag que j'ai mets a BUSY quand j'ai commence la communication et que j'ai remets a READY lorsque j'ai fini la fonction fincom.

Si par example le deuxième appel de la fonction me change l'état de la variable, tout est perdu.

2. La deuxième question est plus ou moins lié a la première, il s'agit de faire sortir l'information de la dll pour cela j'ai crée une fonction CALLBACK qui se lance lors de la fin de comm ou lors d'une erreur produite.

Cette fonction a un prototype bien défini, mais j'ai toujours le même problème, j'aurais besoin que le callback s'exécute de manière indépendante pour tous les ports de communication (qu'elle se dédouble comme la dll). Est-ce que il existe une façon de dire que je veux exécuter la fonction callback dans une zone mémoire indépendante en fonction de l'appel dll?

Merci pour votre aide

[Médinoc]

1. Il n'existe qu'un seul exemplaire des données de la DLL dans un processus. Donc, tu vas devoir dé-globaliser tes variables.
2. Je ne comprends pas ce que tu veux dire pour la zone mémoire liée à la callback...

[ppfromero]

Bonjour:

Je pense que je ne suis pas clair dans mes explications.... je reformule...

Voici une structure simplifié de mon 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
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
 
////////////////////Programme principal
void Main(....)
{
    //Je lance dans plusieurs thread une fontion qui va scruter avec une  periodicité mon port COM1, COM2,....
    CmtScheduleThread(fctCOM1)
    CmtScheduleThread(fctCOM2)
    ...
}
 
void fctCOM1()
{
    //Avec une periodicité je lance la commande Commande declaré dans la dll
    Commande(portcom1, données)
}
 
void fctCOM2()
{
    //Avec une periodicité je lance la commande Commande declaré dans la dll
    Commande(portcom2, données)
}
.....
 
////////////////////DLL de communication
 
///DLL.h
typedef struct
        {
            int comport;
            int read_write;
            int N_codes;
 
            int data_length[USER_MAX_CODES];
            SHORTINT codes[USER_MAX_CODES];
            SHORTINT N_bytes[USER_MAX_CODES];
            BYTE *data_in[USER_MAX_CODES];
            BYTE *data_out[USER_MAX_CODES];
 
            int flag_com_busy;
 
        } COMMUNICATION;
 
///DLL.c
 
//Variable globale 
COMMUNICATION comm
 
void Command(int comport,int (*callback_function)(int,int))
 //Remarque.. je passe en paramétré l'adresse d'une fonction de retour de la dll. c.a.d. que si on a fini on exécute cette fonction ou si il y a eu erreur on passe en paramétré un registre d'erreurs
{
   comm.flag_com_busy = BUSY;
 
   copie des datas dans la structure comm (je suis obligé de declares comm en variable globale car fin acknowledge et fin comm ont besoin des informations des cette structure entre autres le flag_com_busy) 
 
   allocation de mémoire
 
   acknowledge()
 
   si erreur on execute callback_function
}
 
void acknowledge()
{
   //programmation d'une interruption (CALLBACK) sur le port com pour fin_acknowledge()
 
   //Envoi des codes d'acknolewdge
 
   //si erreur on execute callback_function
} 
 
void CALLBACK fin_acknowledge()
{
    //lecture de réponse
 
    debut_com()
 
    //si erreur on execute callback_function
}
 
void debut_com()
{
   //libération mémoire data_in 
 
   //programmation d'une interruption sur le port com pour fin_com()    
 
   //envoi des codes et datas
 
   //si erreur on execute callback_function
}
 
void CALLBACK fin_com()
{
   //lecture des donnés
 
   //raz des structures et buffers
 
   //libération mémoire data_out
 
   flag_com_busy = READY;
 
   //on execute callback_function avec l'adresse des données de sortie
 
}

Voilà la structure globale de mon programme, mais le problème est que si j'ai plusieurs ports COM qui exécutent la même fonction Commande, je ne sais pas ce qui se passe au niveau de ma variable globale de dll comm.

Le deuxième problème c'est que je donne l'adresse d'une fonction de retour en paramètre, mais je voudrais avoir le même prototype de fonction une seule fois, mais que, pour chaque port COM s'exécute indépendamment.

L'idéal serait avoir une dll par port COM et une fonction de retour par port COM completement indépendantes, mais je ne sais pas comment faire cela.

[Médinoc]

Le problème est dans le prototype de CmtScheduleThread() et du callback.

Tu dois leur rajouter un paramètre que ta fonction devra transmettre directement à la fonction callback. Un paramètre du type intptr_t (ou INT_PTR, ou LONG_PTR, ou LPARAM sous Windows) ou bien void* (ou LPVOID sous Windows).

[ppfromero]

Merci pour ta réponse Médinoc:

Je vois pas très bien à quoi va servir le passage de ce pointeur en paramètre, mais effectivement je peux faire passer un pointeur à ma fonction dont voici le prototype:

Code :

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

1
2
 
int CmtScheduleThreadPoolFunction (int poolHandle, ThreadFunctionPtr threadFunction, void *threadFunctionData, int *threadFunctionID);

Après avoir consulté les gars de National Instruments( car je rappel que je travaille avec un compilateur CVI de NI) j'ai toujours les mêmes problèmes:

1. Si je lance sur plusieurs ports COM la fonction Commande de ma dll, ma structure globale à la dll, communication, va être utilisé par tous les ports COM créant une incompatibilité.
2. Le callback du retour va aussi être utilisé par tous les port COM donc attente!!.

Par rapport à ce qui vous m'avez conseillez:

Je pourrait bien créer un contexte pour chaque port COM a partir de mon programme principal mais je voudrais allouer la mémoire dynamiquement par souci de économie de la mémoire c.a.d que je ne veut pas dans mon programme principal avoir des déclarations du type:
ma_structure_pour_chaque_port[NB_MAX_PORTS]
Car cela représente de la mémoire gaspillé dans le cas ou j'aurais un seul port COM de connecté.
Un autre problème lié à cela c'est que chaque port COM devra attendre une éventuelle utilisation de la dll par un autre port COM.
Voilà n'hésitez pas à poster toute remarque et bonne!!!
Merci