execution switch

**calitom** · 03/05/2005, 14h56

Bonjour,

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

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

**sg-40** · 03/05/2005, 15h15

C'est là l'intérêt de mettre un break... Après avoir trouvé le bon stop

**jack69** · 03/05/2005, 15h18

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.

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

**calitom** · 03/05/2005, 15h25

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

:

**jack69** · 03/05/2005, 15h32

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

**Ti-R** · 03/05/2005, 15h33

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…

**calogerogigante** · 03/05/2005, 15h35

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

**calitom** · 03/05/2005, 15h42

voici le vrai code:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
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...

**Mac LAK** · 03/05/2005, 16h03

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

)

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

**calitom** · 03/05/2005, 16h25

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

**jack69** · 03/05/2005, 16h34

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.

**calitom** · 03/05/2005, 16h44

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

**Emmanuel Delahaye** · 03/05/2005, 18h12

Envoyé par calitom

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

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

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

**Emmanuel Delahaye** · 03/05/2005, 18h14

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.

**Mac LAK** · 03/05/2005, 20h46

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.

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.

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.

**calitom** · 04/05/2005, 08h27

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.

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

L'execution se fait sur un PC.

Quel compilateur (nom et version) ?

C'est LabWindows/CVI v5.5.

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

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.

**calitom** · 04/05/2005, 16h55

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 :

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

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

**Mac LAK** · 04/05/2005, 19h45

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

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.

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.

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.

**Mac LAK** · 04/05/2005, 19h49

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 :

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

nbi=0;

Variable mise à zéro, RAS.

Code :

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

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

Post-incrémentation. RAS aussi.

Code :

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

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.

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 ?"...

**calitom** · 09/05/2005, 08h36

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

execution switch

C

Vue hybride

Discussions similaires

Partager

Partager