execution switch

Version imprimable

execution switch

Bonjour,

J'aimerai savoir un détail sur l'execution d'un switch. Prenons le code suivant:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 t=1; switch(t) { case 1: ... t=2; break; case 2: ... t=3; break; case 3: ... t=1; break; }
Est ce qu'à l'execution tous les case vont s'éxecuter à la suite, ou est ce que le break provoque la sortie du switch?

Vu que dans le dernier case on refixe la variable t à 1, est ce que l'execution va reiterer le switch ou pas?

En esperant que quelqu'un pourra m'aider...
Merci d'avance :wink:

03/05/2005, 15h15
sg-40

C'est là l'intérêt de mettre un break... Après avoir trouvé le bon stop
03/05/2005, 15h18
jack69

Citation:

Est ce qu'à l'execution tous les case vont s'éxecuter à la suite, ou est ce que le break provoque la sortie du switch?

Le break provoque la sortie du switch.

Citation:

Vu que dans le dernier case on refixe la variable t à 1, est ce que l'execution va reiterer le switch ou pas?

Je ne comprends pas. Si tu es dans une boucle qui te ramènes avant le switch oui sinon tu continues...
03/05/2005, 15h25
calitom

Oui, je suis d'accord, mais alors quel est l'interet de changer la variable t pour aller dans le case suivant alors?

En fait je travail sur le code d'une machine, et je ne comprend pas pourquoi celui qui a developpé a utilisé un switch...
J'ai l'impression qu'il ne sert à rien si à chaque fois on cherche aller dans le case suivant...

Est ce que je me trompe :?:
03/05/2005, 15h32
jack69

Si le code est exactement comme tu nous l'as donné, c'est très bizarre.
Par contre il ressemble bcp à une machine d'état.

t=1, on rentre dans le switch, on applique le traitement correspondant, et on passe à l'état 2.

A la prochaine exécution du switch (si la ligne t=1 n'existe pas) t=2 => on applique le nouveau traitement correspondant et on passe à l'état 3.

Etc....
03/05/2005, 15h33
Ti-R

Il n'y a pas une boucle sur le switch par hasard ?

Cela permettrait d'exécuter des bouts de codes à la suite.
Par exemple t=1, il traite suivant le cas 1, ensuite t=2, il fera un nouveau traitement suivant le cas 2 etc...

Ou tout simplement pour remapper la variable pour un protocole différent. Pour indiquer que si sur le protocole 1 on trouve 3, il sera équivalent à 4 sur le protocole 2.

Ou peut être encore autre chose…
:lol:
03/05/2005, 15h35
calogerogigante

N'y avait-il pas moyen de faire un truc similaire plus simplement avec un "for" ?

Puisque le t est incrémenté à chaque fois ??

Enfin c'est dur à dire comme ça car on n'a pas tout le contexte externe à ce switch... Mais bon !!!

voici le vrai code:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
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
 
 
tps_capteur=1;
 
while( ((Capt.deplace[1] - contactdalle) < Outil.profondeur)&&(Cont.alarme==0))
{
	/* Temps de la boucle initialisé */
	tempsboucle=Timer();
 
	/* Fréquence de régulation 40Hz */
	if( Perio.force<=(tempsboucle-tps_force) )
	{
		Regulation(consigne);
		moy_capt[0]+=(Capt.force[1]+poids);
		/* Lecture de la valeur du capteur de déplacement */
		LectureDeplacement();
		s_force++;
		/* Systeme de buffer circulaire les 1000 dernieres valeurs sont sauvegardées */
		if(nbi>=NOMBRE_ECHANT)
		{
			nbi=0;
			flagi=1;
		}
		a1[nbi]=Capt.force[1]+poids;
		a2[nbi++]=(Capt.deplace[1]-contactdalle);
 
		/* Reinitialisatino temps régulation */
		tps_force=Timer();
	}
 
	if( Perio.rota<=(tempsboucle-tps_rota) )
	{
		LectureRotation();
		moy_capt[2]+=Capt.rota[1];
		s_rota++;
		if(nbj>=NOMBRE_ECHANT)
		{
			nbj=0;
			flagj=1;
		}
		a3[nbj++]=Capt.rota[1];
		tps_rota=Timer();
 
		if(Capt.temps[1]>tps_alarme_rota)
			Cont.flag_rotation=1;
 
	}
 
 
 
	switch(tps_capteur)
	{
	case 1:
		LectureTemperature();
		if(nbl<NOMBRE_ECHANT)
		{
			a5[nbl]=Capt.temp[1];
		}
		tps_capteur=2;
	break;
	case 2:
		LectureTension();
		if(nbl<NOMBRE_ECHANT)
			a6[(nbl)]=Capt.tension;
		tps_capteur=3;
	break;
	case 3:
		LectureIntensite();
		if(nbl<NOMBRE_ECHANT)
			a7[nbl]=Capt.intensite;
		tps_capteur=4;
	break;
	case 4:
		LectureCosPhi();
		if(nbl<NOMBRE_ECHANT)
			a8[nbl++]=Capt.cosphi;
		if(nbl>=NOMBRE_ECHANT)
		{
			nbl=0;
			flagl=1;
		}
		tps_capteur=1;
 
		moy_capt[4]+=Capt.temp[1];
		moy_capt[5]+=Capt.tension;
		moy_capt[6]+=Capt.intensite;
		moy_capt[7]+=Capt.cosphi;
		LecturePuissance;  /*Definit dans lib.h*/
		moy_capt[8]+=Capt.puis[1];
		s_puis++;
		if(Capt.temps[1]>tps_alarme_puis)
			Cont.flag_puissance=1;
	break;
	}
 
 
	if(panel_manu==0)
		CheckAlarme(force_contact);
 
	if(Capt.temps[1]==0.0)
		tempsboucle=Timer();
 
	if(!InstallationEnService())
	{
		ArretUrgence();
		if(!pasremonter)
			pasremonter=1;
		break;
	}
 
	temps.debourrage=0.0;
 
	/* Distance de débourage atteinte */
	if( ((Capt.deplace[1] - distancetmp)>=Outil.debourrage)&&((Capt.deplace[1] - contactdalle)<(Outil.profondeur-10)) )
	{
		/* Lecture du temps avant le debourage */
		temps.debourrage=Timer();
 
		/* Memorisation de la profondeur avant debourrage & affichage operateur */
		distancetmp=(long)Capt.deplace[1];
 
		/* Debourrage jusqu'a distance debut de trou & affichage operateur */
		if(!RemonteeDebou(contactdalle))
		{
			ArretCmdeActionneur();
			pasremonter=1;
			break;
		}
		else
		{
			/* Descente de l'outil jusqu'a contact */
			DescenteContact(force_contact);
 
			/* Calcul du temps d'une boucle */
			temps.debourrage=Timer()-temps.debourrage;
		}
	}
	/* mise à jour affichage des valeurs */
	if ( (tempsboucle - temps.affiche ) > tps_aff )
	{
	/* Interface manuel si panel manu */
		if(panel_manu)
			AfficheManuel();
		else
			AfficheControl(contactdalle, poids);
 
		temps.affiche=Timer();
	}
 
	GetUserEvent (0, &panel, &ctrl);
 
	/* Calcul du temps total de percement durant toute la boucle */
	if(!pasremonter)
	{
		tempsboucle=(Timer()-tempsboucle);
		Capt.temps[1]+=(tempsboucle-temps.debourrage);
	}
}

Et en fait, le probleme que j'ai est lié a l'acquisition des valeurs avec les capteurs. Je n'arrive pas à avoir toutes les valeurs que je veux(NOMBRE_ECHANT dans le switch). Je me demande à quoi c'est du, car ma constante NOMBRE_ECHANT vaut 1024, et je n'ai pas tous le temps ces 1024 valeures. Desfois je les ai toutes, mais le plus souvent, je récupère seulement 700 valeurs...

C'est assez incompréhensible pour moi, donc si quelqu'un peut m'aider...

03/05/2005, 16h03
Mac LAK

Ce qui est certain, c'est que c'est un bout de cycle automate, avec effectivement une machine à états à l'intérieur. A chaque exécution du cycle, dans le switch (la machine à états), on effectue une opération différente, ce qui permet de "séquencer" ces "tâches" manuellement.

Bref, c'est du super classique en automatisme (même si le code est assez crade, ça sent l'automaticien qui a appris le C sur le tas... :twisted:)

