Est-il possible d'affecter une priorité à un module ?

**souviron34** · 08/10/2013, 15h42

Envoyé par cartman_94

Je peux pas être plus clair sur ce que je dois faire.

ben je sais pas moi, ce qu'est "un bout de code" ou "un step de la machine"...

Pour moi, un "step de la machine" c'est un cycle. Mais je suppose que tu veux parlr d'un pas d'une traceuse ou d'une imprinate ou autre chose, non ? (avec gpio, je suppose)

**mith06** · 08/10/2013, 15h48

Merci.

Mesurer le temps d’exécution avec un oscillo est une BONNE idée.

Pour faire ce que tu viens de décrire il tu faut soit un OS temps réel soit pas d'OS du tout (Je pense que sur ton ancienne carte il n'y avait pas d'OS du tout).

Le OS genre Linux/Windows ne peuvent pas te garantir qu'un programme ne sera pas préempté ou qu'une interruption sera immédiatement traitée.

Même si tu arrives en bidouillant a garantir une durée d’exécution ton code. Le temps de réponse de l'interruption ne le sera pas.

**cartman_94** · 10/10/2013, 14h23

Bon j'ai avancé un peux sur le sujet.

@souviron34 : j'ai refait un morceau du code qu'exécute ma machine dans le handler (bien entendu c'est qu'une petite partie mais l'idée est la), afin de voir plus précisément ce que je recherche.

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
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/gpio.h>
 
#define MXC_INT_EPIT1 88 	//numéro d'interruption EPIT
 
#define IRQ_Time 32 	// Sortie sur GPIO_0 : Oscillo
#define HVL 33			// Sortie sur GPIO_1
#define HVE 34			// Sortie sur GPIO_2
#define HVI 59			// Sortie sur GPIO_7 : Utilisable uniquement en Output
#define Trig 9			// Sortie sur GPIO_4
 
#define HVLEOC 41			// Entrée sur GPIO_5
#define HVEEOC 42			// Entrée sur GPIO_6
#define HVIEOC 35			// Entrée sur GPIO_3
 
int m_TimePeriode = 0;
int m_CurrentStep = 0;
int m_SLoadTimeHVL = 300;	//150ms
int m_SLoadTimeHVE = 100;	//50ms
int m_SLoadTimeHVI = 300;	//150ms
int m_SPeriode = 500;		//250ms
 
	//Handler 
static irqreturn_t gpio_handler(int irq, void * ident)
{
	gpio_set_value(IRQ_Time, 1);
 
		//Action depends of step
	switch (m_CurrentStep)
	{
			//Initialisation des GPIO
		case 0 :
			gpio_set_value(HVL, 0);
			gpio_set_value(HVE, 0);
			gpio_set_value(HVI, 1);
			m_CurrentStep++;
		break;
 
			//
		case 1 :
			if (gpio_get_value(HVIEOC) == 0)
				{
				gpio_set_value(HVL, 0);
				gpio_set_value(HVE, 0);
				gpio_set_value(HVI, 0);
				printk("HVIEOC = 0\n");
				m_CurrentStep = 4;
				}
			gpio_set_value(HVL, 1);
			if(m_TimePeriode <= (m_SLoadTimeHVL - m_SLoadTimeHVE)) break;
			gpio_set_value(HVE, 1);
 
			m_CurrentStep++;
		break;
 
			//
		case 2 :
			if ((gpio_get_value(HVLEOC) == 0) && (gpio_get_value(HVIEOC) == 0))
				{
				gpio_set_value(HVL, 0);
				gpio_set_value(HVE, 0);
				gpio_set_value(HVI, 0);
				printk("HVLEOC = 0\n");
				m_CurrentStep = 4;
				}
			if(m_TimePeriode <= m_SLoadTimeHVL) break;
			gpio_set_value(HVL, 0);
			gpio_set_value(HVE, 0);
			gpio_set_value(Trig, 1);
			m_CurrentStep++;
		break;
 
			//Trig à 0
		case 3 :
			gpio_set_value(Trig, 0);
			m_CurrentStep++;
		break;
 
			//Wait 250ms
		case 4 :
			if(m_TimePeriode <= m_SPeriode) break; 
			m_CurrentStep++;
 
			//Reset
		case 5 :
			m_CurrentStep = 0;
			m_TimePeriode = 0;
		break;
	}
 
	m_TimePeriode++;
	gpio_set_value(IRQ_Time, 0);
 
	return IRQ_HANDLED;
}
 
 
	//Module Init
static int __init gpio_init (void)
{
  int err;
 
	//allocation mémoire pour le IRQ_Time
  if ((err = gpio_request(IRQ_Time, THIS_MODULE->name)) != 0)
    return err;
	//allocation mémoire pour HVL
  if ((err = gpio_request(HVL, THIS_MODULE->name)) != 0)
	{
		gpio_free(IRQ_Time);
		return err;
	}
	//allocation mémoire pour le HVE
  if ((err = gpio_request(HVE, THIS_MODULE->name)) != 0)
	{
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		return err;
	}
	//allocation mémoire pour le HVI
  if ((err = gpio_request(HVI, THIS_MODULE->name)) != 0)
	{
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		return err;
	}
	//allocation mémoire pour le Trig
  if ((err = gpio_request(Trig, THIS_MODULE->name)) != 0)
	{
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		return err;
	}
	//allocation mémoire pour HVLEOC
  if ((err = gpio_request(HVLEOC, THIS_MODULE->name)) != 0)
	{
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		return err;
	}
	//allocation mémoire pour HVEEOC
  if ((err = gpio_request(HVEEOC, THIS_MODULE->name)) != 0)
	{
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		return err;
	}
	//allocation mémoire pour HVIEOC
  if ((err = gpio_request(HVIEOC, THIS_MODULE->name)) != 0)
	{    
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		return err;
	}
 
	//direction IRQ_Time : Output
  if ((err = gpio_direction_output(IRQ_Time,1)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	}
  	//direction HVL : Output
  if ((err = gpio_direction_output(HVL,1)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	  }
	//direction HVE : Output
  if ((err = gpio_direction_output(HVE,1)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	  }
	//direction HVI : Output
  if ((err = gpio_direction_output(HVI,1)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	  }
  	//direction Trig : Output
  if ((err = gpio_direction_output(Trig,1)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	  }
  //direction HVLEOC : Input
  if ((err = gpio_direction_input(HVLEOC)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	  }
  //direction HVEEOC : Input
  if ((err = gpio_direction_input(HVEEOC)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	  }
	//direction HVIEOC : Input
  if ((err = gpio_direction_input(HVIEOC)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	  }
 
 
  //declaration IRQ
  if ((err = request_irq(MXC_INT_EPIT1, gpio_handler, IRQF_SHARED, THIS_MODULE->name, THIS_MODULE->name)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	  }
 
  return 0; 
}
 
	//Module Exit
static void __exit gpio_exit (void)
{
	free_irq(MXC_INT_EPIT1, THIS_MODULE->name);	
	gpio_free(IRQ_Time);
	gpio_free(HVL);
	gpio_free(HVE);
	gpio_free(HVI);
	gpio_free(Trig);
	gpio_free(HVLEOC);
	gpio_free(HVEEOC);
	gpio_free(HVIEOC);
}
 
module_init(gpio_init);
module_exit(gpio_exit);
MODULE_LICENSE("GPL");

Nouvelle problématique :
Je souhaite maintenant envoyé des données de ma carte à mon pc (valeur de mes sorties). J'ai pensé faire une sorte de client(pc)/serveur(carte) en tcp/ip.

Vu que sur ma carte, je suis au niveau kernel j'ai utilisé des ksocket pour communiquer avec mon pc. Avant d'implémenter la comm tcp/ip dans mon module, j'ai testé la comm entre le kernel et mon pc (user space).

C'est magique ça communique.... mais pas exactement comme je le veux (quelques bugs d'affichage). lorsque je veux envoyé un message à partir du client, j'obtiens ceci :

client: serveur: Hello, this is from a kernel thread��)
coucou
client: serveur: coucou
slt
client: serveur: slt
bonjour
client: serveur: bonjour

on voit qu'il affiche a chaque fois "client : serveur : texte". Il faudrait qu'il affiche soit client : quand c'est le client qui envoi un message ou serveur : qu'on le client recoit un message et non les 2.

je vous met le code de mon client.c :

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
    #include <sys/types.h>
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <arpa/inet.h>
    #include <unistd.h>
	#include <stdio.h>
    #include <string.h>
    #define INVALID_SOCKET -1
    #define SOCKET_ERROR -1
    #define closesocket(s) close(s)
    typedef int SOCKET;
    typedef struct sockaddr_in SOCKADDR_IN;
    typedef struct sockaddr SOCKADDR;
 
#include <stdio.h>
#include <stdlib.h>
#define PORT 4444
 
int main(void)
{
    int erreur = 0;
    SOCKET sock;
    SOCKADDR_IN sin;
    char buffer[256];
 
    /* Si les sockets Windows fonctionnent */
    if(!erreur)
    {
        /* Création de la socket */
        sock = socket(AF_INET, SOCK_STREAM, 0);
 
        /* Configuration de la connexion */
        sin.sin_addr.s_addr = inet_addr("192.168.101.2");
        sin.sin_family = AF_INET;
        sin.sin_port = htons(PORT);
 
	while (1)
	{
        /* Si l'on a réussi à* se connecter */
        connect(sock, (SOCKADDR*)&sin, sizeof(sin));
		int pid;
        pid=fork();
  	 	if (pid == 0) 
        {
			 /* fils */      
	       	 while(1) 
			{
			printf("client: ");
			scanf("%s",buffer);
        	send(sock,buffer,sizeof(buffer),0);//envoi de ce qu'on a ecrit au serveur
			}         
        }
 
        else
        {
           	/*pere*/
			while(1) 
			{
	     recv(sock,buffer,sizeof(buffer),0);//reception des données du serveur
	     printf("serveur: %s\n",buffer);
	     	} 
        }
	}
        /* On ferme la socket */
        closesocket(sock);
    }
    /* On attend que l'utilisateur tape sur une touche, puis on ferme */
    getchar();
    return EXIT_SUCCESS;
}

Si vous pouvez m'aidez a corriger ces bugs d'affichage sur mon client.c

Merci d'avance

**gangsoleil** · 10/10/2013, 15h23

Envoyé par cartman_94

je vous met le code de mon client.c :

Au risque de paraitre un brin mechant, c'est vraiment le code que tu executes ?

A quoi sert erreur ?
Le commentaire parle de sockets windows, alors que tu nous parles de kernel linux depuis le debut... Ton client est sur une machine distante windows ? Mais en quoi utilises-tu des sockets windows ?
A quoi sert le while(1) autour du fork ? A creer de nouveaux processus en continu en cas d'erreur ? Si c'est bien le cas, tu ne crois pas que si ton programme n'est pas en mesure de creer un seul processus fils, le fait de boucler infiniment sur fork() est une mauvaise idee ?

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
    #include <sys/types.h>
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <arpa/inet.h>
    #include <unistd.h>
	#include <stdio.h>
    #include <string.h>
    #define INVALID_SOCKET -1
    #define SOCKET_ERROR -1
    #define closesocket(s) close(s)
    typedef int SOCKET;
    typedef struct sockaddr_in SOCKADDR_IN;
    typedef struct sockaddr SOCKADDR;
 
#include <stdio.h>
#include <stdlib.h>
#define PORT 4444
 
int main(void)
{
    int erreur = 0;
    SOCKET sock;
    SOCKADDR_IN sin;
    char buffer[256];
 
    /* Si les sockets Windows fonctionnent */
    if(!erreur)
    {
        /* Création de la socket */
        sock = socket(AF_INET, SOCK_STREAM, 0);
 
        /* Configuration de la connexion */
        sin.sin_addr.s_addr = inet_addr("192.168.101.2");
        sin.sin_family = AF_INET;
        sin.sin_port = htons(PORT);
 
	while (1)
	{
        /* Si l'on a réussi à* se connecter */
        connect(sock, (SOCKADDR*)&sin, sizeof(sin));
		int pid;
        pid=fork();
  	 	if (pid == 0) 
        {
			 /* fils */      
	       	 while(1) 
			{
			printf("client: ");
			scanf("%s",buffer);
        	send(sock,buffer,sizeof(buffer),0);//envoi de ce qu'on a ecrit au serveur
			}         
        }
 
        else
        {
           	/*pere*/
			while(1) 
			{
	     recv(sock,buffer,sizeof(buffer),0);//reception des données du serveur
	     printf("serveur: %s\n",buffer);
	     	} 
        }
	}
        /* On ferme la socket */
        closesocket(sock);
    }
    /* On attend que l'utilisateur tape sur une touche, puis on ferme */
    getchar();
    return EXIT_SUCCESS;
}

[/QUOTE]
Et enfin, es-tu certain de vouloir faire un seul "client" dont le pere fasse le recv et le fils fasse le send ?

Je te conseille la lecture de beej's guide ou d'un autre tutoriel sur les sockets.

Enfin, vu que tu as des contraintes temporelles fortes, il semble pour le moins etrange d'utiliser TCP au lieu d'UDP.

**cartman_94** · 10/10/2013, 15h56

Bon ok, je suis qu'un simple amateur en C

Effectivement "erreur" ne sert a rien.

Et enfin, es-tu certain de vouloir faire un seul "client" dont le pere fasse le recv et le fils fasse le send ?

Pour ça j'ai pas de réponse, car je ne connais pas la meilleur solution.

Comme on peut le voir je ne maitrise pas trop (ou pas du tout) les processus...

Si vous pouvez me donnez des conseils sur comment faire pour recevoir et envoyer des données, sa serait génial

.

Autre remarque : scanf ne me permet pas de saisir du texte avec espace, donc j'ai utiliser gets et fgets mais mon compilateur me dit :"the `gets' function is dangerous and should not be used."
Quel est le risque d'utiliser gets ?

**grim7reaper** · 10/10/2013, 16h17

Envoyé par cartman_94

Autre remarque : scanf ne me permet pas de saisir du texte avec espace

Si, il le permet.

Envoyé par cartman_94

donc j'ai utiliser gets et fgets

fgets

gets, JAMAIS

Envoyé par cartman_94

mais mon compilateur me dit :"the `gets' function is dangerous and should not be used."
Quel est le risque d'utiliser gets ?

Et il a bien raison.
Le risque ? Ça (qui peut mener à ça).
Suffit de lire la page de man.

**gangsoleil** · 10/10/2013, 16h58

Envoyé par cartman_94

Bon ok, je suis qu'un simple amateur en C

Aucun soucis a ca, nous sommes tous passés par là. C'est d'ailleurs un bon debut que de venir demander de l'aide sur un forum.

Si vous pouvez me donnez des conseils sur comment faire pour recevoir et envoyer des données, sa serait génial

.

Il existe de tres nombreuses methodes, plus ou moins performantes, permettant de transferer des volumes de donnees plus ou moins importants.
Base de donnee, fichier, memoire partagee, sockets, pipes nommes... en sont quelques uns. On appelle ca des IPC : Inter Process Communication.

En general, on commence par identifier les besoins : volumetrie, frequence des mises a jour, importance de la perte d'une donee, volatilite des donnees, ...

Je pense que tu as besoin d'envoyer des donnees (tres) souvent, en petite quantite, mais je ne sais pas si c'est grave si tu perds une donnee ou non, ou si cela pose un probleme qu'elles arrivent dans le desordre ou non.

Selon, tu vas t'orienter vers la memoire partagee ou bien les sockets UDP.

Autre remarque : scanf ne me permet pas de saisir du texte avec espace

si si : http://xrenault.developpez.com

**souviron34** · 10/10/2013, 17h38

Envoyé par cartman_94

Bon ok, je suis qu'un simple amateur en C

Et, outre les remarques ci-dessus de mes éminents collègues, je te ferais remarquer, et je ré-itère avec ta déclaration citée, que justement modifier le kernel ou certains de ses paramètres, nous assurer que tu ne peux pas faire autrement vu le temps mis, etc etc, et autres choses est une démache totalement irrationnelle dans un tel contexte...

**cartman_94** · 11/10/2013, 15h17

Bon j'ai réussi a avancer un peu sur la communication TCP/IP.

J'ai un petit problème au niveau de l'envoi d'une donnée.
je veux que mon serveur (carte) me renvoi la valeur de ma sortie HVL toute les 30ms.

je reçoit constamment sur mon client HVL = 0, alors que je devrais avoir HVL = 1 de temps en temps. J'ai vérifié sur un oscillo ma sortie HVL est bien a 1 (au moins 150ms) donc je devrais bien avoir sur mon client HVL = 1 (j'ai pensé a vérifier avant de poster quand même

)

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
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/gpio.h>
 
#include <linux/kernel.h>   
#include <linux/string.h>   
#include <linux/socket.h>   
#include <linux/net.h>   
#include <net/sock.h>   
#include <asm/processor.h>   
#include <asm/uaccess.h>     
#include "ksocket.h"   
 
#define MXC_INT_EPIT1 88 	//numéro d'interruption EPIT
 
#define IRQ_Time 32 	// Sortie sur GPIO_0 : Oscillo
#define HVL 33			// Sortie sur GPIO_1
#define HVE 34			// Sortie sur GPIO_2
#define HVI 59			// Sortie sur GPIO_7 : Utilisable uniquement en Output
#define Trig 9			// Sortie sur GPIO_4
 
#define HVLEOC 41			// Entrée sur GPIO_5
#define HVEEOC 42			// Entrée sur GPIO_6
#define HVIEOC 35			// Entrée sur GPIO_3
 
int m_TimePeriode = 0;
int m_CurrentStep = 0;
int m_SLoadTimeHVL = 300;	//150ms
int m_SLoadTimeHVE = 100;	//50ms
int m_SLoadTimeHVI = 300;	//150ms
int m_SPeriode = 500;		//250ms
 
 
	//Handler 
static irqreturn_t gpio_handler(int irq, void * ident)
{
 
	gpio_set_value(IRQ_Time, 1);
 
		//Action depends of step
	switch (m_CurrentStep)
	{
			//Initialisation des GPIO
		case 0 :
			gpio_set_value(HVL, 0);
			gpio_set_value(HVE, 0);
			gpio_set_value(HVI, 1);
			m_CurrentStep++;
		break;
 
			//
		case 1 :
			if (gpio_get_value(HVIEOC) == 0)
				{
				gpio_set_value(HVL, 0);
				gpio_set_value(HVE, 0);
				gpio_set_value(HVI, 0);
				printk("HVIEOC = 0\n");
				m_CurrentStep = 4;
				}
			gpio_set_value(HVL, 1);
			if(m_TimePeriode <= (m_SLoadTimeHVL - m_SLoadTimeHVE)) break;
			gpio_set_value(HVE, 1);
 
			m_CurrentStep++;
		break;
 
			//
		case 2 :
			if ((gpio_get_value(HVLEOC) == 0) && (gpio_get_value(HVIEOC) == 0))
				{
				gpio_set_value(HVL, 0);
				gpio_set_value(HVE, 0);
				gpio_set_value(HVI, 0);
				printk("HVLEOC = 0\n");
				m_CurrentStep = 4;
				}
			if(m_TimePeriode <= m_SLoadTimeHVL) break;
			gpio_set_value(HVL, 0);
			gpio_set_value(HVE, 0);
			gpio_set_value(Trig, 1);
			m_CurrentStep++;
		break;
 
			//Trig à 0
		case 3 :
			gpio_set_value(Trig, 0);
			m_CurrentStep++;
		break;
 
			//Wait 250ms
		case 4 :
			if(m_TimePeriode <= m_SPeriode) break; 
			m_CurrentStep++;
 
			//Reset
		case 5 :
			m_CurrentStep = 0;
			m_TimePeriode = 0;
		break;
	}
	m_TimePeriode++;
	gpio_set_value(IRQ_Time, 0);
 
	return IRQ_HANDLED;
}
 
char *inet_ntoa(struct in_addr in); 
 
static int port = 4444;   
module_param(port, int, 0444); 
 
	//Fonction Server TCP/IP
int tcp_srv(void *arg)   
{   
    ksocket_t sockfd_srv, sockfd_cli;   
    struct sockaddr_in addr_srv;   
    struct sockaddr_in addr_cli;   
    char buf[1024];   
    int addr_len, len;   
 
    sprintf(current->comm, "ksocket"); /* kernel thread name*/     
 
    sockfd_srv = sockfd_cli = NULL;   
    memset(&addr_cli, 0, sizeof(addr_cli));   
    memset(&addr_srv, 0, sizeof(addr_srv));   
    addr_srv.sin_family = AF_INET;   
    addr_srv.sin_port = htons(port);   
    addr_srv.sin_addr.s_addr = INADDR_ANY;   
    addr_len = sizeof(struct sockaddr_in);   
 
    sockfd_srv = ksocket(AF_INET, SOCK_STREAM, 0);   
    //ksocket_debug("sockfd_srv = 0x%p\n", sockfd_srv);   
    if (sockfd_srv == NULL)   
    {   
        printk("socket failed\n");   
        return -1;   
    }   
    if (kbind(sockfd_srv, (struct sockaddr *)&addr_srv, addr_len) < 0)   
    {   
        printk("bind failed\n");   
        return -1;   
    }   
 
    if (klisten(sockfd_srv, 10) < 0)   
    {   
        printk("listen failed\n");   
        return -1;   
    }   
 
    sockfd_cli = kaccept(sockfd_srv, (struct sockaddr *)&addr_cli, &addr_len);   
    if (sockfd_cli == NULL)   
    {   
        printk("accept failed\n");   
        return -1;   
    }   
    else   
        printk("sockfd_cli = 0x%p\n", sockfd_cli);   
    printk("got connected from : %s %d\n", inet_ntoa(addr_cli.sin_addr), ntohs(addr_cli.sin_port));   
 
 
    while (1)   
    {   
 
		/*if(gpio_get_value(HVL)==1)
		{*/
		len = sprintf(buf, "HVL : %d \n", gpio_get_value(HVL));
    	ksend(sockfd_cli, buf, len, 0);   
        if (memcmp(buf, "quit", 4) == 0)  break;   
		msleep(30);
    }   
 
    kclose(sockfd_cli);   
    kclose(sockfd_srv);   
 
    return 0;   
} 
 
	//Module Init
static int __init gpio_init (void)
{
  int err;
 
	//allocation mémoire pour le IRQ_Time
  if ((err = gpio_request(IRQ_Time, THIS_MODULE->name)) != 0)
    return err;
	//allocation mémoire pour HVL
  if ((err = gpio_request(HVL, THIS_MODULE->name)) != 0)
	{
		gpio_free(IRQ_Time);
		return err;
	}
	//allocation mémoire pour le HVE
  if ((err = gpio_request(HVE, THIS_MODULE->name)) != 0)
	{
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		return err;
	}
	//allocation mémoire pour le HVI
  if ((err = gpio_request(HVI, THIS_MODULE->name)) != 0)
	{
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		return err;
	}
	//allocation mémoire pour le Trig
  if ((err = gpio_request(Trig, THIS_MODULE->name)) != 0)
	{
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		return err;
	}
	//allocation mémoire pour HVLEOC
  if ((err = gpio_request(HVLEOC, THIS_MODULE->name)) != 0)
	{
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		return err;
	}
	//allocation mémoire pour HVEEOC
  if ((err = gpio_request(HVEEOC, THIS_MODULE->name)) != 0)
	{
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		return err;
	}
	//allocation mémoire pour HVIEOC
  if ((err = gpio_request(HVIEOC, THIS_MODULE->name)) != 0)
	{    
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		return err;
	}
 
	//direction IRQ_Time : Output
  if ((err = gpio_direction_output(IRQ_Time,1)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	}
  	//direction HVL : Output
  if ((err = gpio_direction_output(HVL,1)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	  }
	//direction HVE : Output
  if ((err = gpio_direction_output(HVE,1)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	  }
	//direction HVI : Output
  if ((err = gpio_direction_output(HVI,1)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	  }
  	//direction Trig : Output
  if ((err = gpio_direction_output(Trig,1)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	  }
  //direction HVLEOC : Input
  if ((err = gpio_direction_input(HVLEOC)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	  }
  //direction HVEEOC : Input
  if ((err = gpio_direction_input(HVEEOC)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	  }
	//direction HVIEOC : Input
  if ((err = gpio_direction_input(HVIEOC)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	  }
 
 
  //declaration IRQ
  if ((err = request_irq(MXC_INT_EPIT1, gpio_handler, IRQF_SHARED, THIS_MODULE->name, THIS_MODULE->name)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	  }
 
	//Init de la communication
	kernel_thread(tcp_srv, NULL, 0);     
    printk("ksocket tcp srv init ok\n");   
 
  return 0; 
}
 
	//Module Exit
static void __exit gpio_exit (void)
{
	free_irq(MXC_INT_EPIT1, THIS_MODULE->name);	
	//On libere les GPIO
	gpio_free(IRQ_Time);
	gpio_free(HVL);
	gpio_free(HVE);
	gpio_free(HVI);
	gpio_free(Trig);
	gpio_free(HVLEOC);
	gpio_free(HVEEOC);
	gpio_free(HVIEOC);
	//On affiche la fermeture de la communication
	printk("ksocket tcp srv exit\n");  
}
 
module_init(gpio_init);
module_exit(gpio_exit);
MODULE_LICENSE("GPL");

Je n'aarive pas a voir d'ou viens le problème

**gangsoleil** · 11/10/2013, 16h02

Bonjour,

Je ne sais pas ou se situe ton erreur, mais je rebondis sur ce point :

Envoyé par cartman_94

Bon j'ai réussi a avancer un peu sur la communication TCP/IP.

Sauf erreur de ma part, tu fais des choses qui ont besoin de performances assurees, c'est a dire que tu veux etre certain d'executer ton code dans un temps inferieur a X.

Dans ce cadre, l'utilisation de TCP est un peu etrange : ce protocole t'assure qu'un paquet envoye sera recu, ainsi que l'ordre des paquets (entre autre). C'est tres utile dans certains cas, mais dans ton cas, une perte de paquet risque d'etre catastrophique :
A envoie un paquet au serveur B. A ouvre donc une fenetre de temps pendant laquelle il attends le ACK (acquitement).
Le paquet se perd.
A la fin de la fenetre, A se rend compte qu'il n'a pas eu son acquitement. Il va donc re-emettre le paquet. Celui-ci passe, et B emet donc le fameux ACK attendu par A.

Seulement voila, si tu fais ca avec une fenetre de temps un peu grande, et que la mesure suivante est emise avant la re-emission du paquet -- et que tout se passe bien, TCP va supprimer le paquet contenant la mesure 2 afin qu'il soit re-emis.

Bref, selon les cas, tu peux perdre beaucoup de temps, ce qui semble potentiellement problematique dans ton cas.

Bien sur, si toutes ces communications sont en locales, la probabilite de perte est infime, mais non nulle, et tes communications pourront etre perturbees par d'autres communications.

A toutes fins utiles, il existe sous certains OS l'option SO_USE_LOOPBACK ou quelque chose comme ca, qui te permet de ne pas "descendre" jusqu'a la carte reseau mais de rester dans l'OS.

Pour des echanges rapides et de tres faible volumetrie, je privilegierai dans la mesure du possible le segment de memoire partagee (*).

(*) Attention a ce que ton programme ne crash pas en cas de suppression du segment, mais a ce qu'il le reconstruise.

**cartman_94** · 17/10/2013, 15h19

Me revoila avec de nouveaux problèmes.

@gangsoleil : Je suis contraint d'utiliser le TCP pour des raison de sécurité au niveau des paquets émis et reçus

J'arrive a communiquer entre ma carte et mon pc (je viens de créer une ihm client sous c#

) en recevant toutes les 30ms les valeurs de mes sorties sur mon ihm.

Maintenant il faudrait que je puisse envoyer les valeurs de mes sorties tte les 30ms (server vers client) et en même temps lui envoyer une commande pour saisir un mode de fonctionnement (client vers server).

Mon problème se situe au niveau de mon server ou je n'arrive pas savoir comment gérer l'envoi et la réception simultanément (actuellement il communique chacun leur tour). On m'a parlé des threads, mais je ne sais pas trop m'en servir.

Mon 2eme pb se situe aussi sur mon server. lorsque je coupe la comm entre le client et le server tous part en sucette (

j'en ai marre de redémarrer ma carte a chaque coup), je pense que je ferme mal ma socket mais je ne vois pas ou.

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
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/gpio.h>
 
#include <linux/kernel.h>   
#include <linux/string.h>   
#include <linux/socket.h>   
#include <linux/net.h>   
#include <net/sock.h>   
#include <asm/processor.h>   
#include <asm/uaccess.h>     
#include "ksocket.h"   
 
#define MXC_INT_EPIT1 88 	//numéro d'interruption EPIT
 
#define IRQ_Time 32 	// Sortie sur GPIO_0 : Oscillo
#define HVL 33			// Sortie sur GPIO_1
#define HVE 34			// Sortie sur GPIO_2
#define HVI 59			// Sortie sur GPIO_7 : Utilisable uniquement en Output
#define Trig 9			// Sortie sur GPIO_4
 
#define HVLEOC 41			// Entrée sur GPIO_5
#define HVEEOC 42			// Entrée sur GPIO_6
#define HVIEOC 35			// Entrée sur GPIO_3
 
int m_TimePeriode = 0;
int m_CurrentStep = 0;
int m_SLoadTimeHVL = 300;	//150ms
int m_SLoadTimeHVE = 100;	//50ms
int m_SLoadTimeHVI = 300;	//150ms
int m_SPeriode = 500;		//250ms
 
int m_Val_HVL = 0;
int m_Val_HVE = 0;
int m_Val_HVI = 0;
int m_Val_Trig = 0;
 
ksocket_t m_SockfdSrv, m_SockfdCli; 
 
struct Commande{
int m_Stop;
int m_Start;
int m_Manuel;
} Mode;
 
 
 
 
	//Handler 
static irqreturn_t gpio_handler(int irq, void * ident)
{
 
	gpio_set_value(IRQ_Time, 1);
 
 
			//Action depends of step
		switch (m_CurrentStep)
		{
				//Initialisation des GPIO
			case 0 :
					//Si Mode Stop ou Manuel on met en pause le systeme
				if (Mode.m_Stop == 1 || Mode.m_Manuel == 1)
				{
					m_CurrentStep = 4;
				}	
					//Si Mode Start on continu
				if (Mode.m_Start == 1)
				{
					gpio_set_value(HVL, 0);
					gpio_set_value(HVE, 0);
					gpio_set_value(HVI, 1);
					m_CurrentStep++;
				}
			break;
 
				//
			case 1 :
				if (gpio_get_value(HVIEOC) == 0)
				{
					gpio_set_value(HVL, 0);
					gpio_set_value(HVE, 0);
					gpio_set_value(HVI, 0);
					printk("HVIEOC = 0\n");
					m_CurrentStep = 4;
				}
				gpio_set_value(HVL, 1);
				if(m_TimePeriode <= (m_SLoadTimeHVL - m_SLoadTimeHVE)) break;
				gpio_set_value(HVE, 1);
 
				m_CurrentStep++;
			break;
 
				//
			case 2 :
				if ((gpio_get_value(HVLEOC) == 0) && (gpio_get_value(HVIEOC) == 0))
				{
					gpio_set_value(HVL, 0);
					gpio_set_value(HVE, 0);
					gpio_set_value(HVI, 0);
					printk("HVLEOC = 0\n");
					m_CurrentStep = 4;
				}
				if(m_TimePeriode <= m_SLoadTimeHVL) break;
				gpio_set_value(HVL, 0);
				gpio_set_value(HVE, 0);
				gpio_set_value(Trig, 1);
				m_CurrentStep++;
			break;
 
				//Trig à 0
			case 3 :
				gpio_set_value(Trig, 0);
				m_CurrentStep++;
			break;
 
				//Wait 250ms
			case 4 :
				if(m_TimePeriode <= m_SPeriode) break; 
				m_CurrentStep++;
 
				//Reset
			case 5 :
				m_CurrentStep = 0;
				m_TimePeriode = 0;
			break;
		}
		m_TimePeriode++;
 
		gpio_set_value(IRQ_Time, 0);
 
 
	return IRQ_HANDLED;
}
 
char *inet_ntoa(struct in_addr in); 
 
static int port = 4444;   
module_param(port, int, 0444); 
static int prog_run;
 
	//Fonction Server TCP/IP
int tcp_srv(void *arg)   
{   
 
    struct sockaddr_in addr_srv;   
    struct sockaddr_in addr_cli;   
    int buf[1024];   
    int addr_len;
	int len; 
	int jeton = 1;  
 
    sprintf(current->comm, "ksocket"); /* kernel thread name*/     
 
    m_SockfdSrv = m_SockfdCli = NULL;   
    memset(&addr_cli, 0, sizeof(addr_cli));   
    memset(&addr_srv, 0, sizeof(addr_srv));   
    addr_srv.sin_family = AF_INET;   
    addr_srv.sin_port = htons(port);   
    addr_srv.sin_addr.s_addr = INADDR_ANY;   
    addr_len = sizeof(struct sockaddr_in);   
 
    m_SockfdSrv = ksocket(AF_INET, SOCK_STREAM, 0);   
    //ksocket_debug("m_SockfdSrv = 0x%p\n", m_SockfdSrv);   
    if (m_SockfdSrv == NULL)   
    {   
        printk("socket failed\n");   
        return -1;   
    }   
    if (kbind(m_SockfdSrv, (struct sockaddr *)&addr_srv, addr_len) < 0)   
    {   
        printk("bind failed\n");   
        return -1;   
    }   
 
    if (klisten(m_SockfdSrv, 10) < 0)   
    {   
        printk("listen failed\n");   
        return -1;   
    }   
 
    m_SockfdCli = kaccept(m_SockfdSrv, (struct sockaddr *)&addr_cli, &addr_len);   
    if (m_SockfdCli == NULL)   
    {   
        printk("accept failed\n");   
        return -1;   
    }   
    else   
    printk("m_SockfdCli = 0x%p\n", m_SockfdCli);   
    printk("got connected from : %s %d\n", inet_ntoa(addr_cli.sin_addr), ntohs(addr_cli.sin_port));   
 
 
    while (prog_run == 1)   
    {   
			//Reception
		if (jeton == 1 )
		{	
			memset(buf, 0, sizeof(buf));
			len = krecv(m_SockfdCli, buf, sizeof(buf), 0);   
        	//printk("Message Client : Mode saisi par le Client : %s \n", buf);
 
								//Mode Stop
			if (buf[0] == '0' && buf[1] == '0' && buf[2] == '1')
			{ 
				printk("Mode Stop Activé \n");
 
					//Selection du mode Stop
				Mode.m_Stop = 1;
				Mode.m_Start = 0;
				Mode.m_Manuel = 0;
 
 
			}
 
				//Mode Start
			if (buf[0] == '0' && buf[1] == '1' && buf[2] == '0')
			{ 
				printk("Mode Start Activé \n");
 
					//Selection du mode Start
				Mode.m_Stop = 0;
				Mode.m_Start = 1;
				Mode.m_Manuel = 0;
 
			}
 
				//Mode Manuel
			if (buf[0] == '1' && buf[1] == '0' && buf[2] == '0')
			{
				printk("Mode Manuel Activé \n");
 
					//Selection du mode Manuel
				Mode.m_Stop = 0;
				Mode.m_Start = 0;
				Mode.m_Manuel = 1;
 
				m_Val_HVL = (int)buf[3];
				m_Val_HVL = m_Val_HVL - 48; 
 
				m_Val_HVE = (int)buf[4];
				m_Val_HVE = m_Val_HVE - 48;
 
				m_Val_HVI = (int)buf[5];
				m_Val_HVI = m_Val_HVI - 48; 
 
				m_Val_Trig = (int)buf[6];
				m_Val_Trig = m_Val_Trig - 48;
 
				gpio_set_value(HVL,m_Val_HVL);
				gpio_set_value(HVE,m_Val_HVE);
				gpio_set_value(HVI,m_Val_HVI);
				gpio_set_value(Trig,m_Val_Trig);
 
 
			}
			jeton = 0;
		}
			//Envoi
		else 
		{
			if (Mode.m_Start == 1)
			{
				buf[0] =  0;
				buf[1] =  1;
				buf[2] =  0;
			}
 
			if (Mode.m_Stop == 1)
			{
				buf[0] =  0;
				buf[1] =  0;
				buf[2] =  1;
			}
 
			if (Mode.m_Manuel == 1)
			{
				buf[0] =  1;
				buf[1] =  0;
				buf[2] =  0;
			}
 
			sprintf(buf, "%d%d%d%d%d%d\n", buf[0],buf[1],buf[2],gpio_get_value(HVLEOC),gpio_get_value(HVEEOC),gpio_get_value(HVIEOC));
			ksend(m_SockfdCli, buf, sizeof(buf), 0);
 
			jeton = 1;
		} 
	}
	 printk("exit tcp_srv\n");
 
    return 0;   
} 
 
 
	//Module Init
static int __init gpio_init (void)
{
  int err;
 
		//Mode Start a l'init
	Mode.m_Stop = 0;
	Mode.m_Start = 1;
	Mode.m_Manuel = 0;
 
	prog_run = 1;	
 
	//allocation mémoire pour le IRQ_Time
  if ((err = gpio_request(IRQ_Time, THIS_MODULE->name)) != 0)
    return err;
	//allocation mémoire pour HVL
  if ((err = gpio_request(HVL, THIS_MODULE->name)) != 0)
	{
		gpio_free(IRQ_Time);
		return err;
	}
	//allocation mémoire pour le HVE
  if ((err = gpio_request(HVE, THIS_MODULE->name)) != 0)
	{
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		return err;
	}
	//allocation mémoire pour le HVI
  if ((err = gpio_request(HVI, THIS_MODULE->name)) != 0)
	{
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		return err;
	}
	//allocation mémoire pour le Trig
  if ((err = gpio_request(Trig, THIS_MODULE->name)) != 0)
	{
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		return err;
	}
	//allocation mémoire pour HVLEOC
  if ((err = gpio_request(HVLEOC, THIS_MODULE->name)) != 0)
	{
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		return err;
	}
	//allocation mémoire pour HVEEOC
  if ((err = gpio_request(HVEEOC, THIS_MODULE->name)) != 0)
	{
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		return err;
	}
	//allocation mémoire pour HVIEOC
  if ((err = gpio_request(HVIEOC, THIS_MODULE->name)) != 0)
	{    
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		return err;
	}
 
	//direction IRQ_Time : Output
  if ((err = gpio_direction_output(IRQ_Time,1)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	}
  	//direction HVL : Output
  if ((err = gpio_direction_output(HVL,1)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	  }
	//direction HVE : Output
  if ((err = gpio_direction_output(HVE,1)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	  }
	//direction HVI : Output
  if ((err = gpio_direction_output(HVI,1)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	  }
  	//direction Trig : Output
  if ((err = gpio_direction_output(Trig,1)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	  }
  //direction HVLEOC : Input
  if ((err = gpio_direction_input(HVLEOC)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	  }
  //direction HVEEOC : Input
  if ((err = gpio_direction_input(HVEEOC)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	  }
	//direction HVIEOC : Input
  if ((err = gpio_direction_input(HVIEOC)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	  }
 
 
  //declaration IRQ
  if ((err = request_irq(MXC_INT_EPIT1, gpio_handler, IRQF_SHARED, THIS_MODULE->name, THIS_MODULE->name)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	  }
 
	//Init de la communication
	kernel_thread(tcp_srv, NULL, 0);     
    printk("ksocket tcp srv init ok\n");   
 
  return 0; 
}
 
	//Module Exit
static void __exit gpio_exit (void)
{
	prog_run = 0;
	//free_irq(MXC_INT_EPIT1, THIS_MODULE->name);	
	//On libere les GPIO
	gpio_free(IRQ_Time);
	gpio_free(HVL);
	gpio_free(HVE);
	gpio_free(HVI);
	gpio_free(Trig);
	gpio_free(HVLEOC);
	gpio_free(HVEEOC);
	gpio_free(HVIEOC);
	//On affiche la fermeture de la communication  
	if(NULL != m_SockfdCli)
	{
		kclose(m_SockfdCli);   
	}
	if(NULL != m_SockfdSrv)
	{
    	kclose(m_SockfdSrv); 
	}
	printk("ksocket tcp srv exit\n");  
}
 
module_init(gpio_init);
module_exit(gpio_exit);
MODULE_LICENSE("GPL");

une fois ces problèmes réglés, j'en aurait enfin fini avec tout ça

**cartman_94** · 18/10/2013, 15h20

Bonne nouvelle j'ai réussi a trouver comment gérer l'envoi et la réception grâce au kthread.

Par contre je n'arrive pas a savoir pourquoi ma socket se ferme mal. La dessus j'aurai besoin de votre aide

**cartman_94** · 22/10/2013, 15h52

Bon j'ai réussi a fermer ma ksocket correctement.

J'ai un nouveau problème concernant la transmission des données (sa finira jamais

)

Exemple :
Lorsque le client envoi une commande au serveur (1001010 qui correspond a un mode d'utilisation (bit 0 à 2) et les valeurs des sorties (bit 3 à 6)), le serveur prend bien en compte la requête du client (j'affiche la commande reçu) mais n'affecte pas immédiatement les valeurs de sortie demandé par le client. Il y a un temps de latence plus ou moins long (sa peut aller jusqu' a 30s) avant que les sorties prennent la valeur saisi par le client. Du coup lorsque le serveur envoi au client la valeur des sorties (toutes les 30ms), j'ai aussi ce temps de latence sur l'IHM client (un timer de 30ms affiche ce que le serveur me renvoi).

Je précise que je n'ai pas tous le temps ce problème, des fois ça marche comme je le voudrais.

Je sais que je n'ai pas un OS temps réel, donc l'OS ne peux me garantir un temps de réponse précis.

code serveur :

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
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/gpio.h>
 
#include <linux/kernel.h>   
#include <linux/string.h>   
#include <linux/socket.h>   
#include <linux/net.h>   
#include <net/sock.h>   
#include <asm/processor.h>   
#include <asm/uaccess.h>     
#include "ksocket.h"   
 
#include <linux/kthread.h> 
#include <linux/sched.h>
 
#define MXC_INT_EPIT1 88 	//numéro d'interruption EPIT
 
#define IRQ_Time 32 	// Sortie sur GPIO_0 : Oscillo
#define HVL 33			// Sortie sur GPIO_1
#define HVE 34			// Sortie sur GPIO_2
#define HVI 59			// Sortie sur GPIO_7 : Utilisable uniquement en Output
#define Trig 9			// Sortie sur GPIO_4
 
#define HVLEOC 41			// Entrée sur GPIO_5
#define HVEEOC 42			// Entrée sur GPIO_6
#define HVIEOC 35			// Entrée sur GPIO_3
 
int m_TimePeriode = 0;
int m_CurrentStep = 0;
int m_SLoadTimeHVL = 300;	//150ms
int m_SLoadTimeHVE = 100;	//50ms
int m_SLoadTimeHVI = 300;	//150ms
int m_SPeriode = 500;		//250ms
 
int m_Val_HVL = 0;
int m_Val_HVE = 0;
int m_Val_HVI = 0;
int m_Val_Trig = 0;
 
ksocket_t m_SockfdSrv, m_SockfdCli; 
 
struct Commande{
int m_Stop;
int m_Start;
int m_Manuel;
} Mode;
 
char *inet_ntoa(struct in_addr in); 
static int port = 4444;   
module_param(port, int, 0444); 
static int prog_run;
static int run;
 
	//Handler 
static irqreturn_t gpio_handler(int irq, void * ident)
{
 
	gpio_set_value(IRQ_Time, 1);
 
		if (Mode.m_Manuel == 1 && Mode.m_Stop == 0 &&Mode.m_Start == 0)
		{
			gpio_set_value(HVL,m_Val_HVL);
			gpio_set_value(HVE,m_Val_HVE);
			gpio_set_value(HVI,m_Val_HVI);
			gpio_set_value(Trig,m_Val_Trig);	
		}
 
		if (Mode.m_Stop == 1 && Mode.m_Start == 0 && Mode.m_Manuel == 0)
		{
			gpio_set_value(HVL, 0);
			gpio_set_value(HVE, 0);
			gpio_set_value(HVI, 0);
			gpio_set_value(Trig, 0);
			//m_CurrentStep = 4;
		}	
 
		if (Mode.m_Start == 1 && Mode.m_Manuel == 0 && Mode.m_Stop == 0)
		{
			//Action depends of step
			switch (m_CurrentStep)
			{
					//Initialisation des GPIO
				case 0 :
						gpio_set_value(HVL, 0);
						gpio_set_value(HVE, 0);
						gpio_set_value(HVI, 1);
 
						m_CurrentStep++;
 
				break;
 
					//
				case 1 :
					/*if (gpio_get_value(HVIEOC) == 0)
					{
						gpio_set_value(HVL, 0);
						gpio_set_value(HVE, 0);
						gpio_set_value(HVI, 0);
						printk("HVIEOC = 0\n");
						m_CurrentStep = 4;
					}*/
					gpio_set_value(HVL, 1);
					if(m_TimePeriode <= (m_SLoadTimeHVL - m_SLoadTimeHVE)) 
					break;
					gpio_set_value(HVE, 1);
					m_CurrentStep++;
				break;
 
					//
				case 2 :
					/*if ((gpio_get_value(HVLEOC) == 0) && (gpio_get_value(HVIEOC) == 0))
					{
						gpio_set_value(HVL, 0);
						gpio_set_value(HVE, 0);
						gpio_set_value(HVI, 0);
						printk("HVLEOC = 0\n");
						m_CurrentStep = 4;
					}*/
					if(m_TimePeriode <= m_SLoadTimeHVL) break;
					gpio_set_value(HVL, 0);
					gpio_set_value(HVE, 0);
					gpio_set_value(Trig, 1);
 
					m_CurrentStep++;
				break;
 
					//Trig à 0
				case 3 :
					gpio_set_value(Trig, 0);
					m_CurrentStep++;
				break;
 
					//Wait 250ms
				case 4 :
					if(m_TimePeriode <= m_SPeriode) 
					break; 
					m_CurrentStep++;
				break;
 
					//Reset
				case 5 :
					m_CurrentStep = 0;
					m_TimePeriode = 0;
				break;
 
			}
m_TimePeriode++;
		}		
 
	gpio_set_value(IRQ_Time, 0);
 
 
	return IRQ_HANDLED;
}
 
	//Thread Envoi
int thread_send(void *data)
{
	int buf[1024];
	int len;
 
	while (prog_run == 1)
	{
 
		if (Mode.m_Stop == 1)
		{
			buf[0] =  0;
			buf[1] =  0;
			buf[2] =  1;
		}
 
		if (Mode.m_Start == 1)
		{
			buf[0] =  0;
			buf[1] =  1;
			buf[2] =  0;
		}
 
		if (Mode.m_Manuel == 1)
		{
			buf[0] =  1;
			buf[1] =  0;
			buf[2] =  0;
		}
 
		len = sprintf(buf, "%d%d%d%d%d%d\n", buf[0],buf[1],buf[2],gpio_get_value(HVLEOC),gpio_get_value(HVEEOC),gpio_get_value(HVIEOC));
		ksend(m_SockfdCli, buf, len , 0);
		msleep(300);
	}
	return 0;
 
}
 
	//Thread Reception
int thread_recv(void *data)
{
	char buf[1024];
 
	while (prog_run == 1)
	{
		memset(buf, 0, sizeof(buf));
		krecv(m_SockfdCli, buf, 7, 0); 
 
		printk("commande recu : %s\n", buf);
 
 
			//Mode Stop
		if (buf[0] == '0' && buf[1] == '0' && buf[2] == '1')
		{ 
			//printk("Mode Stop Activé \n");
 
				//Selection du mode Stop
			Mode.m_Stop = 1;
			Mode.m_Start = 0;
			Mode.m_Manuel = 0;									
		}
 
			//Mode Start
		if (buf[0] == '0' && buf[1] == '1' && buf[2] == '0')
		{ 
			//printk("Mode Start Activé \n");
 
				//Selection du mode Start
			Mode.m_Stop = 0;
			Mode.m_Start = 1;
			Mode.m_Manuel = 0;	
 
			m_CurrentStep = 0;		
		}
 
			//Mode Manuel
		if (buf[0] == '1' && buf[1] == '0' && buf[2] == '0')
		{
			//printk("Mode Manuel Activé \n");
 
				//Selection du mode Manuel
			Mode.m_Stop = 0;
			Mode.m_Start = 0;
			Mode.m_Manuel = 1;
 
			m_Val_HVL = (int)buf[3];
			m_Val_HVL = m_Val_HVL - 48; 
 
			m_Val_HVE = (int)buf[4];
			m_Val_HVE = m_Val_HVE - 48;
 
			m_Val_HVI = (int)buf[5];
			m_Val_HVI = m_Val_HVI - 48; 
 
			m_Val_Trig = (int)buf[6];
			m_Val_Trig = m_Val_Trig - 48;
 
		}	
 
		if (buf[0] == '1' && buf[1] == '1' && buf[2] == '1')
		{
			prog_run = 0;
 
			gpio_set_value(HVL, 0);
			gpio_set_value(HVE, 0);
			gpio_set_value(HVI, 0);
			gpio_set_value(Trig, 0);
 
			Mode.m_Stop = 1;
			Mode.m_Start = 0;
			Mode.m_Manuel = 0;	
		}
	}
	kclose(m_SockfdCli);
	printk("Client Disconnect...\n");
	return 0;
 
}
 
struct task_struct *m_Thread_Send;
struct task_struct *m_Thread_Recv;
 
	//Fonction Server TCP/IP
int tcp_srv(void *arg)   
{   
 
    struct sockaddr_in addr_srv;   
    struct sockaddr_in addr_cli;  
 
    int addr_len;
 
    sprintf(current->comm, "ksocket"); /* kernel thread name*/     
 
    m_SockfdSrv = m_SockfdCli = NULL;   
    memset(&addr_cli, 0, sizeof(addr_cli));   
    memset(&addr_srv, 0, sizeof(addr_srv));   
    addr_srv.sin_family = AF_INET;   
    addr_srv.sin_port = htons(port);   
    addr_srv.sin_addr.s_addr = INADDR_ANY;   
    addr_len = sizeof(struct sockaddr_in);   
 
    m_SockfdSrv = ksocket(AF_INET, SOCK_STREAM, 0);   
    //ksocket_debug("m_SockfdSrv = 0x%p\n", m_SockfdSrv);   
    if (m_SockfdSrv == NULL)   
    {   
        printk("socket failed\n");   
        return -1;   
    }   
    if (kbind(m_SockfdSrv, (struct sockaddr *)&addr_srv, addr_len) < 0)   
    {   
        printk("bind failed\n");   
        return -1;   
    }   
 
    if (klisten(m_SockfdSrv, 10) < 0)   
    {   
        printk("listen failed\n");   
        return -1;   
    }   
 
	while (run == 1)
	{
   		m_SockfdCli = kaccept(m_SockfdSrv, (struct sockaddr *)&addr_cli, &addr_len);   
		if (m_SockfdCli == NULL)   
		{   
		    printk("accept failed\n");   
		    return -1;   
		}   
		else   
		printk("m_SockfdCli = 0x%p\n", m_SockfdCli);   
		printk("got connected from : %s %d\n", inet_ntoa(addr_cli.sin_addr), ntohs(addr_cli.sin_port));
 
		prog_run = 1;
		m_Thread_Send = kthread_run(thread_send,NULL,"thread_send");
		m_Thread_Recv = kthread_run(thread_recv,NULL,"thread_recv"); 
   }
 
	kclose(m_SockfdSrv); 
    return 0;   
} 
 
 
	//Module Init
static int __init gpio_init (void)
{
  int err;
 
	gpio_set_value(HVL, 0);
	gpio_set_value(HVE, 0);
	gpio_set_value(HVI, 0);
	gpio_set_value(Trig, 0);
 
		//Mode Stop a l'init
	Mode.m_Stop = 1;
	Mode.m_Start = 0;
	Mode.m_Manuel = 0;
 
	//prog_run = 1;
	run = 1;
 
	//allocation mémoire pour le IRQ_Time
  if ((err = gpio_request(IRQ_Time, THIS_MODULE->name)) != 0)
    return err;
	//allocation mémoire pour HVL
  if ((err = gpio_request(HVL, THIS_MODULE->name)) != 0)
	{
		gpio_free(IRQ_Time);
		return err;
	}
	//allocation mémoire pour le HVE
  if ((err = gpio_request(HVE, THIS_MODULE->name)) != 0)
	{
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		return err;
	}
	//allocation mémoire pour le HVI
  if ((err = gpio_request(HVI, THIS_MODULE->name)) != 0)
	{
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		return err;
	}
	//allocation mémoire pour le Trig
  if ((err = gpio_request(Trig, THIS_MODULE->name)) != 0)
	{
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		return err;
	}
	//allocation mémoire pour HVLEOC
  if ((err = gpio_request(HVLEOC, THIS_MODULE->name)) != 0)
	{
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		return err;
	}
	//allocation mémoire pour HVEEOC
  if ((err = gpio_request(HVEEOC, THIS_MODULE->name)) != 0)
	{
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		return err;
	}
	//allocation mémoire pour HVIEOC
  if ((err = gpio_request(HVIEOC, THIS_MODULE->name)) != 0)
	{    
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		return err;
	}
 
	//direction IRQ_Time : Output
  if ((err = gpio_direction_output(IRQ_Time,1)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	}
  	//direction HVL : Output
  if ((err = gpio_direction_output(HVL,1)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	  }
	//direction HVE : Output
  if ((err = gpio_direction_output(HVE,1)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	  }
	//direction HVI : Output
  if ((err = gpio_direction_output(HVI,1)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	  }
  	//direction Trig : Output
  if ((err = gpio_direction_output(Trig,1)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	  }
  //direction HVLEOC : Input
  if ((err = gpio_direction_input(HVLEOC)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	  }
  //direction HVEEOC : Input
  if ((err = gpio_direction_input(HVEEOC)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	  }
	//direction HVIEOC : Input
  if ((err = gpio_direction_input(HVIEOC)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	  }
 
 
  //declaration IRQ
  if ((err = request_irq(MXC_INT_EPIT1, gpio_handler, IRQF_SHARED, THIS_MODULE->name, THIS_MODULE->name)) != 0) 
	  {
		gpio_free(IRQ_Time);
		gpio_free(HVL);
		gpio_free(HVE);
		gpio_free(HVI);
		gpio_free(Trig);
		gpio_free(HVLEOC);
		gpio_free(HVEEOC);
		gpio_free(HVIEOC);
		return err;
	  }
 
	//Init de la communication
	kernel_thread(tcp_srv, NULL, 0);     
    printk("ksocket tcp srv init ok\n");   
 
  return 0; 
}
 
	//Module Exit
static void __exit gpio_exit (void)
{	
	run  = 0;
	free_irq(MXC_INT_EPIT1, THIS_MODULE->name);	
	//On libere les GPIO
	gpio_free(IRQ_Time);
	gpio_free(HVL);
	gpio_free(HVE);
	gpio_free(HVI);
	gpio_free(Trig);
	gpio_free(HVLEOC);
	gpio_free(HVEEOC);
	gpio_free(HVIEOC);
	kclose(m_SockfdSrv); 
	//On affiche la fermeture de la communication  
	/*if(NULL != m_SockfdCli)
	{
		kclose(m_SockfdCli);   
	}
	if(NULL != m_SockfdSrv)
	{
    	kclose(m_SockfdSrv); 
	}*/
 
}
 
module_init(gpio_init);
module_exit(gpio_exit);
MODULE_LICENSE("GPL");

code client :

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
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
 
//Librairie pour socket
using System.IO;
using System.Net;
using System.Net.Sockets;
 
namespace IHM
{
    public partial class Form1 : Form
    {
        private TcpClient m_Tcpclnt;
        private NetworkStream m_Stm;
        bool m_HVL;
        bool m_HVE;
        bool m_HVI;
        bool m_Trig;
 
        public Form1()
        {
            InitializeComponent();
            bConnect.Enabled = true;
            bClose.Enabled = false;
            bSend.Enabled = false;
            bClear.Enabled = false;
            radioButton1.Enabled = false;
            radioButton2.Enabled = false;
            radioButton3.Enabled = false;
            bHVLOn.Enabled = false;
            bHVLOff.Enabled = false;
            bHVEOn.Enabled = false;
            bHVEOff.Enabled = false;
            bHVIOn.Enabled = false;
            bHVIOff.Enabled = false;
            tCmd.Enabled = false;
        }
 
        private void EnableIHM(bool value)
        {
            bClose.Enabled = value;
            bConnect.Enabled = !value;
            bSend.Enabled = value;
            bClear.Enabled = value;
            radioButton1.Enabled = value;
            radioButton2.Enabled = value;
            radioButton3.Enabled = value;
            tCmd.Enabled = value;
            bHVLOn.Enabled = !value;
            bHVLOff.Enabled = !value;
            bHVEOn.Enabled = !value;
            bHVEOff.Enabled = !value;
            bHVIOn.Enabled = !value;
            bHVIOff.Enabled = !value;
        }
 
        private void bConnect_Click(object sender, EventArgs e)
        {
            try
            {
                m_Tcpclnt = new TcpClient();
                tConsole.Text = "Connecting.....\r\n" + tConsole.Text;
 
                m_Tcpclnt.Connect("192.168.101.2", 4444);
 
                tConsole.Text = "Connected\r\n" + tConsole.Text;
                m_Stm = m_Tcpclnt.GetStream();
 
                EnableIHM(true);
                radioButton1.Checked = true;
            }
            catch (Exception ex) { tConsole.Text = ex.Message + "\r\n" + tConsole.Text; }
            timer.Enabled = true;
        }
 
        private void bClose_Click(object sender, EventArgs e)
        {
            SendCmd("1111111");
            timer.Enabled = false;
            m_Tcpclnt.Close();
            tConsole.Text = "\r\nDisconnect....\r\n" + tConsole.Text;
            EnableIHM(false);
        }
 
        private void bSend_Click(object sender, EventArgs e)
        {
            byte[] OutStream = new byte[100];
            string msg_send = "";
            msg_send = tCmd.Text;
            OutStream = ASCIIEncoding.ASCII.GetBytes(msg_send);
            m_Stm.Write(OutStream, 0, OutStream.Length);
            tCmd.Clear();
        }
 
        private void radioButton1_CheckedChanged(object sender, EventArgs e)
        {
            SendCmd("0010000");
            bHVLOn.Enabled = false;
            bHVLOff.Enabled = false;
            bHVEOn.Enabled = false;
            bHVEOff.Enabled = false;
            bHVIOn.Enabled = false;
            bHVIOff.Enabled = false;
 
        }
 
        private void radioButton2_CheckedChanged(object sender, EventArgs e)
        {
            SendCmd("0100000");
            bHVLOn.Enabled = false;
            bHVLOff.Enabled = false;
            bHVEOn.Enabled = false;
            bHVEOff.Enabled = false;
            bHVIOn.Enabled = false;
            bHVIOff.Enabled = false;
 
        }
 
        private void radioButton3_CheckedChanged(object sender, EventArgs e)
        {
            SendCmd("1000000");
            bHVLOn.Enabled = true;
            bHVLOff.Enabled = true;
            bHVEOn.Enabled = true;
            bHVEOff.Enabled = true;
            bHVIOn.Enabled = true;
            bHVIOff.Enabled = true;
        }
 
        private void bHVLOn_Click(object sender, EventArgs e)
        {
            m_HVL = true;
            SendCmd("100" + (m_HVL ? '1' : '0') + (m_HVE ? '1' : '0') + (m_HVI ? '1' : '0') + '0');
        }
 
        private void bHVLOff_Click(object sender, EventArgs e)
        {
            m_HVL = false;
            SendCmd("100" + (m_HVL ? '1' : '0') + (m_HVE ? '1' : '0') + (m_HVI ? '1' : '0') + '0');
        }
 
        private void bHVEOn_Click(object sender, EventArgs e)
        {
            m_HVE = true;
            SendCmd("100" + (m_HVL ? '1' : '0') + (m_HVE ? '1' : '0') + (m_HVI ? '1' : '0') + '0');
        }
 
        private void bHVEOff_Click(object sender, EventArgs e)
        {
            m_HVE = false;
            SendCmd("100" + (m_HVL ? '1' : '0') + (m_HVE ? '1' : '0') + (m_HVI ? '1' : '0') + '0');
        }
 
        private void bHVIOn_Click(object sender, EventArgs e)
        {
            m_HVI = true;
            SendCmd("100" + (m_HVL ? '1' : '0') + (m_HVE ? '1' : '0') + (m_HVI ? '1' : '0') + '0');
        }
 
        private void bHVIOff_Click(object sender, EventArgs e)
        {
            m_HVI = false;
 
            SendCmd("100" + (m_HVL ? '1' : '0') + (m_HVE ? '1' : '0') + (m_HVI ? '1' : '0') + '0');
        }
 
        private void bClear_Click(object sender, EventArgs e)
        {
            tConsole.Clear();
        }
 
        private void timer_Tick(object sender, EventArgs e)
        {          
            string returndata = String.Empty;
            string msg = "";
            byte[] inStream = new byte[100];
            m_Stm.Read(inStream, 0, 7);
            returndata = System.Text.Encoding.ASCII.GetString(inStream,0,7);
            msg = "Received: " + returndata;
            tConsole.Text = msg +"\r\n"+ tConsole.Text + "\r\n";
 
            bool ModeBit1 = Convert.ToBoolean(inStream[0] - '0');
            bool ModeBit2 = Convert.ToBoolean(inStream[1] - '0');
            bool ModeBit3 = Convert.ToBoolean(inStream[2] - '0');
 
            tMode.Clear();
 
            if(ModeBit1 == true)
            {
                tMode.Text += "Manuel";
            }
            if (ModeBit2 == true)
            {
                tMode.Text += "Start";
            }
            if (ModeBit3 == true)
            {
                tMode.Text += "Stop";
            }
            UpdateIHM(inStream);
        }
 
        private void UpdateIHM(byte[] command)
        {
            bool ModeBit1 = Convert.ToBoolean(command[0] -'0');
            bool ModeBit2 = Convert.ToBoolean(command[1] - '0');
            bool ModeBit3 = Convert.ToBoolean(command[2] - '0');
            bool HVLOn = Convert.ToBoolean(command[3] - '0');
            bool HVEOn = Convert.ToBoolean(command[4] - '0');
            bool HVIOn = Convert.ToBoolean(command[5] - '0');
            bool TrigOn = Convert.ToBoolean(command[6] - '0');
 
                //Color la textbox de HVL
            tHVL.BackColor = HVLOn ? Color.Lime : Color.Black;
            tHVL.ForeColor = HVLOn ? Color.Black : Color.White;
                //Color la textbox de HVE
            tHVE.BackColor = HVEOn ? Color.Lime : Color.Black;
            tHVE.ForeColor = HVEOn ? Color.Black : Color.White;
                //Color la textbox de HVI
            tHVI.BackColor = HVIOn ? Color.Lime : Color.Black;
            tHVI.ForeColor = HVIOn ? Color.Black : Color.White;
        }
 
        private void SendCmd(string cmd)
        {
            byte[] OutStream = new byte[100];
            OutStream = ASCIIEncoding.ASCII.GetBytes(cmd);
            m_Stm.Write(OutStream, 0, OutStream.Length);
        }   
    }
}

Si quelqu'un peut m'aider svp

**gangsoleil** · 22/10/2013, 16h48

Envoyé par cartman_94

le serveur prend bien en compte la requête du client (j'affiche la commande reçu) mais n'affecte pas immédiatement les valeurs de sortie demandé par le client.

Je pense que "volatile" est le mot-cle qui t'interesse.

En gros, si mes souvenirs sont bons, il faut que tu definisses les variables modifiables par ton hardware avec le mot-cle volatile pour que le systeme ne fasse pas d'optimisation sur la lecture.

**cartman_94** · 22/10/2013, 17h33

Merci de ta réponse gangsoleil.

Par contre quand le serveur envoi la valeur des sorties au client, c'est pas les bonnes valeurs que reçoit le client.

je m'explique : la commande envoyé par le client change bien l’état des sorties, mais le serveur me renvoi pas les valeur des sorties (celle que j'observe sur l'oscillo) mais les valeurs d'avant la commande saisi par le client.
Je voudrai qu'il me retourne les valeurs saisies par le client par rapport a celle que j'observe sur l'oscillo et non des valeurs des sorties d'il y a 30s.

Je pense que cela viens du TCP/IP, a votre avis ??

**cartman_94** · 25/10/2013, 14h32

Petit question : la commande gpio_get_value(GPIO) prend elle du temps à récupérer la valeur GPIO ??

**gangsoleil** · 25/10/2013, 15h19

Envoyé par cartman_94

Petit question : la commande gpio_get_value(GPIO) prend elle du temps à récupérer la valeur GPIO ??

Ca veut dire quoi prendre du temps ? Par rapport a quoi ?

Oui, ca prend du temps si tu travailles dans des operations de l'ordre de la dizaine de microsecondes, comme tu as l'air de le faire.
Non, par rapport a un traitement d'une seconde, ca ne prend pas de temps.

Mais le mieux serait peut-etre de faire des mesures non ?

**cartman_94** · 29/10/2013, 10h06

Venant de débuter en C#, j'aurai besoin de votre aide.

je demande a mon serveur de me renvoyer des données (du type état d'une variable ou d'une sortie). je cherche a l'afficher sur mon IHM client (qui est en C#) mais je n'y arrive pas.

Dans mon serveur je déclare un tableau de int (car avec char je ne peux pas envoyer une valeur > à 255). je rempli mon tableau de tab[0] à tab[8] avec les données a envoyées.

Sur mon IHM client j'ai déclarer un tableau de bytes ou sont stockés ce que je reçoit. il me faut donc convertir mon tableau de bytes en int pour que je puisse utiliser ces données.

C'est donc cette partie que je n'arrive pas à faire. j'ai essayé avec BitConverter.ToInt32(inStream, 0) mais ceci me sort que la première donnée que j'envoi avec une autre valeur (ex : si j'envoi 1024 coté serveur je reçoit 1024 et 0 coté client, le 0 je ne sais pas d'ou il sort)

je voudrais pouvoir récupérer exactement ce que le serveur me renvoi et afficher ces valeurs.

**Metalman** · 29/10/2013, 10h29

Vu qu'ici on fait du C... si c'est pour le C# et connaitre la libDotNet on ne va pas être les meilleurs pour ça :/
Peut être pourrais-tu faire un topic ici, et leur expliquer comment faire la conversion que tu cherches ?

EDIT : et nous on reste dispo pour la partie C, hein !

**cartman_94** · 31/10/2013, 15h04

Salut a tous,

Méga bonne nouvelle, j'ai réussi a terminer mon projet

Je vous remercie tous pour votre aide, sans quoi je ne n'aurai jamais vu le bout

Est-il possible d'affecter une priorité à un module ?

C

Discussions similaires

Partager

Partager