Statistics
| Revision:

root / branch / mbaye / Emb_App / programme_principal_etud.c @ 536

History | View | Annotate | Download (14.4 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
  
31
// Potentiometre: lire les registres ad00 et ad01, les valeurs sont sur 10 bits.
32

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

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

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

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

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

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

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

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

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

    
100

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

    
124
int pos;
125
int dis;
126
int capt;
127
UINT flag;
128
int dist;
129
int info_piste;
130
int numero_p;
131
int feu;
132
int tour=1;
133
int consigne =450;
134

    
135
void asserv_T()
136
{
137
        while(1)
138
        {
139
           CanFrame comm,req; 
140
           req.data.id='R'; req.data.rtr=1;
141
       periph[ADDR('R')].ev= 0x01;
142
           snd_dtq (CanTx,req.msg);
143
           wai_flg(ev_periph, 0x01, TWF_ANDW, &flag);
144
       pos = periph[ADDR('R')].val;
145
          // dly_tsk(100);
146
        
147
           comm.data.id='T'; comm.data.rtr=0; 
148
           comm.data.val=1.0*(consigne-pos);
149
           snd_dtq (CanTx,comm.msg);
150
           dly_tsk(50);
151
        }
152
        
153
}
154
void dist_T()
155
{
156
        while(1)
157
        {
158
           CanFrame comm,req;
159
           req.data.id='U'; req.data.rtr=1;
160
           periph[ADDR('U')].ev= 0x01;
161
           snd_dtq (CanTx,req.msg);
162
           wai_flg(ev_periph, 0x01, TWF_ANDW, &flag);
163
       dis = periph[ADDR('U')].val;
164
           
165
           comm.data.id='D'; comm.data.rtr=0; 
166
           
167
           if(numero_p==0x0002)
168
           
169
           {
170
            if(capt==(0x5603))
171
            {
172
                   comm.data.val=0;
173
               snd_dtq (CanTx,comm.msg);
174
                    if (dis>1000) 
175
                {
176
                      dis = 710;
177
                }
178
                    else
179
                {
180
                          dis = periph[ADDR('U')].val;
181
                  comm.data.val=-1.0*(710-dis);
182
                  snd_dtq (CanTx,comm.msg);
183
                }
184
             }
185
                else
186
                {
187
                        comm.data.val=-1.0*(710-dis);
188
                snd_dtq (CanTx,comm.msg);
189
                }
190
        
191
           }
192
           else if(numero_p==0x0003)
193
          
194
           {
195
                   if(capt==(0x5601))
196
               {
197
                      comm.data.val=0;
198
                  snd_dtq (CanTx,comm.msg);
199
                      if (dis>1000) 
200
                  {
201
                         dis = 710;
202
                  }
203
                      else
204
                  {
205
                             dis = periph[ADDR('U')].val;
206
                     comm.data.val=-1.0*(710-dis);
207
                     snd_dtq (CanTx,comm.msg);
208
                  }
209
               }
210
                   else if(capt==(0x5602))
211
                   {
212
                           comm.data.val=0;
213
                   snd_dtq (CanTx,comm.msg);
214
                       if (dis>1000) 
215
                   {
216
                         dis = 710;
217
                   }
218
                       else
219
                   {
220
                             dis = periph[ADDR('U')].val;
221
                     comm.data.val=-1.0*(710-dis);
222
                     snd_dtq (CanTx,comm.msg);
223
                   }
224
                          
225
               }
226
        
227
                   else if(capt==(0x5604))
228
                   {
229
                           comm.data.val=0;
230
                   snd_dtq (CanTx,comm.msg);
231
                       if (dis>1000) 
232
                   {
233
                         dis = 710;
234
                   }
235
                       else
236
                   {
237
                             dis = periph[ADDR('U')].val;
238
                     comm.data.val=-1.0*(710-dis);
239
                     snd_dtq (CanTx,comm.msg);
240
                   }
241
               }
242
                   else
243
                   {
244
                          comm.data.val=-1.0*(710-dis);
245
                  snd_dtq (CanTx,comm.msg);
246
                   }
247
                  
248
           }
249
           else if(numero_p==0x0001)
250
           
251
           {
252
                   comm.data.val=-1.0*(710-dis);
253
               snd_dtq (CanTx,comm.msg);
254
           }
255
           dly_tsk(20);
256
           
257
        }
258
}
259
void vitesse_roue()
260
{
261
        while(1)
262
        {
263
          CanFrame commv;
264
          commv.data.id='V'; commv.data.rtr=0; 
265
          if(Bp_G==1)
266
          {
267
                  commv.data.val=0;
268
              snd_dtq (CanTx,commv.msg);
269
                  LED_R=!LED_R;
270
          }
271
          if(Bp_M==1)
272
          {
273
                  commv.data.val=ad00+ad01;
274
              snd_dtq (CanTx,commv.msg);
275
                  LED_R=!LED_R;
276
          }
277
          if(tour==4)
278
          {
279
                  commv.data.val=0;
280
              snd_dtq (CanTx,commv.msg);
281
          }
282
      dly_tsk(3000);
283
          
284

    
285
          switch (numero_p)
286
          {
287
            //else if(numero_p==0x0001)
288
                case 0x0001:
289
                //{
290
                        
291
                  if(capt==0x5602)
292
                  {
293
                commv.data.val=40;
294
                snd_dtq (CanTx,commv.msg);
295
                  }
296
                  
297
                  else if(capt==0x5603)
298
                  {
299
                commv.data.val=40;
300
                snd_dtq (CanTx,commv.msg);
301
                  }
302
                  
303
                   else if(capt==0x5604)
304
                  {
305
                commv.data.val=40;
306
                snd_dtq (CanTx,commv.msg);
307
                  }
308
                  
309
                  else if(capt==0x5601)
310
                  {
311
                commv.data.val=40;
312
                snd_dtq (CanTx,commv.msg);
313
                  }
314
                  else
315
                  {
316
                    commv.data.val=15;
317
                snd_dtq (CanTx,commv.msg);        
318
                  }
319
                  break;
320
                //}
321
            //else if(numero_p==0x0002)
322
                case 0x0002:
323
                //{
324
                         if(capt==0x5602)
325
                  {
326
                commv.data.val=35;
327
                snd_dtq (CanTx,commv.msg);
328
                  }
329
                  else if(capt==0x4a01)
330
                  {
331
                commv.data.val=22;
332
                snd_dtq (CanTx,commv.msg);
333
                  }
334
                        
335
                  else if(capt==0x5603)
336
                  {
337
                commv.data.val=20;
338
                snd_dtq (CanTx,commv.msg);
339
                  }
340
                  else if(capt==0x5604)
341
                  {
342
                commv.data.val=30;
343
                snd_dtq (CanTx,commv.msg);
344
                  }
345
                  else
346
                  {
347
                    commv.data.val=20;
348
                snd_dtq (CanTx,commv.msg);        
349
                  }
350
                  break;
351
                //}
352
                //else if(numero_p==0x0003)
353
                case 0x0003:
354
                //{
355
                        
356
                  if(capt==0x5603)
357
                  {
358
                commv.data.val=70;
359
                snd_dtq (CanTx,commv.msg);
360
                        dly_tsk(4000);
361
                        commv.data.val=20;
362
                snd_dtq (CanTx,commv.msg);
363
                   }
364
                 /*else if(capt==0x7602)
365
                  {
366
                commv.data.val=12;
367
                snd_dtq (CanTx,commv.msg);
368
                  }*/
369
                  else
370
                  {
371
                    commv.data.val=35;
372
                snd_dtq (CanTx,commv.msg);        
373
                  }
374
                  break;
375
             //}
376
         case 0x0004:
377
         if(capt==0x5603)
378
                  {
379
                commv.data.val=70;
380
                snd_dtq (CanTx,commv.msg);
381
                        dly_tsk(4000);
382
                        commv.data.val=20;
383
                snd_dtq (CanTx,commv.msg);
384
                   }
385
         else
386
                  {
387
                    commv.data.val=35;
388
                snd_dtq (CanTx,commv.msg);        
389
                  }
390
                  break;
391
          }
392
         dly_tsk(30);
393
        }
394
}
395
 
396
void info_capt()
397
{
398
        while(1)
399
        {
400
           CanFrame req;
401
           req.data.id='C'; req.data.rtr=1;
402
           periph[ADDR('C')].ev= 0x01;
403
           snd_dtq (CanTx,req.msg);
404
           wai_flg(ev_periph, 0x01, TWF_ANDW, &flag);
405
       capt = periph[ADDR('C')].val;
406
           dly_tsk(30);
407
           if(capt==0x5602)
408
           {
409
                    tour=tour+1;
410
                        dly_tsk(30);
411
           }
412
        }
413
}
414
void mode_course()
415
{
416
        while(1)
417
        {
418
           CanFrame req;
419
           req.data.id='M'; req.data.rtr=1;
420
           periph[ADDR('M')].ev= 0x01;
421
           snd_dtq (CanTx,req.msg);
422
           wai_flg(ev_periph, 0x01, TWF_ANDW, &flag);
423
       info_piste = periph[ADDR('M')].val;
424
           numero_p= info_piste & 0x00FF;
425
           feu= info_piste & 0x8000;
426
           dly_tsk(50);
427
        }
428
}
429
void demarrage_feu()
430
{
431
        while(1)
432
        {
433
                if(feu==0x8000)
434
                {
435
                        sta_tsk(ID_vitesse_roue);
436
                }
437
        }
438
}
439

    
440
unsigned long Puiss10 (char indice)
441
{
442
        int i; 
443
        unsigned long puiss = 1;
444
        for(i=0;i<indice;i++)
445
        {
446
                puiss = puiss * 10;
447
        }
448
        return puiss;        
449
}
450
unsigned int decode_int(char *chaine){
451
unsigned int  nombre=0;
452
int entier[10]={0};
453
int i=0,j = 0, n = 0;
454
if(chaine[i] != '#') return -1;
455
i=1;
456
  while(chaine[i] != '*')
457
    {                
458
        if('0'>chaine[i] && chaine[i]>'9') return -1;
459
        entier[i-1] = chaine[i] - '0';
460
        i++;
461
    }
462
   for(j=0;j<i-1;j++)
463
    {
464
        nombre = nombre + entier[j]*Puiss10(i-2-j);        
465
    }
466
    return nombre;
467
}
468
void clavier() 
469
{
470
 char sequence[10]={0};
471
 short code_touche;
472
 int index = 1;
473
 while(1) 
474
 {
475
     vrcv_dtq(QdmTouche, &code_touche);
476
     lcd_putc(code_touche);
477
     while(code_touche != '*')
478
     {                
479
       if(code_touche == '#')
480
         {
481
            sequence[0] = code_touche; 
482
         } 
483
       else
484
         {
485
           sequence[index] = code_touche;
486
           index++;
487
         }
488
       vrcv_dtq(QdmTouche, &code_touche);
489
       lcd_putc(code_touche);
490
      }
491
         //lcd_com(0xC0);
492
      sequence[index] = '*';
493
      consigne = decode_int(sequence);
494
      index=1;
495
                
496
                
497
 }
498
 dly_tsk(60);
499
                
500
}
501

    
502
void main()
503
{
504
        ports_mcu();
505
    lcd_init();
506
        periph_init();
507
        periph_nom("#km07*");
508

    
509
    can_init();
510
    clavier_init(1);
511
        capture_init();
512

    
513
        sta_cyc(ID_acqui);
514
        sta_tsk(ID_periph_rx);
515
        
516
        sta_tsk(ID_asserv_T);
517
        //sta_tsk(ID_hcy_tourelle);
518
        sta_tsk(ID_dist_T);
519
//        sta_tsk(ID_demarrage_feu);
520
        sta_tsk(ID_vitesse_roue);
521
        sta_tsk(ID_info_capt);
522
        sta_tsk(ID_mode_course);
523
        sta_tsk(ID_clavier);
524
        
525
        
526
        
527
        
528

    
529
    while(1)
530
    {
531
                
532
          lcd_com(0x80);
533
                switch (numero_p){
534
                        case 0x0001:
535
                        lcd_str("Piste Verte");
536
                        break;
537
                        case 0x0002:
538
                        lcd_str("Piste Bleue");
539
                        break;
540
                        case 0x0003:
541
                        lcd_str("Piste Rouge");
542
                        break;
543
                        case 0x0004:
544
                        lcd_str("Piste Noire");
545
                        break;
546
                }
547
                 dly_tsk(50);
548
                 lcd_com(0xC0);
549
                 switch (capt){
550
                        case 0x5601:
551
                        lcd_str("Capteur vert");
552
                        break;
553
                        case 0x4a01:
554
                        lcd_str("Capteur Jaune");
555
                        break;
556
                        case 0x5202:
557
                        lcd_str("Capteur Rouge");
558
                        break;
559
                        case 0x4203:
560
                        lcd_str("Capteur Bleu");
561
                        break;
562
                        case 0x4304:
563
                        lcd_str("Capteur Cyan");
564
                        break;
565
                        dly_tsk(20);
566
                 }
567
          
568
    }
569
                
570
}
571

    
572
void acqui()
573
{
574
        LED_V=!LED_V;
575
}