Ton nombre d'échantillons peut être lié à la capacité de mémorisation des évènements (une file circulaire de 1000 éléments est implémentée, apparemment), et tu n'as pas forcément les 1000 évènements à chaque fois : tout dépend de leur nature (evt sur changement ? acquisition périodique ?).
Tu peux également avoir un problème de timing avec l'acquisition des données (fréquent si tu es en train de porter du code DOS vers Windows, par exemple).

Plus de détails, stp...
03/05/2005, 16h25
calitom

En fait, il s'agit d'une machine percant des trous pour tester la durée de vie des perceuses...

Quand la perceuse entre en contact avec la dalle au moment du forage, l'algorithme de regulation se declenche, et c'est à ce moment que l'on souhaite récupérer les valeurs des capteurs de manière à tracer des courbes(capteur de température, de force, de rotation, de deplacement...)

L'acquisition des donnees se fait periodiquement.

Je n'arrive pas à savoir d'ou vient le probleme.
Je me suis dis qu'il était possible que cela vienne de l'utilisation du Timer()?...
Je reste à disposition pour tout complément d'info...
03/05/2005, 16h34
jack69

En fait la question est qu'est ce qui te chagrine ?
Tu veux absolument 1024 données ?

Parce que en gros ton prog fait l'acquisition de données tant que tu perces. Ces données sont stockées dans un buffer circulaire dont la taille fait 1024.

Donc si tu perces pendant un laps de temps trop court, tu n'auras pas rempli ton buffer. De même si ce temps est trop long, tu écraseras les premières données (dans ce cas flag1 est validé).

Le tout est de savoir si cela est génant ou non.
03/05/2005, 16h44
calitom

En fait, moi je suis en stage, et mon employeur veut les 1024 acquisitions.
Moi aussi je suis d'accord pour dire que c'est pas grave, mais d'un côté, pour pouvoir analyser les données il a surement besoin de ces 1024 acquisitions...

Le truc que je ne comprend paas, c'est que l'on ne trouve quasiment jamais la meme frequence d'acquisition(nb valeurs acquisitions/temps percement) et je ne comprend pas pourquoi...

Re: execution switch

Citation:
Envoyé par calitom
J'aimerai savoir un détail sur l'execution d'un switch. Prenons le code suivant:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 t=1; switch(t) { case 1: ... t=2; break; case 2: ... t=3; break; case 3: ... t=1; break; }
Est ce qu'à l'execution tous les case vont s'éxecuter à la suite, ou est ce que le break provoque la sortie du switch?
Qu'en pense ton livre de C ?

Ici, le 'break' est un 'goto fin du switch' deguisé
Le dernier break est superflu.

Citation:

Vu que dans le dernier case on refixe la variable t à 1, est ce que l'execution va reiterer le switch ou pas?

Non. Un switch ne fait jamais de boucle.

Il serait vraiment temps que tu lises un livre de C... Le K&R2 au hasard...

http://www.dunod.com/pages/ouvrages/ficheouvrage.asp?id=48734

03/05/2005, 18h14
Emmanuel Delahaye

Citation:

Envoyé par calitom

Oui, je suis d'accord, mais alors quel est l'interet de changer la variable t pour aller dans le case suivant alors?

Ca ressemble à un automate d'état finis ou à un séquenceur.
03/05/2005, 20h46
Mac LAK

Citation:

Envoyé par calitom

En fait, moi je suis en stage, et mon employeur veut les 1024 acquisitions.

Normal, étant donné qu'une acquisition de ce type se fait à une fréquence connue et déterminée... C'est crucial pour pouvoir tracer la courbe si tu ne timestampe pas ton acquisition.

Citation:

Envoyé par calitom

Moi aussi je suis d'accord pour dire que c'est pas grave, mais d'un côté, pour pouvoir analyser les données il a surement besoin de ces 1024 acquisitions...

C'est exactement ça, et c'est réellement important.

Citation:

Envoyé par calitom

Le truc que je ne comprend paas, c'est que l'on ne trouve quasiment jamais la meme frequence d'acquisition(nb valeurs acquisitions/temps percement) et je ne comprend pas pourquoi...

