Statistics
| Revision:

root / branch / sotty / Emb_App / programme_principal_etud.c @ 346

History | View | Annotate | Download (12.1 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 simulateur, 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
// Definition des codes commandes et requetes
124
#define VITESSE_ROUES 'V'
125
#define ANGLE_ROUES 'D'
126
#define VITESSE_TOURELLE 'T'
127
#define ANGLE_TOURELLE 'R'
128
#define DISTANCE_TELEMETRE 'U'
129
#define MODE_COURSE 'M'
130
#define INFO_CAPTEUR 'C'
131

    
132
//Definition des couleurs de piste
133
#define PISTE_VERTE 1
134
#define PISTE_BLEUE 2
135
#define PISTE_ROUGE 3
136
#define PISTE_NOIRE 4
137

    
138
void strategie(void);
139
void couleur_piste(void);
140
void rotation_tourelle(unsigned int angle);
141
int position_tourelle(void);
142
void asserv_tourelle(VP_INT stacd);
143
short distance_telemetre(void);
144
void vitesse_roue(unsigned int vitesse);
145
void angle_roue(unsigned int angle);
146
void asserv_roue(VP_INT stacd);
147
unsigned int send_requete(unsigned char id_periph);
148
void send_commande(unsigned char id_periph, unsigned int val);
149

    
150

    
151
short distance_mur = 0;
152
short angle_tourelle = 450;
153

    
154
const short vit_max = 30;
155
unsigned int vit_roue = 15;//*
156
short K_roue = 1;
157
short ang_roue = 0;
158
short capteur = 0;
159

    
160
char num_piste = -1;
161

    
162

    
163
void main()
164
{
165
        int k;
166

    
167
        //Initialise tous les peripheriques, taches et cycliques handler
168
        ports_mcu();
169
    lcd_init();
170
        periph_init();
171
        periph_nom("#Camobile*");
172
    can_init();
173
    clavier_init(1);
174
        capture_init();
175
        sta_tsk(ID_periph_rx);
176
        sta_cyc(ID_acqui);
177
        dly_tsk(100);
178
        sta_tsk(ID_asserv_tourelle);
179

    
180
        //Obtention de la couleur du feu
181
        while ( (send_requete(MODE_COURSE)>>15)==0 ){ //Attente que le feu soit vert  //**
182
                dly_tsk(50);
183
        }
184

    
185
        sta_tsk(ID_asserv_roue);
186
        for(k=1 ; k<=vit_max ; k++) {//*
187
                vit_roue = k;//**
188
                dly_tsk(100);
189
        }
190
        
191
        couleur_piste();
192
        
193
    while(1)
194
    {
195
                strategie();
196
                LED_J=1;
197
                dly_tsk(100);
198
                LED_J=0;
199
                dly_tsk(100);
200
                
201
    }
202
}
203

    
204
void couleur_piste(void){
205
        //Obtention de la piste
206
    num_piste = send_requete(MODE_COURSE) & 0x00FF;
207
}
208

    
209
void strategie(void){
210
        static int k = 0;
211
                
212
        capteur = send_requete(INFO_CAPTEUR);//**
213
        switch(num_piste){
214
            case PISTE_VERTE :
215
            break;
216

    
217
        case PISTE_BLEUE :
218
            break;
219

    
220
        case PISTE_ROUGE :
221
                        switch(capteur){
222
                                case 0x6301 : //Capteur perso avant bosse rouge
223
                                        ang_roue = 0;//*****
224
                                        vit_roue = 45;
225
                                        break;
226
                                        
227
                                case 0x4203 : //Capteur apres bosse rouge
228
                                        vit_roue = 8;
229
                                        k = 0;
230
                                        break;
231
                                        
232
                                case 0x6304 : // Capteur perso apres bosse rouge
233
                                        if (k == 0){
234
                                                k = vit_roue*3;
235
                                        }
236
                                        if(k < (vit_max-3)*3){
237
                                                vit_roue = k/3;
238
                                                k++;
239
                                        }
240
                                        break;
241
                                        
242
                                case 0x5604 :
243
                                        if(k < (vit_max-3)*3){
244
                                                vit_roue = k/3;
245
                                                k++;
246
                                        }
247
                                        break;
248
                                        
249
                                case 0x4304        : // Capteur avant fin
250
                                        vit_roue = vit_max;
251
                                        break;
252
                        }
253
            break;
254

    
255
        case PISTE_NOIRE :
256
                        switch(capteur){
257
                                case 0x6302 :
258
                                        if(distance_mur > 1000 || distance_mur < 0) {        //Trou dans le mur  //**
259
                                                ang_roue = 0;
260
                                        }
261
                                        else {
262
                                                ang_roue = (K_roue*(distance_mur-700));//**
263
                                        }
264
                                break;
265
                                
266
                                
267
                        }
268
            break;
269
        }
270
        
271
        
272
        
273
}
274

    
275

    
276
void maj_variables(void){
277
        if (Bp_G == 1){LED_R = 1;} //si bouton poussoire gauche appuy? allumer led rouge
278
        else{LED_R = 0;}
279

    
280
        //Angle des roues necessaire pour toutes les pistes
281
        distance_mur = distance_telemetre()*sin(3.1415*angle_tourelle/1800.0);
282
        if(distance_mur > 1000 || distance_mur < 0) {        //Trou dans le mur  //**
283
                ang_roue = 0;
284
        }
285
        else {
286
                ang_roue = (K_roue*(distance_mur-500));//**
287
        }
288

    
289
        
290

    
291
/*
292
        //Detection de couleur
293
        //8 bits de poids fort : couleur ('C','R','J','B' ou 'V')
294
        if((capteur && 0x0100) == 0x0100){} //Capteur cyan ? //********
295
    if((capteur && 0x0200) == 0x0200){} //Capteur rouge ?
296
    if((capteur && 0x0300) == 0x0300){} //Capteur jaune ?
297
    if((capteur && 0x0400) == 0x0400){} //Capteur bleu ?
298
    if((capteur && 0x0500) == 0x0500){} //Capteur vert ?
299
        */
300
}
301

    
302
void asserv_roue(VP_INT stacd){
303
//Maintient de la voiture au centre de la piste
304
        while(1){
305
                maj_variables();//***
306

    
307
                angle_roue(ang_roue);
308
                vitesse_roue(vit_roue);//****
309

    
310
                dly_tsk(25);//**50
311
        }
312
}
313

    
314
void asserv_tourelle(VP_INT stacd){
315
//Maintient de la tourelle orientee a 45 degre
316
        CanFrame comm;
317
        unsigned int vitesse_tourelle;
318
        char K = 2;
319

    
320
        while(1){
321
                vitesse_tourelle =        K*(angle_tourelle - position_tourelle());
322
                send_commande(VITESSE_TOURELLE, vitesse_tourelle);
323
                dly_tsk(25);//**
324
        }
325
}
326

    
327

    
328

    
329

    
330

    
331
void rotation_tourelle(unsigned int angle){
332
        send_commande(VITESSE_TOURELLE,angle);
333
}
334

    
335
int position_tourelle(){
336
//Renseigne sur la position de la tourelle (angle en dizieme de degre)
337
        int angle;
338

    
339
        angle = send_requete(ANGLE_TOURELLE);
340
        return angle;
341
}
342

    
343
short distance_telemetre(void){
344
//Renseigne la distance mesuree par le telemetre
345
        short distance;
346

    
347
        distance = send_requete(DISTANCE_TELEMETRE);
348
        return distance;
349
}
350

    
351
void vitesse_roue(unsigned int vitesse){
352
        send_commande(VITESSE_ROUES,vitesse);
353
}
354

    
355
void angle_roue(unsigned int angle){
356
        send_commande(ANGLE_ROUES,angle);
357
}
358

    
359
unsigned int send_requete(unsigned char id_periph){//**
360
        //Envoi la requete correspondant a lidentifiant id_periph
361
        CanFrame req;
362
        unsigned int val;
363
        UINT flag;
364

    
365
        req.data.id = id_periph;
366
        req.data.rtr = 1; // envoie d'une requete de lecture
367
        //periph[ADDR(id_periph)].ev = 0x01; //declenche un evenement quand mise a jour du peripherique id_periph
368
        dly_tsk(5);
369

    
370
        snd_dtq(CanTx, req.msg); // attente de la reponse
371
        //wai_flg(ev_periph, 0x01, TWF_ANDW, &flag);
372
        //periph[ADDR(id_periph)].ev = 0x00;
373
        val = periph[ADDR(id_periph)].val;
374
        return val;
375
}
376

    
377
void send_commande(unsigned char id_periph, unsigned int val){//**
378
        //Envoi la commande correspondant a lidentifiant id_periph avec la valeur val
379
        CanFrame comm;
380

    
381
        comm.data.id = id_periph;
382
        comm.data.rtr = 0;                                 //Ecriture
383
        comm.data.val =        val;
384
        snd_dtq(CanTx, comm.msg);
385
}
386

    
387
void acqui()
388
{
389
        LED_V = !LED_V;
390
}
391