Revision 310 branch/nan_cao/Emb_App/programme_principal_etud.c

View differences:

programme_principal_etud.c
123 123

  
124 124
short alpha; 
125 125
short distance;
126
short vitesse, longueur;
127
int g=1;					//gain angle de roue
128
int g2=1;					//gain vitesse de tourelle
126
short vitesse;
127
short vitourelle;
128
short num_piste;
129
int m;
130
int cap;
131
int numcap;
132
int couleurcap;
133
CanFrame comm_ang;
134
CanFrame comm_vitesse;
129 135

  
130
void vit(){	
131
	CanFrame comm;
132
		while(1)
133
		{
134
			comm.data.id='V'; 
135
			comm.data.rtr=0;
136
		//	if(distance < 100)
137
	 		comm.data.val=15;
138
		//	else comm.data.val = 5;
139
			snd_dtq(CanTx,comm.msg);   
140
			dly_tsk(500);
141
		}	
142
				
143
}
144

  
145 136
void ang_tourelle(){	
146 137
	
147 138
		CanFrame req,reponse,comm;
......
149 140
		while(1)
150 141
		{	
151 142
			req.data.id='R';						//lecture angle de la tourelle
152
			req.data.rtr=1; 
153
		//	snd_dtq(CanRx, req.msg);
143
			req.data.rtr=1;
144
			snd_dtq(CanRx, req.msg);
154 145
													//Attente de la reponse
155
													//rcv_dtq(CanRx, &reponse.msg);
156 146
			periph[ADDR('R')].ev=0x01;
157 147
			snd_dtq(CanTx,req.msg);
158 148
			wai_flg(ev_periph, 0x01, TWF_ANDW,&flag);
......
161 151
													
162 152
			comm.data.id='T';						//Vitesse de la tourelle
163 153
			comm.data.rtr=0;
164
	 		comm.data.val=g2*(450-alpha);
154
			comm.data.val=vitourelle;
165 155
			snd_dtq(CanTx,comm.msg);
166
			dly_tsk(100);
156
	 		if (alpha!=450) vitourelle=450-alpha;
157
			
158
			dly_tsk(20);
167 159
		}	
168 160
		
169 161
}
170 162

  
171 163
void ang_roue(){	
172 164
	
173
		CanFrame req,reponse,comm;
174
		UINT flag;	
165
		CanFrame req,reponse;		
166
		UINT flag;			
175 167
		while(1)
176 168
		{	
177 169
			req.data.id='U';						 //distance mesueree par la tourelle
178 170
			req.data.rtr=1; 
179
		//	snd_dtq(CanRx, req.msg);
171
			snd_dtq(CanRx, req.msg);
180 172
													//Attente de la reponse
181
													//rcv_dtq(CanRx, &reponse.msg);
182 173
			periph[ADDR('U')].ev=0x02;
183 174
			snd_dtq(CanTx,req.msg);
184 175
			wai_flg(ev_periph, 0x02, TWF_ANDW,&flag);
185 176

  
186 177
			distance=periph[ADDR('U')].val;			// contient la valeur de retour du simulateur.
187 178
													
188
			comm.data.id='D';						//angle de roue
189
			comm.data.rtr=0;
190
	 		comm.data.val=-g*(450-distance); 
191
			snd_dtq(CanTx,comm.msg);
192
			dly_tsk(200);
179
			comm_ang.data.id='D';						//angle de roue
180
			comm_ang.data.rtr=0;
181
	 		if(distance < 900) comm_ang.data.val=-(710-distance);
182
			else comm_ang.data.val=0;
183
			snd_dtq(CanTx,comm_ang.msg);
184
			dly_tsk(20);
193 185
		}	
194 186
			
195 187
}
196 188

  
189
void vit(){	
190
	
191
	CanFrame req,reponse;	
192
	UINT flag;	
193
		while(1)
194
		{	req.data.id='V';						
195
			req.data.rtr=1; 
196
			snd_dtq(CanRx, req.msg);
197
													//Attente de la reponse
198
			periph[ADDR('V')].ev=0x03;
199
			snd_dtq(CanTx,req.msg);
200
			wai_flg(ev_periph, 0x03, TWF_ANDW,&flag);
201

  
202
			vitesse=periph[ADDR('V')].val;			// contient la valeur de retour du simulateur.
203

  
204
			comm_vitesse.data.id='V'; 						//vitesse de roue
205
			comm_vitesse.data.rtr=0;
206
	 		if(distance < 850) comm_vitesse.data.val=35;
207
			else comm_vitesse.data.val=vitesse;
208
			snd_dtq(CanTx,comm_vitesse.msg);
209
			dly_tsk(10);
210
		}	
211
				
212
}
213

  
214

  
215
void mod(){	
216
	
217
		CanFrame req,reponse,comm;
218
		UINT flag;	
219
		while(1)
220
		{	
221
			req.data.id='M';						//mode de course
222
			req.data.rtr=1; 
223
			snd_dtq(CanRx, req.msg);
224
													//Attente de la reponse
225
			periph[ADDR('M')].ev=0x05;
226
			snd_dtq(CanTx,req.msg);
227
			wai_flg(ev_periph, 0x05, TWF_ANDW,&flag);
228
		
229
			m=periph[ADDR('M')].val;				// contient la valeur de retour du simulateur.
230
			num_piste=m & 0x007D;
231
			snd_dtq(CanTx,comm.msg);
232
		}	
233

  
234
}	
235

  
236
void capteur(){	
237
	
238
		CanFrame req,reponse,comm;
239
		UINT flag;	
240
		while(1)
241
		{	
242
			req.data.id='C';						//le dernier capteur touche
243
			req.data.rtr=1; 
244
			snd_dtq(CanRx, req.msg);
245
													//Attente de la reponse
246
			periph[ADDR('C')].ev=0x04;
247
			snd_dtq(CanTx,req.msg);
248
			wai_flg(ev_periph, 0x04, TWF_ANDW,&flag);
249
		
250
			cap=periph[ADDR('C')].val;				// contient la valeur de retour du simulateur.
251
			couleurcap=cap & 0xff00;				//couleur 
252
			numcap=cap & 0x00ff;					//numero du capteur
253
			if(cap==0x5601 & num_piste=3) {
254
				vitesse=50;
255
				snd_dtq(CanTx,comm_vitesse.msg);
256
			}
257
		}	
258

  
259
}			
260

  
261

  
197 262
void main()
198 263
{
199 264
	CanFrame comm;
......
201 266
	ports_mcu();
202 267
	lcd_init();
203 268
	periph_init();
204
	periph_nom("#AutoTest*");
269
	periph_nom("#nan*");
205 270

  
206 271

  
207 272
	lcd_putc(1);
......
211 276
			
212 277
	sta_tsk(ID_ang_roue);
213 278
	sta_tsk(ID_ang_tourelle);
214
	sta_tsk(ID_vitesse);
279
	sta_tsk(ID_vitesse);
280
	sta_tsk(ID_capteur);
281
	sta_tsk(ID_mode);
215 282
	sta_cyc(ID_acqui);
216 283
	sta_tsk(ID_periph_rx);
217 284
	

Also available in: Unified diff