Là, on entre certainement dans un problème plus pointu :
- Est-ce un portage d'une application existante ?
- Quel OS utilises-tu ?
- Quelle est la cible d'exécution ? PC, PC industriel, automate ?
- Quel compilateur (nom et version) ?
- Par quel médium est faite l'acquisition ? Port COM, LPT, SPI, I²C, CAN, carte dédiée, ... ?
- La fréquence est-elle calculée uniquement via un timer, ou par un autre système ?
- Si c'est un portage, est-ce que l'acquisition fonctionnait correctement auparavant ?

Avec ces éléments, il sera plus facile de t'aiguiller... Je penche pour un sévère problème de perte lors de l'acquistion des données.
04/05/2005, 08h27
calitom

Citation:

Est-ce un portage d'une application existante ?

Cette application fonctionnait sous windows 3.11. A ce moment ca fonctionnait. Et ils ont changé de carte d'acquisition et d'OS(Windows NT), et à partir de la ca ne fonctionnait plus correctement.

Citation:

Quelle est la cible d'exécution ? PC, PC industriel, automate ?

L'execution se fait sur un PC.

Citation:

Quel compilateur (nom et version) ?

C'est LabWindows/CVI v5.5.

Citation:

Par quel médium est faite l'acquisition ? Port COM, LPT, SPI, I²C, CAN, carte dédiée, ... ?

L'acquisition se fait à l'aide d'une carte d'acquisition(PCI 6025E de National Instrument).

Citation:

La fréquence est-elle calculée uniquement via un timer, ou par un autre système ?

La fréquence d'acquisition n'est pas calculée, je la calcule en me basant sur le nombre de valeurs acquises/temps de percement.

J'ai récupérées les valeures à l'intérieur des tableaux a1,a2... qui stockent les valeurs lues par les capteurs. L'incrementation des variables nbi,nbj,nbl est bizarre. Elle se fait de 3 en 3, alors que je ne vois pas pourquoi. Je met le code en dessous:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
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
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
 
/********** HEADER ***********/
#include <ansi_c.h> 
#include "lib.h"
#include "port.h"
#include <stdio.h>
#include <dataacq.h>
#include <utility.h>
#include <userint.h>
 
static double R[5],S[5],T[5],ctrl[5],outpp[5];
 
/*____________________________________________________
 |													  |
 |			Algorithme de régulation RST 			  |
 |____________________________________________________|
*/
int Regulation(double consigne)
{
double t,s1,s2,s3,force,sortie,val_force;
int i,nbr,fin;
 
/* codage en dur des valeurs du régulateur correction par DIDIER GEORGE le 26/09/95
   "Méthode Régulation linéaire quadratique généralisé implanté dans un RST."
   Valeurs capteurs et consignes en decaNewton (lib.h) pour 40 Hz
   Affectation dans main */
 
R[0]=R0;
R[1]=R1;
R[2]=R2;
R[3]=R3;
S[0]=S0;
S[1]=S1;
S[2]=S2;
S[3]=S3;
T[0]=T0;
T[1]=T1;
T[2]=T2;
T[3]=T3;
 
/**************** Boucle de régulation RST **********************/
/* 																*/
/* outpp 	 =	Vecteur des valeurs de sortie                  	*/
/* consigne = 	Valeur de la consigne						    */
/* ctrl 	 =	Vecteur des valeurs de commande                 */
/* 																*/
/* Fin = Appui sur une touche									*/
/* Décalage des valeurs dans chaque tableau						*/
/* Les valeurs acquises seront situées en 0						*/
/* Possibilitée d'améliorer le temps en ne faisant qu'une boucle puisque nS=nR=nT */
 
for(i=nS; i>0; i--)
{
	ctrl[i] = ctrl[i-1];
	outpp[i] = outpp[i-1];
}
 
/* Lecture de la sortie capteur de force */
LectureForce();
 
outpp[0]=Capt.force[1];
 
s1 = 0;
s2 = 0;
s3 = 0;
 
/* Calcul de la commande (ctrl[o] // outpp[i] // T[i] */
/* Tous ensemble car nS=nR=nT */
 
s1 += R[0]*outpp[0];
s3 += T[0]*consigne;
 
for(i=1; i<(nR+1);i++)
{
	s1 += R[i]*outpp[i];
	s2 += S[i]*ctrl[i];
	s3 += T[i]*consigne;
}
 
ctrl[0] = (s3-s1-s2)/S[0];
 
/* SEUILS sur la commande */
/* La commande ne peut pas dépasser ctrlmax Volts */
if(ctrl[0]>maxconsigne)
	ctrl[0] = maxconsigne;
if(ctrl[0]<(-maxconsigne))
	ctrl[0] = -maxconsigne;
 
/* Commande du vérin */
/* Ecriture de la valeur de sortie */
val_force=ctrl[0];
 
APPUIE_MARTEAU;
 
 return(0);
}
/*-------------------------------------------------------------------------------------------*/
int AfficheControl(long contactdalle,double poids)
{
 
SetCtrlVal(controle, CONTROLE_FORCE, Capt.force[1]+poids);
SetCtrlVal(controle, CONTROLE_DEPLACEMENT, Capt.deplace[1]-contactdalle);
/*SetCtrlVal(controle, CONTROLE_VIBRATION, Capt.vibra[1]); */
SetCtrlVal(controle, CONTROLE_ROTATION, Capt.rota[1]);
SetCtrlVal(controle, CONTROLE_TEMPERATURE, Capt.temp[1]);
SetCtrlVal(controle, CONTROLE_TENSION, Capt.tension);
SetCtrlVal(controle, CONTROLE_INTENSITE, Capt.intensite);
SetCtrlVal(controle, CONTROLE_COSPHI, Capt.cosphi);
SetCtrlVal(controle, CONTROLE_PUISSANCE, Capt.puis[1]);
SetCtrlVal(controle, CONTROLE_TEMPS, Capt.temps[1]);
return(0);
}
 
