Statistics
| Revision:

root / branch / porte / Emb_App / programme_principal_etud.c @ 372

History | View | Annotate | Download (18.8 KB)

1
 /***********************************************************************/
2
/*                                                                     */
3
/*  FILE        :test_compil.c                                         */
4
/*  DATE        :Fri, Sep 29, 2006                                     */
5
/*  DESCRIPTION :main program file.                                    */
6
/*  CPU GROUP   :87                                                    */
7
/*                                                                     */
8
/*  This file is generated by Renesas Project Generator (Ver.4.5).     */
9
/*   m308                                                                                                                           */
10
/*   nc308lib                                                                                                                   */
11
/*   c308mr                                                                                                                           */
12
/*   nc382lib                                                                                                                   */
13
/*                                                                     */
14
/***********************************************************************/
15
#include "sfr32c87.h"
16
#include <stdio.h>
17
#include <stdlib.h>
18
#include <itron.h>
19
#include <kernel.h>
20
#include "kernel_id.h"
21
#include "lcd.h"
22
#include "clavier.h"
23
#include "periph.h"
24
#include "uart0.h"
25
#include "can.h"
26
#include "carte_io.h"
27
#include "carte_m32.h"
28
#include <math.h>
29

    
30
// Potentiometre: lire les registres ad00 et ad01, les valeurs sont sur 10 bits.
31

    
32
// Clavier: vrcv_dtq(QdmTouche,&code_touche) pour lire la derniere touche appuyee sur le clavier.
33
//                         la variable code_touche doit etre du type short.
34

    
35
// Bouton poussoir: Bp_G, Bp_M, Bp_D permettent de lire l'etat des boutons de la carte I/O
36

    
37
// Leds: LED_R=1 ou LED_R=0 Pour allumer ou eteindre les leds (LED_R, LED_J, LED_V).
38

    
39
// Pour communiquer avec le simulateur utiliser une variable de type CanFrame,
40
// Definir les differents champs en utilisant la structure (S)eparee (comm.data)
41
// Envoyer le message complet en utilisant l'union (comm.msg)
42

    
43
// Exemple:
44
//                 CanFrame comm;
45
//                        comm.data.id='T'; comm.data.rtr=0; comm.data.val=-100;
46
//                        snd_dtq (CanTx,comm.msg);
47

    
48
// Pour interroger un peripherique et recuperer les donnees brutes renvoyees simulateur:
49
//                CanFrame demande;
50
//                CanFrame reponse;
51
//
52
//                        demande.data.id='R'; demande.data.rtr=1;
53
//                        snd_dtq (CanTx,demande.msg); // Interrogation du peripherique
54
//                         rcv_dtq (CanRx,&reponse.msg); // Attente de la reponse
55
//                         reponse.data.val contient la valeur de retour du simulateur.
56
// ATTENTION: Ne pas utiliser rcv_dtq(CanRx... si la tache ID_periph_rx est active
57

    
58
// Lors de l'utilisation de la tache de reception et distribution des messages ID_periph_rx
59
// Demarrer cette tache : sta_tsk(ID_periph_rx);
60
// Pour lire la valeur d'un peripherique:
61
// Il faut envoyer une demande de lecture:
62
//         CanFrame comm;
63
//                 comm.data.id='R'; comm.data.rtr=1;
64
//                 snd_dtq (CanTx,comm.msg);
65
//
66
// Des l'arrivee de la reponse du simlateur, les variables suivantes sont mises a jour:
67
// periph[ADDR('R')].val : contient la derniere valeur renvoyee par le simulateur.
68
//
69
// Pour verifier si une nouvelle valeur a ete recue utiliser:
70
// periph[ADDR('R')].maj (incremente a chaque reception).
71

    
72
// Pour qu'un evenement soit declenche lors de la reception d'une donnee pour un peripherique:
73
// periph[ADDR('R')].ev=0x01;
74
// Pour se mettre en attente de l'evenement: wai_flg (ev_periph,0x01,TWF_ORW,&flag); // Declarer la variable flag comme : FLGPTN flag
75
// Attention l'evenement n'est pas efface apres reception, il faut donc utiliser clr_flg(ev_periph,~0x01); par example
76

    
77
// Les evenements:
78
// Si le simulateur envoi un evenement sur 16 bits il est recu grace a:
79
// par exemple:  wai_flg(event,(FLGPTN) 0x0007,TWF_ORW,&flag); // Declarer la variable flag comme : FLGPTN flag
80
// Attention l'evenement n'est pas efface apres reception, il faut donc utiliser clr_flg(event,~flag); par example
81
//Bit   Information associee            Remarque
82
//0     Capteur Vert,                   remis a zero lors de la lecture du peripherique 'C'
83
//1     Capteur Jaune,                  remis a zero lors de la lecture du peripherique 'C'
84
//2     Capteur Rouge,                  remis a zero lors de la lecture du peripherique 'C'
85
//3     Capteur Bleu,                   remis a zero lors de la lecture du peripherique 'C'
86
//4     Capteur Cyan,                   remis a zero lors de la lecture du peripherique 'C'
87
//5
88
//6     Collision avec le sol,          remise a zero au changement de piste.
89
//7     Fin de course (capteur vert),   remis a zero lors de la lecture du peripherique 'C'
90
//8     La piste a change ,             remis a zero lors de la lecture du peripherique 'M'
91
//9     Le mode de course a change ,    remis a zero lors de la lecture du peripherique 'M'
92
//10
93
//11    Le vehicule a termine un tour,   remis a zero au changement du mode de course.
94
//12    Sortie de la piste,
95
//13    Teleportation a ete utilisee,   remis a zero au changement de piste ou du mode de course.
96
//14    Faux depart                     remise a zero au changement du mode de course.
97
//15
98

    
99

    
100
// Peripheriques disponibles:
101
//'V'/86/0x56?: Commande en vitesse des roues motrices du vehicule (en radian /secondes).
102
//'D'/68/0x44?: Commande de l'angle des roues directrices (en 1/10 de degre).
103
//'T'/84/0x54?: Commande en vitesse de la tourelle portant le telemetre (en 1/10 de degre/secondes).
104
//'R'/82/0x52?: Lecture de l'angle effectif de la tourelle portant le telemetre (en 1/10 de degre).
105
//'U'/85/0x55?: Distance mesuree par le telemetre (1/100 de metre)
106
//'N'/78/0x4E?: Numero de la voiture (en fonction de l'ordre de connexion)
107
//'E'/69/0x45?: Lecture des evenements,
108
//'H'/72/0x48?: Donne le temps de course actuel
109
//'S'/83/0x53?: Temps du tour precedent
110
//'M'/77/0x7D?: Mode de course :
111
//  Bit 15?: Etat feu tricolore ( 1 -> Vert, 0 -> Orange ou Rouge),
112
//  Bits 14-8?: 1 Attente, 2 course, 3 essais libres)
113
//  Bits 7-0?: numero de la piste
114
//'C'/67/0x43?: Informations sur le dernier capteur touche :
115
//  8 bits de poids faible?: numero du capteur
116
//  8 bits de poids fort?: couleur ('C','R','J','B' ou 'V')
117
//'J'/74/0x4A : Proposition d'un code de d?v?rouillage.
118
//'j'/106/06A : R?cup?ration du r?sultat de dernier code envoy?. 0x77 si aucun code n'a ?t? soumis. <0 si la r?ponse n'est pas
119
//                                disponible. 0xab avec a-> nombre de couleurs bien plac?es et b -> couleurs pr?sentes mais mal plac?es.
120
//'I'/73/Ox49 : D?finition du nom du v?hicule. Doit d?buter par le caract?re '#' et entraine le chargement de la configuration de piste
121
//                                correspondant au nom du v?hicule si le nom se termine par '*'
122

    
123
// +-----------------------------------------------------+
124
// |                                     Constantes                                |
125
// +-----------------------------------------------------+
126
const Vitesse_max=99, Vitesse_min=0, Vitesse_noir=12;
127
const Kpt=1 , Kdt=0.1, Kdr=0.2, Kpr=1;                                                                                        //Param?tre des PD de la tourelle et des roues
128

    
129
// +-----------------------------------------------------+
130
// |                                     Variables                                |
131
// +-----------------------------------------------------+
132
//Variables pour l'asserivssement des roues, de la vitesse et du telemetre
133
unsigned int Angle_T=0, Consigne_T=400, Consigne_T_noir=900;                                                //prend la valeur de l'angle au temps t-1 //Consigne de l'angle de la tourelle (consigne/10=>degr?s)
134
unsigned int valeur=0, Saut=0;                                                                                 //valeur transmise corrig?
135
unsigned int Somme_Erreur=0, Erreur=0;                        
136
unsigned int ErreurRoues=0,Somme_ErreurRoues=0;
137
unsigned int vit=0, i=1, Distance;                
138
unsigned int Angle_R=0, Vitesse_vert=40,Vitesse_bleu=35,Vitesse_rouge=30;                                        //Angle des roues
139
//Variable de la fonction Capteur
140
unsigned int Info_capteur, couleur_capteur, num_capteur;
141
//Variable de la fonction Distance_bord
142
unsigned int Bord_defaut=0, ecart=400, distance_bord=790, distance_bord_noir=500;
143
//Variable des fonctions IHM
144
short Touche_clavier, Temps=0;
145
//char *Temps;
146
//Variable de la fonction Circuit
147
unsigned int Info_circuit, Etat_feu, Num_circuit=0, Depart_ok=0, Arret_urgence=0;
148
//Variable de la fonction Evenement
149
unsigned int Lecture_eve;
150
FLGPTN test;
151

    
152

    
153
// +-----------------------------------------------------+
154
// |                             Asservissement tourelle                    |
155
// +-----------------------------------------------------+
156
void Asserv_T(){        
157
        
158
        //'T'/84/0x54?: Commande en vitesse de la tourelle portant le telemetre (en 1/10 de degre/secondes).
159
        //'R'/82/0x52?: Lecture de l'angle effectif de la tourelle portant le telemetre (en 1/10 de degre).
160
        CanFrame comm;
161
        CanFrame demande;
162
        CanFrame reponse;
163
        while(1){
164
                        
165
                demande.data.id='R'; 
166
                demande.data.rtr=1;
167
                
168
        
169
                snd_dtq (CanTx,demande.msg);                         // Interrogation du peripherique sur la position de la tourelle
170
                Angle_T=periph[ADDR('R')].val;                         // contient la valeur de retour du simulateur de l'angle de la tourelle.
171
                
172
                comm.data.id='T'; 
173
                comm.data.rtr=0; 
174
                comm.data.val=valeur;                                        // Commande de l'angle de la tourelle 
175
                snd_dtq (CanTx,comm.msg);                                // Envoi de la commande                
176
                
177
                dly_tsk(100);
178
                }
179
        }
