Statistics
| Revision:

root / branch / bacher / Emb_App / programme_principal_etud.c @ 447

History | View | Annotate | Download (16.7 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
int cons=450; //contient la consigne
125
int retour=0; //contient la valeur retourner par le p?riph
126
int k=5; //contient le gain du correcteur de la boucle de r?gulation de la tourelle
127
int k2=1; //contient le gain du correcteur de l'angle des roues
128
int vitesse=0; //vitesse en ligne droite
129
int vitesse_virage=0; //vitesse dans les virages
130
int valeur=0; //contient la valeur ? envoyer
131
int distance=0; //mesure de la distance gr?ce au t?l?m?re
132
int cons_roue=700; //consigne du placement au milieu de la route
133
int ang_roue=0; //correction de l'angle ? effectuer
134
int numcapt=0; //num?ro du dernier capteur
135
int colcapt=0; //couleur du dernier capteur
136
int retour_C; //couleur & num?ro
137
int i_tremplin=0; //bool?en : 1=ligne du tremplin 0=autres lignes
138
int i_ralenti=0;
139
int i=0; //bool?en : 1=acc?l?ration avant le tremplin et d?sactivation de la rotation des roues 0= fonctionnement normal
140
int retour_M; //retour du p?riph?rique M
141
int num_piste=0; //contient l'identifiant de la piste
142
int col_feu=0; //contient la couleur du feu
143
int mode=0; //mode de ralentissemennt dans les virages
144
int compte_tour=0;
145
int i_tour=0;
146
int stop=0;
147
int i_urgence=0; //incr?ment d'urgence
148
int s_urgence=0; //signal d'urgence
149
int cu=0;
150
int i_ar=0;
151
int Temps;
152
int sec;
153
int cent_sec;
154
char c_Temps[6];
155

    
156
FLGPTN flag_capt;
157
FLGPTN flag_pist;
158

    
159
CanFrame vit_roue; //canal de commande de la vitesse
160
CanFrame capteur; 
161
CanFrame piste;
162
CanFrame demande_temps;
163

    
164
void demarre()
165
{
166
        piste.data.id='M';
167
          piste.data.rtr=1; 
168
        periph[ADDR('M')].ev=0x04;
169
        while(col_feu!=-1){
170
                snd_dtq(CanTx, piste.msg);
171
                wai_flg (ev_periph, 0x04, TWF_ANDW, &flag_pist);
172
        
173
                retour_M=periph[ADDR('M')].val;
174
                num_piste=retour_M & 0x007F;
175
                col_feu=retour_M>>15;
176
        
177
                switch(num_piste){
178
                        case 4: //piste noire
179
                                vitesse=30;
180
                                vitesse_virage=30;
181
                                mode=0;
182
                                break;
183
                        case 1: //piste verte
184
                                vitesse=60;
185
                                vitesse_virage=30;
186
                                mode=0;
187
                                break;
188
                        case 2: //piste bleue;
189
                                vitesse=50;
190
                                vitesse_virage=30;
191
                                mode=0;                
192
                                break;
193
                        case 3: //piste rouge
194
                                vitesse=60;
195
                                vitesse_virage=30;
196
                                mode=0;
197
                                break;
198
                }
199
                dly_tsk(200);
200
        }
201
        sta_tsk(ID_LCD);
202
        vit_roue.data.id='V'; 
203
    vit_roue.data.rtr=0; 
204
    vit_roue.data.val=vitesse;
205
        snd_dtq (CanTx,vit_roue.msg);
206
}
207

    
208
void asserv0()
209
{
210
        CanFrame comm;
211
        CanFrame req;
212
        CanFrame reponse;
213
        while(1){
214
                if(s_urgence==0){
215
                        
216
                    req.data.id='R'; 
217
                    req.data.rtr=1;
218
 
219
                    if(s_urgence==0)snd_dtq (CanTx,req.msg); // Interrogation du peripherique
220
                    retour=periph[ADDR('R')].val; // contient la valeur de retour du simulateur.
221
        
222
                    comm.data.id='T'; 
223
                    comm.data.rtr=0; 
224
                    comm.data.val=valeur;
225
                    if(s_urgence==0)snd_dtq (CanTx,comm.msg); //on envoie la modification ? effectuer
226
                        if(retour!=cons) valeur=k*(cons-retour);
227
                }
228
                dly_tsk(6);        
229
        }
230
}
231

    
232
int calcul_virage(int a) //modifie la vitesse dans les virages
233
{
234
        if (mode==0){
235
                if (a>-10 && a<10)        return vitesse;
236
                else return vitesse_virage;
237
        }
238
        if (mode==1){
239
                if (a>-10 && a<10){
240
                        return vitesse;}
241
                else if(a>0&&a<50) 
242
                        //return -a/2+vitesse;
243
                        return (a*a)/100-a+vitesse;
244
                else if(a<0&&a>-50) 
245
                        //return a/2+vitesse;
246
                        return (a*a)/100+a+vitesse;
247
                else if (a<-100||a>100){
248
                        return vitesse_virage;
249
                }
250
                else return ((-(a*a)/100)+vitesse);
251
        }
252
        if (mode==2){
253
                if (a>-10 && a<10){
254
                        return vitesse;}
255
                else if(a>0&&a<50) 
256
                        
257
                        return (a*a)/100-a+vitesse;
258
                else if(a<0&&a>-50) 
259
                        
260
                        return (a*a)/100+a+vitesse;
261
                else if (a<-100||a>100){
262
                        return vitesse_virage;
263
                }
264
                else return ((-(a*a)/100)+vitesse);
265
        }        
266
}
267
         
268
void mes_dist(){
269

    
270
        CanFrame req;
271
    UINT flag;
272
    while(1){
273
                if(s_urgence==0){        
274
                req.data.id='U';
275
                req.data.rtr=1;
276
                periph[ADDR('U')].ev=0x02;
277
                       if(s_urgence==0)snd_dtq(CanTx, req.msg);
278

    
279
                       wai_flg (ev_periph, 0x02, TWF_ANDW, &flag);
280
                       if (periph[ADDR('U')].val>900){
281
                        }
282
                        else {
283
                                distance=periph[ADDR('U')].val;
284
                                }
285
                }
286
                dly_tsk(6);                        
287
        }
288
}
289

    
290
void angle_roue()
291
{
292
    CanFrame req,comm;
293
    UINT flag;
294
           while (1) {
295
                if(s_urgence==0){        
296
                        req.data.id='D';
297
                req.data.rtr=1;
298
                periph[ADDR('D')].ev=0x01;
299
                if(s_urgence==0)snd_dtq(CanTx, req.msg);
300

    
301
                       wai_flg (ev_periph, 0x01, TWF_ANDW, &flag);
302
                ang_roue=periph[ADDR('D')].val;
303

    
304
                comm.data.id='D';
305
                comm.data.rtr=0; 
306
                if(i_tremplin==1) comm.data.val=0;
307
                        if(i_tremplin==0) comm.data.val=k2*(distance-cons_roue);                
308
                    if(i_tremplin==0 && i_ralenti==0 && stop==0) {
309
                                vit_roue.data.val=calcul_virage(k2*(distance-cons_roue)); 
310
                                  if(s_urgence==0)snd_dtq (CanTx,vit_roue.msg);
311
                        
312
                        }
313
                        if(s_urgence==0)snd_dtq(CanTx, comm.msg); 
314
                }
315
                dly_tsk(6);        
316
        }
317
}
318

    
319
void detect_capteur()
320
{
321
        while(1){
322
                
323
                capteur.data.id='C';
324
                capteur.data.rtr=1; 
325
                periph[ADDR('C')].ev=0x03;
326
                if(s_urgence==0)snd_dtq(CanTx, capteur.msg);
327
                wai_flg (ev_periph, 0x03, TWF_ANDW, &flag_capt);
328
        
329
                retour_C=periph[ADDR('C')].val;
330
                numcapt=retour_C & 0x00ff;
331
                if ((retour_C & 0xff00)!=colcapt) {
332
                colcapt=retour_C & 0xff00;
333
                }
334
                
335
                
336

    
337
//COMPTEUR DE TOUR
338
                
339
                if (retour_C==0x5605 && i_tour==0){
340
                        i_tour++;
341
                        compte_tour++;
342
                        if (compte_tour>=3){
343
                                stop=1;
344
                                vitesse=0; 
345
                                vitesse_virage=0;
346
                                vit_roue.data.val=vitesse;
347
                                snd_dtq (CanTx,vit_roue.msg);
348
                        }
349
                }
350
                if (retour_C==0x5601 && i_tour!=0){
351
                        i_tour=0;                
352
                        }        
353
                        
354
//CAPTEURS POUR LA PISTE ROUGE        
355
                if (retour_C==0x5603 && i==0 && num_piste==3){ //si on passe le capteur avant le tremplin
356
                        i++;
357
                        vitesse_virage=50;
358
                        dly_tsk(1500);
359
                        i_tremplin=1;
360
                        vitesse=45;
361
                        vitesse_virage=45;
362
                        dly_tsk(1000);
363
                        vitesse=20;
364
                        vitesse_virage=20;
365
                }
366
        
367
                if (retour_C==0x4203 && num_piste==3){ //si on passe le capteur apr?s le tremplin
368
                        i_tremplin=0;
369
                        i_ralenti=1;
370
                        vitesse=20;
371
                        vitesse_virage=20;
372
                        i=0;
373
                }
374
                
375
                if (retour_C==0x5604 && num_piste==3){
376
                        vitesse=40;
377
                        vitesse_virage=30;
378
                        i_ralenti=0;
379
                }        
380
                        
381
                if (retour_C==0x4304 && num_piste==3){ //on reprend les param?tres de d?part
382
                        vitesse=60;
383
                        vitesse_virage=30;
384
                        i_ralenti=0;
385
                }
386

    
387
                
388
/*        
389
//CAPTEURS POUR LA PISTE BLEUE
390
                if (retour_C==0x5604 & num_piste==2){ //avant la bosse de la piste bleue
391
                        vit_roue.data.val=40;
392
                        snd_dtq (CanTx,vit_roue.msg);
393
                        i_ralenti=1;
394
                }        
395
                if (retour_C==0x4204 & num_piste==2){ //apr?s la bosse de la piste bleue
396
                        vit_roue.data.val=vitesse; 
397
                          snd_dtq (CanTx,vit_roue.msg);
398
                        i_ralenti=0;
399
                }        
400
*/
401
        
402
//CAPTEURS POUR LA PISTE NOIRE
403
                if (retour_C==0x5601 && num_piste==4 && i==0){ //esquive des tonneaux
404
                        cons_roue=700;
405
                        vitesse=30;
406
                        vitesse_virage=30;
407
                        i_ralenti=0;
408
                        i_tremplin=1;
409
                        dly_tsk(2500);
410
                        i_tremplin=0;
411
                        cons_roue=450;
412
                        i++;
413
                }
414
                if (retour_C==0x4a01 && num_piste==4 && i==1){ //ralentissement dans le virage pour se coller ? la barri?re
415
                        vitesse=10;
416
                        vitesse_virage=10;
417
                        cons_roue=250;
418
                        i_ralenti=0;
419
                        i++;
420
                }
421
                if (retour_C==0x5602 && num_piste==4 && i==2){ //avant la bosse de la piste noire
422
                        vitesse=10;
423
                        vitesse_virage=10;
424
                        cons_roue=150;
425
                        i++;
426
                }        
427
                if (retour_C==0x5202 && num_piste==4){ //apr?s la bosse de la piste noire
428
                        cons_roue=700;
429
                        dly_tsk(1000);
430
                        vitesse=20;
431
                        vitesse_virage=20;
432
                        i=0;
433
                }
434
                if (retour_C==0x5603 && i==0 && num_piste==4){ //si on passe le capteur avant le tremplin
435
                        i++;
436
                        vitesse=43;
437
                        vitesse_virage=43;
438
                        cons_roue=700;
439
                        dly_tsk(2000);
440
                        i_tremplin=1;
441
                        dly_tsk(1500);
442
                        i_tremplin=0;
443

    
444
                }
445
        
446
                if (retour_C==0x4203 && num_piste==4 && i==1){ //si on passe le capteur apr?s le tremplin
447
                        i_tremplin=0;
448
                        i_ralenti=0;
449
                        vitesse=5;
450
                        vitesse_virage=5;
451
                        i++;
452
                        dly_tsk(2500);
453
                        vitesse=20;
454
                        vitesse_virage=20;
455
                        cons_roue=450;
456
                }
457
                
458
                if (retour_C==0x5604 && num_piste==4){ //on se d?cale et on ralentit pour les graviers
459
                        cons_roue=300;
460
                        vitesse=15;
461
                        vitesse_virage=15;
462
                        i_ralenti=0;
463
                }
464
                if (retour_C==0x4304 && num_piste==4 && i!=0){ //on reprend les param?tres de d?part
465
                        cons_roue=500;
466
                        vitesse=20;
467
                        vitesse_virage=20;
468
                        i=0;
469
                        dly_tsk(1500);
470
                        cons_roue=700;
471
                }
472
                
473
        dly_tsk(20);}
474
}
475

    
476
void urgence()
477
{
478
        while(1){
479
                
480
                while (p0_4==0){
481
                        vit_roue.data.val=0;                                         
482
                        snd_dtq (CanTx,vit_roue.msg);
483
                        i_ar=1;
484
                        LED_R=1;
485
                        cu=1;
486
                        s_urgence=1;
487
                        i_urgence=0;
488
                }
489
                if (p0_4==1 && i_urgence==0){
490
                        LED_R=0;
491
                        i_ar=0;
492
                        i_urgence==1;
493
                        s_urgence=0;
494
                        vit_roue.data.val=vitesse; 
495
                         snd_dtq (CanTx,vit_roue.msg);
496
                        cu=0;                
497
                }
498
        dly_tsk(20);
499
        }
500
}
501
char decode_int(int a){
502
        switch(a){
503
                case 0:
504
                        return '0';
505
                        break;
506
                case 1:
507
                        return '1';
508
                        break;
509
                case 2:
510
                        return '2';
511
                        break;
512
                case 3:
513
                        return '3';
514
                        break;
515
                case 4:
516
                        return '4';
517
                        break;
518
                case 5:
519
                        return '5';
520
                        break;        
521
                case 6:
522
                        return '6';
523
                        break;        
524
                case 7:
525
                        return '7';
526
                        break;
527
                case 8:
528
                        return '8';
529
                        break;
530
                case 9:
531
                        return '9';
532
                        break;
533
        }        
534
}
535

    
536
void aff_LCD()
537
{
538
        while(1){
539
//AFFICHAGE DE LA COULEUR ET DU CIRCUIT
540
                switch(colcapt){
541
                        case 0x5600:
542
                                lcd_init();
543
                                lcd_str("vert_");
544
                                break;
545
                        case 0x4a00:
546
                                lcd_init();
547
                                lcd_str("jaun_");
548
                                break;
549
                        case 0x5200:
550
                                lcd_init();
551
                                lcd_str("roug_");
552
                                break;
553
                        case 0x4200:
554
                                lcd_init();
555
                                lcd_str("bleu_");
556
                                break;
557
                        case 0x4300:
558
                                lcd_init();
559
                                lcd_str("cyan_");
560
                                break;
561
                }
562
                switch(num_piste){
563
                        case 1:
564
                                lcd_str("verte      ");
565
                                break;
566
                        case 2:
567
                                lcd_str("bleue      ");
568
                                break;
569
                        case 3:
570
                                lcd_str("rouge      ");
571
                                break;
572
                        case 4:
573
                                lcd_str("noire      ");
574
                                break;
575
                }
576
//AFFICHAGE DU TEMPS
577
                demande_temps.data.id='H';
578
            demande_temps.data.rtr=1;
579
        snd_dtq (CanTx,demande_temps.msg);                 // Interrogation du peripherique sur le temps de course actuel.
580
        Temps=periph[ADDR('H')].val; 
581
                c_Temps[0]=decode_int(Temps/1000);
582
                c_Temps[1]=decode_int((Temps%1000)/100);
583
                c_Temps[2]=':';
584
                c_Temps[3]=decode_int(((Temps%1000)%100)/10);
585
                c_Temps[4]=decode_int(((Temps%1000)%100)%10);
586
                c_Temps[5]=' ';
587
                lcd_str("Temps: ");
588
                lcd_str(c_Temps);
589
                dly_tsk(100);
590
        }
591
}        
592
void main()
593
{        
594
        ports_mcu();
595
    lcd_init();
596
        periph_init();
597
        periph_nom("#T2C*");
598

    
599
    can_init();
600
    clavier_init(1);
601
        capture_init();
602
        
603
        sta_cyc(ID_acqui);
604
        sta_tsk(ID_periph_rx);
605
        sta_tsk(ID_asserv0);
606
        sta_tsk(ID_mes_dist);
607
        sta_tsk(ID_angle_roue);
608
        sta_tsk(ID_demarre);
609
        sta_tsk(ID_capteur);
610
        sta_tsk(ID_urgence);
611

    
612
    while(1){
613
                        
614
        }         
615
}
616

    
617
void acqui()
618
{
619
        LED_V=!LED_V;
620
}
621