/*-------------------------------------------------------------------------------------------*/
int DesactiveControl()
{
SetCtrlAttribute(controle,CONTROLE_BUTTON_INIT    ,ATTR_CTRL_MODE,VAL_INDICATOR);
SetCtrlAttribute(controle,CONTROLE_BUTTON_MANUEL  ,ATTR_CTRL_MODE,VAL_INDICATOR);
SetCtrlAttribute(controle,CONTROLE_BUTTON_RESULTAT,ATTR_CTRL_MODE,VAL_INDICATOR);
SetCtrlAttribute(controle,CONTROLE_BUTTON_MODEM   ,ATTR_CTRL_MODE,VAL_INDICATOR);
SetCtrlAttribute(controle,CONTROLE_LANCE_TEST     ,ATTR_CTRL_MODE,VAL_INDICATOR);
SetCtrlAttribute(controle,CONTROLE_BOX_OPERATEUR  ,ATTR_CTRL_MODE,VAL_INDICATOR);
SetCtrlAttribute(controle,CONTROLE_QUIT           ,ATTR_CTRL_MODE,VAL_INDICATOR);
SetCtrlAttribute(controle,CONTROLE_LISTECAPTEUR   ,ATTR_CTRL_MODE,VAL_INDICATOR);
SetCtrlAttribute(controle,CONTROLE_str1			  ,ATTR_CTRL_MODE,VAL_INDICATOR);
SetCtrlAttribute(controle,CONTROLE_PAUSE		  ,ATTR_CTRL_MODE,VAL_INDICATOR);
SetActiveCtrl (controle, CONTROLE_ARRET);
return(0);
}
 
/*-------------------------------------------------------------------------------------------*/
int ActiveControl()
{
SetCtrlAttribute(controle,CONTROLE_BUTTON_INIT    ,ATTR_CTRL_MODE,VAL_HOT);
SetCtrlAttribute(controle,CONTROLE_BUTTON_MANUEL  ,ATTR_CTRL_MODE,VAL_HOT);
SetCtrlAttribute(controle,CONTROLE_BUTTON_RESULTAT,ATTR_CTRL_MODE,VAL_HOT);
SetCtrlAttribute(controle,CONTROLE_BUTTON_MODEM   ,ATTR_CTRL_MODE,VAL_HOT);
SetCtrlAttribute(controle,CONTROLE_LANCE_TEST     ,ATTR_CTRL_MODE,VAL_HOT);
SetCtrlAttribute(controle,CONTROLE_BOX_OPERATEUR  ,ATTR_CTRL_MODE,VAL_HOT);
SetCtrlAttribute(controle,CONTROLE_QUIT           ,ATTR_CTRL_MODE,VAL_HOT);
SetCtrlAttribute(controle,CONTROLE_LISTECAPTEUR   ,ATTR_CTRL_MODE,VAL_HOT);
SetCtrlAttribute(controle,CONTROLE_PAUSE		  ,ATTR_CTRL_MODE,VAL_HOT);
SetCtrlAttribute(controle,CONTROLE_str1			  ,ATTR_CTRL_MODE,VAL_NORMAL);
return(0);
}
 