180

    
181
void Asserv_T_hc(){
182
        
183
        switch(Num_circuit){                        
184
                        case 1:
185
                                Erreur=Consigne_T-Angle_T;
186
                        break;
187
                        case 2:
188
                                Erreur=Consigne_T-Angle_T;
189
                        break;
190
                        case 3:
191
                                Erreur=Consigne_T-Angle_T;
192
                        break;
193
                        case 4:
194
                                 Erreur=Consigne_T_noir-Angle_T;
195
                        break;                        
196
                }
197
        if(Angle_T!=Consigne_T)
198
                valeur=Kpt*Erreur+Kdt*Somme_Erreur;                                        //correction de l'angle par handler cyclique de la tourelle
199
        }
200

    
201
// +-----------------------------------------------------+
202
// |                             Asservissement Roues                            |
203
// +-----------------------------------------------------+
204

    
205
void Asserv_R(){
206
        
207
        //'D'/68/0x44?: Commande de l'angle des roues directrices (en 1/10 de degre).
208
        CanFrame comm;
209
        CanFrame demande;
210
        CanFrame reponse;
211
        
212
        dly_tsk(1000);
213
        while(1){
214
                
215
                comm.data.id='D'; //Commande de l'angle des roues
216
                comm.data.rtr=0; 
217
                comm.data.val=Angle_R;
218
                snd_dtq (CanTx,comm.msg);//Envoi de la commande
219
                                
220
                dly_tsk(1);
221
                }
222
        }