/*------------------------------------------------------------------------------------------*/
/*	Fonction : Percer un trou																*/
/*	Retourne : 1 si trou sans probleme 														*/
/*------------------------------------------------------------------------------------------*/
int Percement()
{
/* Percement d'un trou */
/* Variables de boucle */
int i=0;
int flagi=0,flagj=0,flagk=0,flagl=0;
short pasremonter=0;
char mess[80];		/* Message pour la boite de dialogue */
long contactdalle;	/* Distance0 : distance initiale */
long distancetmp;	/* Distancetmp : memorisation distance avant debourage */
double tempsboucle;	/* Temps de debourage a ne pas compter selon ALGO */
double tempsdeb;	/* Temps de debourage a ne pas compter selon ALGO */
double temp_deplace=0.0;
/* Variable de Regulation */
double poids,consigne,force_contact;
/* Information statistique */
long int somme=0;
unsigned long s_force=0,s_rota=0,s_puis=0;	   /*,s_vibra=0*/
/* Temps d'acquisition capteur */
double tps_force,tps_rota;		   /*tps_vibra,*/
short tps_capteur;
FILE *fichier;
int panel,ctrl;
 
 
/* Initialisation des temps d'acquisition */
tps_force=Timer();
/*tps_vibra=tps_force;	  */
tps_rota=tps_force;
tps_capteur=1;
temps.affiche=Timer();
 
/* Le control de puissace et rotation ne ce fait 
qu'apres TEMPS_AL_PUIS TEMPS_AL_ROTA*/
Cont.flag_puissance=0;
Cont.flag_rotation=0;
 
/* Prise en compt du poids dans la force de contact et force consigne */
/* si dalle position horizontale */
if(!Cont.flag_face)
{
/* Manque poids equipement */
	poids=Appareil.poid+(Outil.poid/1000.0)+poid_equip_mart;
	consigne=Outil.consigne-poids;
	force_contact=Outil.contact-poids;
}
else
{
	poids=0-poid_effort;
	consigne = Outil.consigne+poid_effort;
	force_contact = Outil.contact+poid_effort;
}
 
/* Recherche du contact entre dalle et marteau (variation force=VAR_FORCE) */
if(Cont.distance0<=0)
{
/* Recherche et affectation Distance0 = dalle+2cm */
	if(!RechercheContactDalle(var_force))
	{
		/* Impose arrets de toutes les cmd sauf position marteau */
		ArretCmdeActionneur();
		temps.fct_marteau=0.0;
		ValideVarXYZ_OFF;
		strcpy(message_err,"RechercheContactDalle :");
		ERREUR=200;
		return(0);
	}
 
}
 
 
if(!DescenteContact(force_contact))
{
 
/* Impose arrets de toutes les cmd sauf position marteau */
	ArretCmdeActionneur();
	temps.fct_marteau=0.0;
	ValideVarXYZ_OFF;
	strcpy(message_err,"DescenteContact :");
	ERREUR=190;
	return(0);
}
 
 
/* Attente stabilisation capteur de déplacement */
temp_deplace=Capt.deplace[1];
tempsdeb=Timer();
 
do
{
	if((Timer()-tempsdeb)>0.02)
	{
		temp_deplace=Capt.deplace[1];
		LectureDeplacement();
		tempsdeb=Timer();
	}
}
while((temp_deplace-Capt.deplace[1])>5.0);
/* Lecture de la valeur du capteur de déplacement au contact avec la dalle */
/* Avec une petite moyenne sur 2 valeurs */
LectureDeplacement();
temp_deplace=Capt.deplace[1];
LectureDeplacement();
Capt.deplace[1]+=temp_deplace;
Capt.deplace[1]/=2.0;
 
/* Lecture de la position au contact de la dalle a tous les trous */
contactdalle=(long)Capt.deplace[1];
distancetmp=contactdalle;
 
/* Premier trou on memorise la taille foret*/
if(Cont.dist_contact<=0)
{
	Cont.dist_contact=contactdalle;
/* Initialisation des alarmes */
	InitValAlarmeCapt();
 
}
else
{
	if(abs(Cont.dist_contact-contactdalle)>usure_accordee)
	{
 
/* Impose arrets de toutes les cmd sauf position axe mesure */
		ArretCmdeActionneur();
		temps.fct_marteau=0.0;
		temps.percement=0.0;
		Cont.alarme = 7;
		AlarmeCasseForet();
		Cont.lancement=FALSE;
		return(0);
	}
 
}
 
/* Remise a zero des moyennes */
for(i=0;i<NB_DE_CAPTEUR;i++)
	moy_capt[i]=0.0;
 
nbi=0;
nbj=0;
nbk=0;
nbl=0;
 
DesactiveControl();
 
/* Démarrage perceuse */
MarcheArret(1);
 
/* Initialisation temps debut de trou */
Capt.temps[1]=0.01;
temps.percement=0.0;
 
/* Affectation de la structure periodes */
Perio.force=1.0/(double)Freq.force ;
//Perio.vibra=1.0/(double)Freq.vibra;
Perio.rota=1.0/(double)Freq.rota ;
 
tempsdeb=Timer();
/**************** Boucle de régulation RST **********************/
while( ((Capt.deplace[1] - contactdalle) < Outil.profondeur)&&(Cont.alarme==0))
{
	/*Affichage des courbes dans le panel controle*/
	Cont.affiche=1;
	ChargeTmp();
 
	/* Temps de la boucle initialisé */
	tempsboucle=Timer();
 
	/* Fréquence de régulation 40Hz */
	if( Perio.force<=(tempsboucle-tps_force) )
	{
		Regulation(consigne);
		moy_capt[0]+=(Capt.force[1]+poids);
		/* Lecture de la valeur du capteur de déplacement */
		LectureDeplacement();
		s_force++;
		/* Systeme de buffer circulaire les 1000 dernieres valeurs sont sauvegardées */
		if(nbi>=NOMBRE_ECHANT)
		{
			nbi=0;
			flagi=1;
		}
		fichier=fopen("a1.txt","a");
		a1[nbi]=Capt.force[1]+poids;
		fprintf(fichier,"nbi=%d _ a1[%d]=%lf\n",nbi,nbi,a1[nbi]);
		fclose(fichier);
		fichier=fopen("a2.txt","a");
		a2[nbi++]=(Capt.deplace[1]-contactdalle);
		fprintf(fichier,"nbi=%d _ a2[%d]=%lf _ (nbi++)-> a2[%d]=%lf\n",nbi,nbi,a2[nbi],nbi++,a2[nbi++]);
		fclose(fichier);
 
		/* Reinitialisatino temps régulation */
		tps_force=Timer();
	}
 
	if( Perio.rota<=(tempsboucle-tps_rota) )
	{
		LectureRotation();
		moy_capt[2]+=Capt.rota[1];
		s_rota++;
		if(nbj>=NOMBRE_ECHANT)
		{
			nbj=0;
			flagj=1;
		}
		fichier=fopen("a3.txt","a");
		a3[nbj++]=Capt.rota[1];
		fprintf(fichier,"nbj=%d _ a3[%d]=%lf _ (nbj++)-> a3[%d]=%lf\n",nbj,nbj,a3[nbj],nbj++,a3[nbj++]);
		fclose(fichier);
		tps_rota=Timer();
 
		if(Capt.temps[1]>tps_alarme_rota)
			Cont.flag_rotation=1;
 
	}
 
 
 
	switch(tps_capteur)
	{
	case 1:
		LectureTemperature();
		if(nbl<NOMBRE_ECHANT)
		{
			fichier=fopen("a5.txt","a");
			a5[nbl]=Capt.temp[1];
			fprintf(fichier,"nbl=%d _ a5[%d]=%lf\n",nbl,nbl,a5[nbl]);
			fclose(fichier);
		}
		tps_capteur=2;
	break;
	case 2:
		LectureTension();
		if(nbl<NOMBRE_ECHANT)
		{
			fichier=fopen("a6.txt","a");
			a6[(nbl)]=Capt.tension;
			fprintf(fichier,"nbl=%d _ a6[%d]=%lf\n",nbl,nbl,a6[nbl]);
			fclose(fichier);
		}
		tps_capteur=3;
	break;
	case 3:
		LectureIntensite();
		if(nbl<NOMBRE_ECHANT)
		{
			fichier=fopen("a7.txt","a");
			a7[nbl]=Capt.intensite;
			fprintf(fichier,"nbl=%d _ a7[%d]=%lf\n",nbl,nbl,a7[nbl]);
			fclose(fichier);
		}
		tps_capteur=4;
	break;
	case 4:
		LectureCosPhi();
		if(nbl<NOMBRE_ECHANT)
		{
			fichier=fopen("a8.txt","a");
			a8[nbl++]=Capt.cosphi;
			fprintf(fichier,"nbl=%d _ a8[%d]=%lf _ (nbl++)-> a8[%d]=%lf\n",nbl,nbl,a8[nbl],nbl++,a8[nbl++]);
			fclose(fichier);
		}
		if(nbl>=NOMBRE_ECHANT)
		{
			nbl=0;
			flagl=1;
		}
		tps_capteur=1;
 
		moy_capt[4]+=Capt.temp[1];
		moy_capt[5]+=Capt.tension;
		moy_capt[6]+=Capt.intensite;
		moy_capt[7]+=Capt.cosphi;
		LecturePuissance;  /*Definit dans lib.h*/
		moy_capt[8]+=Capt.puis[1];
		s_puis++;
		if(Capt.temps[1]>tps_alarme_puis)
			Cont.flag_puissance=1;
	break;
	}
 
	/* Reaffichage des courbes dans le panel controle pour
	 * augmenter le nombre de points vus sur le graphique */
	//Cont.affiche=1;
	//ChargeTmp();
 
 
	if(panel_manu==0)
		CheckAlarme(force_contact);
 
	if(Capt.temps[1]==0.0)
		tempsboucle=Timer();
 
	if(!InstallationEnService())
	{
		ArretUrgence();
		if(!pasremonter)
			pasremonter=1;
		break;
	}
 
	temps.debourrage=0.0;
 
	/* Distance de débourage atteinte */
	if( ((Capt.deplace[1] - distancetmp)>=Outil.debourrage)&&((Capt.deplace[1] - contactdalle)<(Outil.profondeur-10)) )
	{
		/* Lecture du temps avant le debourage */
		temps.debourrage=Timer();
 
		/* Memorisation de la profondeur avant debourrage & affichage operateur */
		distancetmp=(long)Capt.deplace[1];
 
		/* Debourrage jusqu'a distance debut de trou & affichage operateur */
		if(!RemonteeDebou(contactdalle))
		{
			ArretCmdeActionneur();
			pasremonter=1;
			break;
		}
		else
		{
			/* Descente de l'outil jusqu'a contact */
			DescenteContact(force_contact);
 
			/* Calcul du temps d'une boucle */
			temps.debourrage=Timer()-temps.debourrage;
		}
	}
	/* mise à jour affichage des valeurs */
	if ( (tempsboucle - temps.affiche ) > tps_aff )
	{
	/* Interface manuel si panel manu */
		if(panel_manu)
			AfficheManuel();
		else
			AfficheControl(contactdalle, poids);
 
		temps.affiche=Timer();
	}
 
	GetUserEvent (0, &panel, &ctrl);
 
	/* Calcul du temps total de percement durant toute la boucle */
	if(!pasremonter)
	{
		tempsboucle=(Timer()-tempsboucle);
		Capt.temps[1]+=(tempsboucle-temps.debourrage);
	}
}
 
ActiveControl();
 
if((Cont.alarme==0)||(Cont.alarme==PIC))
{
/* Temps de percement par trou */
	temps.percement=Timer()-tempsdeb;
	Capt.temps[1]=temps.percement;
}
else
{
	temps.percement=temps.fct_marteau;
	Capt.temps[1]=temps.percement;
}
 
if((Cont.alarme!=0)&&(Cont.alarme!=PIC))
{
	pasremonter=1;
	/* Si temps maxi on change juste de trou */
	if(Cont.alarme==8)
		Cont.alarme=0;
}
else
	pasremonter=0;
 
/* Test de temps minimum */
if( (Capt.temps[1] < Capt.temps[0])&&(Cont.alarme==0) )
{
		Cont.alarme = 7;
		AlarmeTempsMini();
		pasremonter=1;
}
 
if(Cont.alarme==PIC)
	Cont.alarme=0;
 
/* Le déplacement n'est pas une moyenne des deplacement */
moy_capt[1]=(Capt.deplace[1]-contactdalle);
 
moy_capt[0]/=s_force;
moy_capt[2]/=s_rota;
moy_capt[4]/=s_puis;
moy_capt[5]/=s_puis;
moy_capt[6]/=s_puis;
moy_capt[7]/=s_puis;
moy_capt[8]/=s_puis;
 
/* Remonter lente avec arret moteur DES LA SORTIE DU TROU */
if((!pasremonter)&&(Cont.alarme!=4))
{
	if(!RemonteeFin())
		Cont.alarme=REMONTER;
}
 
 
/* Moyenne des temps attendre arret moteur */
if(Cont.id_algo==1)
	moy_capt[9]=temps.fct_marteau;
else
	moy_capt[9]=temps.percement;
 
/* Affichage des dernieres valeurs (Capt.deplace deja modifier par remonter)*/
/* Temps de percement par trou */
AfficheControl((Capt.deplace[1]-moy_capt[1]), poids);
 
Cont.affiche=1;
if(flagi==1)
{
	fichier=fopen("a1rear.txt","a");
	RearangeTab(a1,nbi-1);
	fprintf(fichier,"nbi=%d _ a1[]=%lf\n",nbi,a1);
	fclose(fichier);
 
	fichier=fopen("a2rear.txt","a");
	RearangeTab(a2,nbi-1);
	fprintf(fichier,"nbi=%d _ a2[]=%lf\n",nbi,a2);
	fclose(fichier);
	nbi=NOMBRE_ECHANT;
}
 
if(flagj==1)
{
	fichier=fopen("a3rear.txt","a");
	RearangeTab(a3,nbj-1);
	fprintf(fichier,"nbj=%d _ a3[]=%lf\n",nbj,a3);
	fclose(fichier);
	nbj=NOMBRE_ECHANT;
}
 
if(flagk==1)
{
	fichier=fopen("a4rear.txt","a");
	RearangeTab(a4,nbk-1);
	fprintf(fichier,"nbk=%d _ a4[]=%lf\n",nbk,a4);
	fclose(fichier);
	nbk=NOMBRE_ECHANT;
}
 
if(flagl==1)
{
	fichier=fopen("a5rear.txt","a");
	RearangeTab(a5,nbl-1);
	fprintf(fichier,"nbl=%d _ a5[]=%lf\n",nbl,a5);
	fclose(fichier);
 
	fichier=fopen("a6rear.txt","a");
	RearangeTab(a6,nbl-1);
	fprintf(fichier,"nbl=%d _ a6[]=%lf\n",nbl,a6);
	fclose(fichier);
 
	fichier=fopen("a7rear.txt","a");
	RearangeTab(a7,nbl-1);
	fprintf(fichier,"nbl=%d _ a7[]=%lf\n",nbl,a7);
	fclose(fichier);
 
	fichier=fopen("a8rear.txt","a");
	RearangeTab(a8,nbl-1);
	fprintf(fichier,"nbl=%d _ a8[]=%lf\n",nbl,a8);
	fclose(fichier);
	nbl=NOMBRE_ECHANT;
}
 
 
 
/* Sauvegarde des fichiers de capteur temporaire */
if( ((Cont.alarme!=0)&&(Cont.alarme!=7))||(Cont.enregtmp==1))
{
	SauvTmp(a1,CAPT_FORCE_TMP,nbi);
	SauvTmp(a2,CAPT_DEPLACEMENT_TMP,nbi);
	SauvTmp(a3,CAPT_ROTATION_TMP,nbj);
	SauvTmp(a5,CAPT_TEMPERATURE_TMP,nbl);
	SauvTmp(a6,CAPT_TENSION_TMP,nbl);
	SauvTmp(a7,CAPT_INTENSITE_TMP,nbl);
	SauvTmp(a8,CAPT_COSPHI_TMP,nbl);
}
 
return(1);
}

Le contenu du tableau a1(a1.txt) est le suivant:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
nbi=0 _ a1[0]=13.380883
nbi=3 _ a1[3]=3.126977
nbi=6 _ a1[6]=0.563500
nbi=9 _ a1[9]=3.493188
nbi=12 _ a1[12]=11.549828
nbi=15 _ a1[15]=24.611352
nbi=18 _ a1[18]=34.499047
...
nbi=969 _ a1[969]=4.835961
nbi=972 _ a1[972]=13.869164
nbi=975 _ a1[975]=23.512719
nbi=0 _ a1[0]=12.892602
nbi=3 _ a1[3]=6.789086
nbi=6 _ a1[6]=0.929711
nbi=9 _ a1[9]=1.295922
nbi=12 _ a1[12]=2.394555
nbi=15 _ a1[15]=7.643578
...
nbi=939 _ a1[939]=3.004906
nbi=942 _ a1[942]=14.357445
nbi=945 _ a1[945]=22.902367
nbi=0 _ a1[0]=12.404320
nbi=3 _ a1[3]=3.859398
nbi=6 _ a1[6]=1.173852
nbi=9 _ a1[9]=0.807641
nbi=12 _ a1[12]=4.469750
nbi=15 _ a1[15]=11.427758
...
nbi=750 _ a1[750]=11.916039
nbi=753 _ a1[753]=10.939477
nbi=756 _ a1[756]=9.962914
nbi=759 _ a1[759]=9.108422
nbi=762 _ a1[762]=8.498070