223

    
224
void Asserv_R_hc(){        
225
        
226
        ErreurRoues=distance_bord-Distance;
227
        Somme_ErreurRoues+=ErreurRoues;
228
        switch(Num_circuit){
229
                        case 1:
230
                                if(Distance != distance_bord && Bord_defaut == 0){
231
                                        Angle_R=-1*(Kpr*ErreurRoues+Kdr*Somme_ErreurRoues);}                                //correction de l'angle par handler cyclique des roues
232
                        break;
233
                        case 2:
234
                                if(Distance != distance_bord && Bord_defaut == 0){
235
                                        Angle_R=-1*(Kpr*ErreurRoues+Kdr*Somme_ErreurRoues);}                                //correction de l'angle par handler cyclique des roues
236
                        break;
237
                        case 3:
238
                                if(Distance != distance_bord && Bord_defaut == 0 && num_capteur != 0x66F0){
239
                                        Angle_R=-1*(Kpr*ErreurRoues+Kdr*Somme_ErreurRoues);}                                //correction de l'angle par handler cyclique des roues                                        
240
                        break;
241
                        case 4:
242
                                if(Distance != distance_bord_noir && Bord_defaut == 0){
243
                                        Angle_R=-1*(Kpr*ErreurRoues+Kdr*Somme_ErreurRoues);}                                //correction de l'angle par handler cyclique des roues
244
                        break;
245
                        default : 
246
                                if(Distance != distance_bord && Bord_defaut == 0){
247
                                Angle_R=-1*(Kpr*ErreurRoues+Kdr*Somme_ErreurRoues);}
248
        }
249
}
250

    
251
// +-----------------------------------------------------+
252
// |                             Asservissement Vitesse                    |
253
// +-----------------------------------------------------+
254
void Asserv_V(){
255
        
256
        //'V'/86/0x56?: Commande en vitesse des roues motrices du vehicule (en radian /secondes).
257
        CanFrame comm;
258
        CanFrame demande;
259
        CanFrame reponse;
260
        
261
        dly_tsk(2500);
262
        while(1){                
263
        
264
                comm.data.id='V';                                                 //Commande de la vitesse des roues motrices
265
                comm.data.rtr=0;
266
                
267
                switch(Num_circuit){                        
268
                        case 1:        
269
                                if(Depart_ok == 1 && Arret_urgence == 0){                
270
                                        if(couleur_capteur == 0x560){                                // Commande de vitesse pour les lignes droites (dernier capteur detecte = vert).
271
                                                comm.data.val=Vitesse_vert;        
272
                                                snd_dtq (CanTx,comm.msg);                        // Envoi de la commande de vitesse
273
                                        }
274
                                        else{                                                                        // Ralentissement en cas de virage.
275
                                                comm.data.val=Vitesse_vert/1.2;        
276
                                                snd_dtq (CanTx,comm.msg);
277
                                        }
278
                                }
279
                                else{
280
                                        comm.data.val=0;        
281
                                        snd_dtq (CanTx,comm.msg);
282
                                }
283
                        break;
284
                        case 2:        
285
                                if(Depart_ok == 1 && Arret_urgence == 0){                
286
                                        if(couleur_capteur == 0x560){                                // Commande de vitesse pour les lignes droites (dernier capteur detecte = vert).
287
                                                comm.data.val=Vitesse_bleu;        
288
                                                snd_dtq (CanTx,comm.msg);                        // Envoi de la commande de vitesse
289
                                        }
290
                                        else{                                                                        // Ralentissement en cas de virage.
291
                                                comm.data.val=Vitesse_bleu/1.3;        
292
                                                snd_dtq (CanTx,comm.msg);
293
                                        }
294
                                }
295
                                else{
296
                                        comm.data.val=0;        
297
                                        snd_dtq (CanTx,comm.msg);
298
                                }
299
                        break;
300
                        case 3 :
301
                                if(Depart_ok == 1 && Arret_urgence == 0){
302
                                        if(couleur_capteur == 0x560){                                // Commande de vitesse pour les lignes droites (dernier capteur detecte = vert).
303
                                        comm.data.val=Vitesse_rouge;        
304
                                        snd_dtq (CanTx,comm.msg);                        // Envoi de la commande de vitesse
305
                                        }
306
                                        else if(couleur_capteur == 0x0766 && num_capteur == 0x66F0){                                //Accel?ration pour passer le saut
307
                                        comm.data.val=45;        
308
                                        snd_dtq (CanTx,comm.msg);
309
                                        }
310
                                        else{                                                                        // Ralentissement en cas de virage.
311
                                        comm.data.val=Vitesse_rouge/1.5;        
312
                                        snd_dtq (CanTx,comm.msg);
313
                                        }
314
                                }
315
                        break;
316
                        case 4 : 
317
                                if(Depart_ok == 1 && Arret_urgence == 0){
318
                                        comm.data.val=Vitesse_noir;        
319
                                        snd_dtq (CanTx,comm.msg);
320
                                }
321
                        break;                                        
322
                        default : 
323
                                comm.data.val=0;        
324
                                snd_dtq (CanTx,comm.msg);
325
                }
326
                                
327
        dly_tsk(10);
328
        }
329
}
330

    
331
// +-----------------------------------------------------+
332
// |                             Commande capteur                                    |
333
// +-----------------------------------------------------+
334
void Capteur(){
335
        
336
        //'C'/67/0x43?: Informations sur le dernier capteur touche :
337
        //  8 bits de poids faible?: numero du capteur
338
        //  8 bits de poids fort?: couleur ('C','R','J','B' ou 'V')
339
        CanFrame comm;
340
        CanFrame demande;
341
        CanFrame reponse;
342
        
343
        while(1){
344
                
345
                demande.data.id='C';
346
                demande.data.rtr=1;
347
                snd_dtq (CanTx,demande.msg);                                 // Interrogation du peripherique sur les donnees du dernier capteur touch?.
348
                Info_capteur=periph[ADDR('C')].val;                 // contient la valeur de retour du simulateur sur le dernier capteur touch?.
349
                couleur_capteur=Info_capteur >> 4;
350
                num_capteur=Info_capteur << 4;
351
                
352
                dly_tsk(100);
353
        }
354
        
355
        
356
}
357

    
358

    
359
// +-----------------------------------------------------+
360
// |                             Gestion des troues                                    |
361
// +-----------------------------------------------------+
362

    
363
void Distance_bord(){
364
        
365
        //'U'/85/0x55?: Distance mesuree par le telemetre (1/100 de metre).
366
        CanFrame comm;
367
        CanFrame demande;
368
        CanFrame reponse;
369
        
370
        while(1){
371
                
372
                demande.data.id='U';
373
                demande.data.rtr=1;
374

    
375
                snd_dtq (CanTx,demande.msg); // Interrogation du peripherique sur la distance mesure par le telemetre.
376
                Distance=periph[ADDR('U')].val; // contient la valeur de retour du simulateur sur la distance mesur? par le telemetre.
377
                
378
                switch(Num_circuit){
379
                        case 1:
380
                                if(Distance > distance_bord+ecart  || Distance < distance_bord-ecart){
381
                                Bord_defaut=1;
382
                                }
383
                                else{
384
                                Bord_defaut=0;
385
                                }
386
                        break;
387
                        case 2:
388
                                if(Distance > distance_bord+ecart  || Distance < distance_bord-ecart){
389
                                Bord_defaut=1;
390
                                }
391
                                else{
392
                                Bord_defaut=0;
393
                                }
394
                        break;
395
                        case 3:
396
                                if(Distance > distance_bord+ecart  || Distance < distance_bord-ecart){
397
                                Bord_defaut=1;
398
                                }
399
                                else{
400
                                Bord_defaut=0;
401
                                }
402
                        break;
403
                        case 4:
404
                                if(Distance > distance_bord_noir+ecart  || Distance < distance_bord_noir-ecart){
405
                                Bord_defaut=1;
406
                                }
407
                                else{
408
                                Bord_defaut=0;
409
                                }
410
                        break;
411
                }
412
                dly_tsk(10);        
413
        }
414
}
415

    
416
// +-----------------------------------------------------+
417
// |                             Commande IHM                                            |
418
// +-----------------------------------------------------+
419
void Commande_clavier(){
420
        
421
        // Interface Homme Machine muni du clavier matricielle, de l'?cran LCD,
422
        // des LEDs, des potentiometre et des interrupteurs.
423
        
424
        while(1){
425
                                
426
                vrcv_dtq(QdmTouche, &Touche_clavier);
427
                
428
                if(Touche_clavier != 0){
429
                        if(Touche_clavier != 42 && Touche_clavier != 35){
430
                                vit = vit*i+(Touche_clavier-48);
431
                                i = 10*i;                
432
                        }
433
                        else if(Touche_clavier == 42 || Touche_clavier == 35){
434
                                if(vit < 100 && vit > 0){
435
                                        Vitesse_vert = vit;
436
                                }
437
                                vit = 0;
438
                                i = 1;                        
439
                        }                                        
440
                        Touche_clavier=0;
441
                        dly_tsk(100);                
442
                }
443
                
444
        dly_tsk(100);        
445
        }                
446

    
447
}
448

    
449
void Commande_LCD(){
450
        
451
        //'H'/72/0x48?: Donne le temps de course actuel
452
        CanFrame comm;
453
        CanFrame demande;
454
        CanFrame reponse;
455
        
456
        while(1){
457
                
458
                demande.data.id='H';
459
                demande.data.rtr=1;
460

    
461
                snd_dtq (CanTx,demande.msg);                 // Interrogation du peripherique sur le temps de course actuel.
462
                Temps=periph[ADDR('H')].val;                 // contient la valeur de retour du simulateur sur le temps de course actuel.
463
                
464
                lcd_init();
465
                switch(Num_circuit){                
466
                        case 1:                lcd_str("VERT");        break;
467
                        case 2:                lcd_str("BLEU");        break;
468
                        case 3:                lcd_str("ROUGE");        break;
469
                        case 4:                lcd_str("NOIR");        break;
470
                        default :        lcd_str("Inconnu");        
471
                }
472
                lcd_putc('|');
473
                switch(Info_capteur){                
474
                        case 0x560:                lcd_str("VERT");        break;
475
                        case 0x430:                lcd_str("NOIR");        break;
476
                        case 0x520:                lcd_str("ROUGE");        break;
477
                        case 0x4a0:                lcd_str("JAUNE");        break;
478
                        case 0x420:                lcd_str("BLEU");        break;
479
                        default :        lcd_str("!!");        
480
                }
481
                lcd_putc('|');
482
                //lcd_str('Temps');
483
                                
484
                dly_tsk(1000);
485
        }
486
}
487

    
488
void Bp_hc(){
489
        
490
        if(Bp_G == 1){ Arret_urgence = 1;}
491
        if(Bp_G == 0){ Arret_urgence = 0;}
492
        
493
}
494

    
495
// +-----------------------------------------------------+
496
// |     Gestion des informations de la piste                            |
497
// +-----------------------------------------------------+
498
void Circuit(){
499
        
500
        //'M'/77/0x7D?: Mode de course :
501
        //  Bit 15?: Etat feu tricolore ( 1 -> Vert, 0 -> Orange ou Rouge),
502
        //  Bits 14-8?: 1 Attente, 2 course, 3 essais libres)
503
        //  Bits 7-0?: numero de la piste
504
        CanFrame comm;
505
        CanFrame demande;
506
        CanFrame reponse;
507
        
508
        while(1){
509
                
510
                demande.data.id='M';
511
                demande.data.rtr=1;
512
                snd_dtq (CanTx,demande.msg);                                                 // Interrogation du peripherique sur les information du circuit.
513
                Info_circuit=periph[ADDR('M')].val;
514
                Num_circuit=Info_circuit & 0x000F;
515
                Etat_feu=Info_circuit >> 15;                                                 // contient la valeur de retour du simulateur sur l'?tat du feu tricolore.
516
                
517
                if( Etat_feu == 1){ Depart_ok = 1;}                                        // Passe la variable permettant le d?part ? 1.
518
                dly_tsk(200);
519
        }
520
                
521
}
522

    
523
void Evenement(){ // non fonctionnelle
524
        
525
        //'E'/69/0x45?: Lecture des evenements,
526
        CanFrame comm;
527
        CanFrame demande;
528
        CanFrame reponse;
529
        
530
        while(1){
531
                
532
                wai_flg(event,(FLGPTN) 0x0800, TWF_ANDW,&test);
533
                
534
                dly_tsk(800);
535
        }
536
                
537
}
538

    
539
// +-----------------------------------------------------+
540
// |                                             main                                                            |
541
// +-----------------------------------------------------+
542
void main()
543
{
544
        ports_mcu();
545
    lcd_init();
546
        periph_init();
547
        periph_nom("#Troen*");
548

    
549
    can_init();
550
    clavier_init(1);
551
        capture_init();
552

    
553
        sta_cyc(ID_acqui);
554
        sta_tsk(ID_periph_rx);
555

    
556
        sta_tsk(ID_Asserv_T);
557
        sta_cyc(ID_Asserv_T_hc);
558
        
559
        sta_tsk(ID_Asserv_R);
560
        sta_cyc(ID_Asserv_R_hc);
561
        
562
        sta_tsk(ID_Asserv_V);
563
        
564
        sta_tsk(ID_Capteur);
565
        
566
        sta_tsk(ID_Distance_bord);
567
        
568
        sta_tsk(ID_Commande_clavier);
569
        sta_cyc(ID_Bp_hc);
570
        sta_tsk(ID_Commande_LCD);
571
        
572
        
573
        sta_tsk(ID_Circuit);
574
        
575
        sta_tsk(ID_Evenement);
576
                
577
    while(1)
578
    {
579
        
580
    }
581
}
582

    
583
void acqui()
584
{
585
        LED_V=!LED_V;
586
}
587