Quelqu'un pourrai il m'expliquer l'incrementation d'une des variables nbi, car je ne vois pas comment ca se fait qu'elle s'incremente de 3 en 3.

04/05/2005, 19h45
Mac LAK

Citation:

Envoyé par calitom

Cette application fonctionnait sous windows 3.11. A ce moment ca fonctionnait. Et ils ont changé de carte d'acquisition et d'OS(Windows NT), et à partir de la ca ne fonctionnait plus correctement.

Bon, déjà, mal barré : la gestion des éléments périodiques n'est pas du tout la même sous Win 3.1 et Win NT : le premier utilise des services "type DOS" (=> très précis, mais flingue le multitâche), le second des OS timers (=> moins précis, mais les autres applis ne sont pas perturbées).

Citation:

Envoyé par calitom

C'est LabWindows/CVI v5.5.

Arf... LabWindows est bourré de particularités... Bon, c'est pas trop grave, mais ça risque de demander à refondre du code.

Citation:

Envoyé par calitom

L'acquisition se fait à l'aide d'une carte d'acquisition(PCI 6025E de National Instrument).

Donc, normalement, via un driver => pas de problème de "perte" de données, la cause est dans le cycle automate certainement.

Citation:

Envoyé par calitom

La fréquence d'acquisition n'est pas calculée, je la calcule en me basant sur le nombre de valeurs acquises/temps de percement.

Gni ??? Comment veux-tu gérer un échantillonnage sans fréquence d'échantillonnage ??? A quoi correspond alors ce 40 Hz vu un peu partout ??
=> Clarifie ce point stp, là c'est franchement pas normal.
04/05/2005, 19h49
Mac LAK

Citation:

Envoyé par calitom

J'ai récupérées les valeures à l'intérieur des tableaux a1,a2... qui stockent les valeurs lues par les capteurs. L'incrementation des variables nbi,nbj,nbl est bizarre. Elle se fait de 3 en 3, alors que je ne vois pas pourquoi. Je met le code en dessous:

Non, c'est normal. Regarde les lignes que j'ai isolées :

Code:

nbi=0;

Variable mise à zéro, RAS.

Code:

a2[nbi++]=(Capt.deplace[1]-contactdalle);

Post-incrémentation. RAS aussi.

Code:

fprintf(fichier,"nbi=%d _ a2[%d]=%lf _ (nbi++)-> a2[%d]=%lf\n",nbi,nbi,a2[nbi],nbi++,a2[nbi++]);

Boum la tête : ta ligne de debug utilise 2 "nbi++", donc deux post-incrémentations, donc... +2 à ta variable !! Rajoutes l'incrémentation "normale", tu obtiens bien ton +3.

Citation:

Envoyé par calitom

Quelqu'un pourrai il m'expliquer l'incrementation d'une des variables nbi, car je ne vois pas comment ca se fait qu'elle s'incremente de 3 en 3.

Tu as ta réponse.
Pour citer un ami, "Qui teste le code de test ?"... :twisted:
09/05/2005, 08h36
calitom

Citation:

Gni ??? Comment veux-tu gérer un échantillonnage sans fréquence d'échantillonnage ??? A quoi correspond alors ce 40 Hz vu un peu partout ??
=> Clarifie ce point stp, là c'est franchement pas normal.

La variable Freq.force est fixée à 44. Donc la période est 1/Freq.force. Mais normalement, on devrait avoir plus d'échantillons que ca, c'est pour ca que je ne comprend pas pourquoi avec cette fréquence on arrive pas à avoir les 1024 échantillons...
09/05/2005, 19h43
Mac LAK

Citation:

Envoyé par calitom

La variable Freq.force est fixée à 44. Donc la période est 1/Freq.force. Mais normalement, on devrait avoir plus d'échantillons que ca, c'est pour ca que je ne comprend pas pourquoi avec cette fréquence on arrive pas à avoir les 1024 échantillons...

Mais encore faut-il que tu puisse aller demander un sampling au moins une fois par période, tu ne crois pas ?
C'est cette ligne qui est "fautive" à priori :

Code:

if( Perio.force<=(tempsboucle-tps_force) )

car elle vérifie le temps "réel", et peut donc "sauter" des échantillons si elle a passé trop de temps dans le corps du "if". Il faudrait utiliser un timer et/ou un thread d'acquisition "pure".
10/05/2005, 08h22
calitom

Citation:

Envoyé par Mac LAK

Il faudrait utiliser un timer et/ou un thread d'acquisition "pure".

C'est à dire? Qu'est ce qu'un thread d'acquisition "pure"? Je ne vois pas vraiment ce que tu veux que j'essaye de faire...
10/05/2005, 18h21
Mac LAK

Citation:

Envoyé par calitom

C'est à dire? Qu'est ce qu'un thread d'acquisition "pure"? Je ne vois pas vraiment ce que tu veux que j'essaye de faire...

C'est pourtant simple : ta boucle fait un polling sur le temps écoulé (contrôlé par l'OS, et indépendant de ton programme) par rapport à une limite prédéfinie (deadline).
Par exemple, si tu dois faire une acquisition toutes les 20 ms, et que l'exécution de ta boucle prends 21 ms :
- 1ère étape : acquisition.
- 2ème étape : delta = 21, donc on n'effectue pas l'itération => acquisition perdue.
- 3ème étape : delta < 1 ms, donc acquisition.
- 4ème étape : delta = 22 ms => acquisition perdue.
etc, etc, etc.
C'est encore plus vicieux si ton temps d'exécution d'une itération est (par exemple) de 10 ms, mais que tu te fais "piquer" la main par un autre processus... :twisted: En ce cas, tu devras attendre la fin du quantum de temps de l'autre processus, soit 100 ms de manière générale...

La solution passe en général par un thread de très haute priorité (TIME_CRITICAL), qui ne fait qu'un traitement simple :
- Récupération de l'adresse du buffer d'échantillons (passé en paramètre du thread).
- Passage en priorité maximale.
- Attente d'un évènement => le thread est suspendu.
- L'application finit de préparer les données, puis déclenche l'évènement.
- Le thread se réveille immédiatement, car il est de priorité supérieure.
- Il va acquérir les données, mais l'attente entre deux samplings se fait via un appel à Sleep plutôt qu'une deadline (vérifier le temps d'exécution du sampling, s'il est long, afin de ne pas introduire de dérive temporelle).
- Pendant le Sleep du thread d'acquisition, l'application peut s'exécuter. Tu peux utiliser un compteur de samples auquel tu accèdes via les fonctions "Interlocked*" si tu as besoin de récupérer les informations en continu.
- Lorsque le Sleep est terminé, le thread d'acquisition reprend (presque) immédiatement la main, car de priorité supérieure. On peut aider ce passage de main en effectuant des Sleep(1) dans l'application, par exemple.
- Lorsque l'acquisition est terminée, le thread déclenche l'évènement indiquant à l'application que les 1024 échantillons sont obtenus, puis se se termine.
- L'application n'a plus qu'à finir la destruction du thread.

Une autre solution peut être faite à l'aide d'un timer, mais suivant l'implémentation, ce n'est pas toujours très précis...

Je repose ma question : quelle est la fréquence d'échantillonnage ? Ou, pour être plus précis, la période d'échantillonnage ? Un sample toutes les milli, toutes les 10, 20, 200 ms ? Suivant la précision requise, l'une ou l'autre des solutions sera préférable...

Tu comprends un peu mieux ?

Citation:

Envoyé par Mac LAK

Je repose ma question : quelle est la fréquence d'échantillonnage ? Ou, pour être plus précis, la période d'échantillonnage ? Un sample toutes les milli, toutes les 10, 20, 200 ms ? Suivant la précision requise, l'une ou l'autre des solutions sera préférable...

A vrai dire, je ne sais pas vraiment quelle est la fréquence d'échantillonage... Ce que j'ai réussi à comprendre, c'est que l'acquisition sur un capteur se fait à chaque appel d'une des fonctions du type:
Code:

1 2 LectureForce(); LectureDeplacement();
Ces fonctions font l'acquisition. Ci-dessous, la fonction Lecture Deplacement():
Code:

1 2 3 4 5 6 7 8 9 10 void LectureDeplacement(void) { /* Lecture du capteur de déplacement et conversion en mm */ /* lecture du capteur */ //CONF_DEPLACE; DEPLACE; /* conversion en mm */ Capt.deplace[1] = ((Capt.deplace[1] * 25.0 )- 10.5); }
DEPLACE; correspond à ce code:

Code:

#define DEPLACE AISampleChannel (2, "1", 10, 0, &Capt.deplace[1]);

La fonction AISampleChannel, fournie par LabWindows, fait l'acquisition sur la carte numéro "2", sur la voie "1", avec 10V max et 0V min, et range la valeur acquise dans Capt.deplace[1].
Ainsi, je pense que la fréquence d'acquisition dépend de la vitesse d'éxécution du programme. Mais c'est ce que je pense avoir compris...

11/05/2005, 13h58
Mac LAK

Citation:

Envoyé par calitom

Ainsi, je pense que la fréquence d'acquisition dépend de la vitesse d'éxécution du programme. Mais c'est ce que je pense avoir compris...

Oui, c'est ça.
Exemple caractéristique : l'appel à la fonction "Timer()" (elle fait quoi, d'ailleurs, cette babasse ???), qui manipule des flottants en plus (monumentale erreur).

Admettons que la ligne suivante :

Code:

if((Timer()-tempsdeb)>0.02)

, qui est une mesure de temps par deadline, soit exprimée en secondes : ça fait donc 20 ms. Il est beaucoup plus rapide et précis d'utiliser l'API Win32 et la fonction GetTickCount() à la place !! Que des entiers, précision à la milliseconde, gain de temps d'exécution important (les flottants renvoyés par Timer() sont forcément, d'une manière ou d'une autre, calculés à partir d'entiers), etc...

Même topo pour cette ligne :

Code:

if( Perio.force<=(tempsboucle-tps_force) )

.
Bref, arrange ça, tu vas déjà gagner pas mal de performances.
11/05/2005, 16h40
calitom

J'avais deja penser aux timer, mais je n'étais pas sur que ca venait de la...
Je vais essayer avec GetTickCount alors...
En tout cas, merci beaucoup de ton aide...
Je te tiens au courant du résultat...