Rev 1166 | Rev 1168 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed
Rev 1166 | Rev 1167 | ||
---|---|---|---|
Line 76... | Line 76... | ||
76 | while(messanzahl_Druck == 0); |
76 | while(messanzahl_Druck == 0); |
77 | if(i<10) Delay_ms_Mess(10); |
77 | if(i<10) Delay_ms_Mess(10); |
78 | } |
78 | } |
79 | Delay_ms_Mess(70); |
79 | Delay_ms_Mess(70); |
80 | } |
80 | } |
81 | /* |
- | |
82 | 0 n |
- | |
83 | 1 r |
- | |
84 | 2 g |
- | |
85 | 3 y |
- | |
86 | 4 n |
- | |
87 | 5 r |
- | |
88 | 6 z |
- | |
89 | 7 l |
- | |
90 | 8 n |
- | |
91 | 9 r |
- | |
92 | 10 x |
- | |
93 | 11 g |
- | |
94 | 12 n |
- | |
95 | 13 r |
- | |
96 | 14 u |
- | |
97 | 15 y |
- | |
98 | 16 n |
- | |
99 | 17 r |
- | |
100 | 18 x |
- | |
101 | 19 n |
- | |
102 | 20 r |
- | |
103 | 21 g |
- | |
104 | 22 y |
- | |
105 | 4 n |
- | |
106 | 5 r |
- | |
107 | 6 z |
- | |
108 | 7 l |
- | |
109 | 8 n |
- | |
110 | 9 r |
- | |
111 | 10 x |
- | |
112 | 11 g |
- | |
113 | 12 n |
- | |
114 | 13 r |
- | |
115 | 14 u |
- | |
116 | 15 y |
- | |
117 | 16 n |
- | |
118 | 17 r |
- | |
119 | 18 x |
- | |
120 | */ |
- | |
121 | #define FILTER 3 |
- | |
Line 122... | Line 81... | ||
122 | 81 | ||
123 | //####################################################################################### |
82 | //####################################################################################### |
124 | // |
83 | // |
125 | SIGNAL(SIG_ADC) |
84 | SIGNAL(SIG_ADC) |
126 | //####################################################################################### |
85 | //####################################################################################### |
127 | { |
86 | { |
128 | static unsigned char kanal=0,state = 0; |
87 | static unsigned char kanal=0,state = 0; |
129 | static signed int gier1, roll1, nick1; |
88 | static signed int gier1, roll1, nick1; |
130 | static signed long nick_filter, roll_filter; |
89 | static signed long nick_filter, roll_filter; |
131 | static signed int accy, accx; |
- | |
132 | // ANALOG_OFF; |
90 | static signed int accy, accx; |
133 | switch(state++) |
91 | switch(state++) |
134 | { |
92 | { |
135 | case 0: |
- | |
136 | J4High; |
93 | case 0: |
137 | nick1 = ADC; |
94 | nick1 = ADC; |
138 | kanal = AD_ROLL; |
95 | kanal = AD_ROLL; |
139 | break; |
96 | break; |
140 | case 1: |
97 | case 1: |
Line 144... | Line 101... | ||
144 | case 2: |
101 | case 2: |
145 | gier1 = ADC; |
102 | gier1 = ADC; |
146 | kanal = AD_ACC_Y; |
103 | kanal = AD_ACC_Y; |
147 | break; |
104 | break; |
148 | case 3: |
105 | case 3: |
149 | J5High; |
- | |
150 | Aktuell_ay = NeutralAccY - ADC; |
106 | Aktuell_ay = NeutralAccY - ADC; |
151 | accy = Aktuell_ay; |
107 | accy = Aktuell_ay; |
152 | kanal = AD_NICK; |
108 | kanal = AD_NICK; |
153 | break; |
109 | break; |
154 | case 4: |
110 | case 4: |
155 | J4High; |
- | |
156 | nick1 += ADC; |
111 | nick1 += ADC; |
157 | kanal = AD_ROLL; |
112 | kanal = AD_ROLL; |
158 | break; |
113 | break; |
159 | case 5: |
114 | case 5: |
160 | roll1 += ADC; |
115 | roll1 += ADC; |
Line 183... | Line 138... | ||
183 | Mess_Integral_Hoch += AdWertAccHoch; // Integrieren |
138 | Mess_Integral_Hoch += AdWertAccHoch; // Integrieren |
184 | Mess_Integral_Hoch -= Mess_Integral_Hoch / 1024; // dämfen |
139 | Mess_Integral_Hoch -= Mess_Integral_Hoch / 1024; // dämfen |
185 | kanal = AD_NICK; |
140 | kanal = AD_NICK; |
186 | break; |
141 | break; |
187 | case 7: |
142 | case 7: |
188 | J4High; |
- | |
189 | nick1 += ADC; |
143 | nick1 += ADC; |
190 | kanal = AD_ROLL; |
144 | kanal = AD_ROLL; |
191 | break; |
145 | break; |
192 | case 8: |
146 | case 8: |
193 | roll1 += ADC; |
147 | roll1 += ADC; |
Line 201... | Line 155... | ||
201 | case 10: |
155 | case 10: |
202 | gier1 += ADC; |
156 | gier1 += ADC; |
203 | kanal = AD_NICK; |
157 | kanal = AD_NICK; |
204 | break; |
158 | break; |
205 | case 11: |
159 | case 11: |
206 | J4High; |
- | |
207 | nick1 += ADC; |
160 | nick1 += ADC; |
208 | kanal = AD_ROLL; |
161 | kanal = AD_ROLL; |
209 | break; |
162 | break; |
210 | case 12: |
163 | case 12: |
211 | roll1 += ADC; |
164 | roll1 += ADC; |
Line 214... | Line 167... | ||
214 | case 13: |
167 | case 13: |
215 | UBat = (3 * UBat + ADC / 3) / 4;//(UBat + ((ADC * 39) / 256) + 19) / 2; |
168 | UBat = (3 * UBat + ADC / 3) / 4;//(UBat + ((ADC * 39) / 256) + 19) / 2; |
216 | kanal = AD_ACC_Y; |
169 | kanal = AD_ACC_Y; |
217 | break; |
170 | break; |
218 | case 14: |
171 | case 14: |
219 | J5High; |
- | |
220 | Aktuell_ay = NeutralAccY - ADC; |
172 | Aktuell_ay = NeutralAccY - ADC; |
221 | accy += Aktuell_ay; |
173 | accy += Aktuell_ay; |
222 | kanal = AD_NICK; |
174 | kanal = AD_NICK; |
223 | break; |
175 | break; |
224 | case 15: |
176 | case 15: |
225 | J4High; |
- | |
226 | nick1 += ADC; |
177 | nick1 += ADC; |
227 | kanal = AD_ROLL; |
178 | kanal = AD_ROLL; |
228 | break; |
179 | break; |
229 | case 16: |
180 | case 16: |
230 | roll1 += ADC; |
181 | roll1 += ADC; |
Line 234... | Line 185... | ||
234 | Aktuell_ax = ADC - NeutralAccX; |
185 | Aktuell_ax = ADC - NeutralAccX; |
235 | accx += Aktuell_ax; |
186 | accx += Aktuell_ax; |
236 | kanal = AD_NICK; |
187 | kanal = AD_NICK; |
237 | break; |
188 | break; |
238 | case 18: |
189 | case 18: |
239 | J4High; |
- | |
240 | nick1 += ADC; |
190 | nick1 += ADC; |
241 | kanal = AD_ROLL; |
191 | kanal = AD_ROLL; |
242 | break; |
192 | break; |
243 | case 19: |
193 | case 19: |
244 | roll1 += ADC; |
194 | roll1 += ADC; |
Line 247... | Line 197... | ||
247 | case 20: |
197 | case 20: |
248 | gier1 += ADC; |
198 | gier1 += ADC; |
249 | kanal = AD_ACC_Y; |
199 | kanal = AD_ACC_Y; |
250 | break; |
200 | break; |
251 | case 21: |
201 | case 21: |
252 | J5High; |
- | |
253 | Aktuell_ay = NeutralAccY - ADC; |
202 | Aktuell_ay = NeutralAccY - ADC; |
254 | accy += Aktuell_ay; |
203 | accy += Aktuell_ay; |
255 | kanal = AD_NICK; |
204 | kanal = AD_NICK; |
256 | break; |
205 | break; |
257 | case 22: |
206 | case 22: |
258 | J4High; |
- | |
259 | nick1 += ADC; |
207 | nick1 += ADC; |
260 | kanal = AD_ROLL; |
208 | kanal = AD_ROLL; |
261 | break; |
209 | break; |
262 | case 23: |
210 | case 23: |
263 | roll1 += ADC; |
211 | roll1 += ADC; |
264 | kanal = AD_DRUCK; |
212 | kanal = AD_DRUCK; |
265 | break; |
213 | break; |
266 | case 24: |
214 | case 24: |
267 | tmpLuftdruck += ADC; |
215 | tmpLuftdruck += ADC; |
268 | - | ||
269 | if(++messanzahl_Druck >= 5) |
216 | if(++messanzahl_Druck >= 5) |
270 | { |
217 | { |
271 | MessLuftdruck = ADC; |
218 | MessLuftdruck = ADC; |
272 | messanzahl_Druck = 0; |
219 | messanzahl_Druck = 0; |
273 | HoeheD = (7 * HoeheD + (int) Parameter_Luftdruck_D * (int)(255 * ExpandBaro + StartLuftdruck - tmpLuftdruck - HoehenWert))/8; // D-Anteil = neuerWert - AlterWert |
220 | HoeheD = (7 * HoeheD + (int) Parameter_Luftdruck_D * (int)(255 * ExpandBaro + StartLuftdruck - tmpLuftdruck - HoehenWert)) / 8; // D-Anteil = neuerWert - AlterWert |
274 | Luftdruck = (tmpLuftdruck + 3 * Luftdruck) / 4; |
221 | Luftdruck = (tmpLuftdruck + 3 * Luftdruck) / 4; |
275 | HoehenWert = 255 * ExpandBaro + StartLuftdruck - Luftdruck; |
222 | HoehenWert = 255 * ExpandBaro + StartLuftdruck - Luftdruck; |
276 | tmpLuftdruck = 0; |
223 | tmpLuftdruck = 0; |
277 | } |
224 | } |
278 | kanal = AD_NICK; |
225 | kanal = AD_NICK; |
279 | break; |
226 | break; |
280 | case 25: |
227 | case 25: |
281 | J4High; |
- | |
282 | nick1 += ADC; |
228 | nick1 += ADC; |
283 | kanal = AD_ROLL; |
229 | kanal = AD_ROLL; |
284 | break; |
230 | break; |
285 | case 26: |
231 | case 26: |
286 | roll1 += ADC; |
232 | roll1 += ADC; |
Line 297... | Line 243... | ||
297 | if(PlatinenVersion == 20) AdWertGier = 2047 - (ADC + gier1 + 1) / 2; |
243 | if(PlatinenVersion == 20) AdWertGier = 2047 - (ADC + gier1 + 1) / 2; |
298 | else AdWertGier = (ADC + gier1 + 1) / 2; |
244 | else AdWertGier = (ADC + gier1 + 1) / 2; |
299 | kanal = AD_NICK; |
245 | kanal = AD_NICK; |
300 | break; |
246 | break; |
301 | case 29: |
247 | case 29: |
302 | J4High; |
- | |
303 | nick1 += ADC; |
248 | nick1 += ADC; |
304 | kanal = AD_ROLL; |
249 | kanal = AD_ROLL; |
305 | break; |
250 | break; |
306 | case 30: |
251 | case 30: |
307 | roll1 += ADC; |
252 | roll1 += ADC; |
308 | kanal = AD_ACC_Y; |
253 | kanal = AD_ACC_Y; |
309 | break; |
254 | break; |
310 | case 31: |
255 | case 31: |
311 | J5High; |
- | |
312 | Aktuell_ay = NeutralAccY - ADC; |
256 | Aktuell_ay = NeutralAccY - ADC; |
313 | AdWertAccRoll = (Aktuell_ay + accy); |
257 | AdWertAccRoll = (Aktuell_ay + accy); |
314 | kanal = AD_NICK; |
258 | kanal = AD_NICK; |
315 | break; |
259 | break; |
316 | case 32: |
260 | case 32: |
317 | J4High; |
- | |
318 | AdWertNick = (ADC + nick1 + 3) / 5; |
261 | AdWertNick = (ADC + nick1 + 3) / 5; |
319 | nick_filter = (long) (1 * (long) nick_filter + 4 * (long)(ADC + nick1) + 1) / 2; |
262 | nick_filter = (long) (1 * (long) nick_filter + 4 * (long)(ADC + nick1) + 1) / 2; |
320 | if(PlatinenVersion == 10) { AdWertNick /= 2;nick_filter /=2;} |
263 | if(PlatinenVersion == 10) { AdWertNick /= 2;nick_filter /=2;} |
321 | HiResNick = nick_filter - 20 * AdNeutralNick; |
264 | HiResNick = nick_filter - 20 * AdNeutralNick; |
322 | AdWertNickFilter = (long)(3L * (long)AdWertNickFilter + HiResNick + 2) / 4; |
265 | AdWertNickFilter = (long)(3L * (long)AdWertNickFilter + HiResNick + 2) / 4; |
Line 345... | Line 288... | ||
345 | state = 0; |
288 | state = 0; |
346 | break; |
289 | break; |
347 | } |
290 | } |
348 | ADMUX = kanal; |
291 | ADMUX = kanal; |
349 | if(state != 0) ANALOG_ON; |
292 | if(state != 0) ANALOG_ON; |
350 | J4Low; |
- | |
351 | J5Low; |
- | |
352 | } |
293 | } |
Line 353... | Line -... | ||
353 | - | ||
354 | /* |
- | |
355 | //####################################################################################### |
- | |
356 | // |
- | |
357 | SIGNAL(SIG_ADC) |
- | |
358 | //####################################################################################### |
- | |
359 | { |
- | |
360 | static unsigned char kanal=0,state = 0; |
- | |
361 | static signed int gier1, roll1, nick1, nick_filter, roll_filter; |
- | |
362 | static signed int accy, accx; |
- | |
363 | // ANALOG_OFF; |
- | |
364 | switch(state++) |
- | |
365 | { |
- | |
366 | case 0: |
- | |
367 | J4High; |
- | |
368 | nick1 = ADC; |
- | |
369 | kanal = AD_ROLL; |
- | |
370 | break; |
- | |
371 | case 1: |
- | |
372 | roll1 = ADC; |
- | |
373 | kanal = AD_GIER; |
- | |
374 | break; |
- | |
375 | case 2: |
- | |
376 | gier1 = ADC; |
- | |
377 | kanal = AD_ACC_Y; |
- | |
378 | break; |
- | |
379 | case 3: |
- | |
380 | Aktuell_ay = NeutralAccY - ADC; |
- | |
381 | accy = Aktuell_ay; |
- | |
382 | kanal = AD_NICK; |
- | |
383 | break; |
- | |
384 | case 4: |
- | |
385 | J4High; |
- | |
386 | nick1 += ADC; |
- | |
387 | kanal = AD_ROLL; |
- | |
388 | break; |
- | |
389 | case 5: |
- | |
390 | roll1 += ADC; |
- | |
391 | kanal = AD_ACC_Z; |
- | |
392 | break; |
- | |
393 | case 6: |
- | |
394 | AdWertAccHoch = (signed int) ADC - NeutralAccZ; |
- | |
395 | if(AdWertAccHoch > 1) |
- | |
396 | { |
- | |
397 | if(NeutralAccZ < 750) |
- | |
398 | { |
- | |
399 | NeutralAccZ += 0.02; |
- | |
400 | if(modell_fliegt < 500) NeutralAccZ += 0.1; |
- | |
401 | } |
- | |
402 | } |
- | |
403 | else if(AdWertAccHoch < -1) |
- | |
404 | { |
- | |
405 | if(NeutralAccZ > 550) |
- | |
406 | { |
- | |
407 | NeutralAccZ-= 0.02; |
- | |
408 | if(modell_fliegt < 500) NeutralAccZ -= 0.1; |
- | |
409 | } |
- | |
410 | } |
- | |
411 | messanzahl_AccHoch = 1; |
- | |
412 | Aktuell_az = ADC; |
- | |
413 | Mess_Integral_Hoch += AdWertAccHoch; // Integrieren |
- | |
414 | Mess_Integral_Hoch -= Mess_Integral_Hoch / 1024; // dämfen |
- | |
415 | kanal = AD_DRUCK; |
- | |
416 | break; |
- | |
417 | case 7: |
- | |
418 | tmpLuftdruck += ADC; |
- | |
419 | - | ||
420 | if(++messanzahl_Druck >= 5) |
- | |
421 | { |
- | |
422 | MessLuftdruck = ADC; |
- | |
423 | messanzahl_Druck = 0; |
- | |
424 | HoeheD = (7 * HoeheD + (int) Parameter_Luftdruck_D * (int)(255 * ExpandBaro + StartLuftdruck - tmpLuftdruck - HoehenWert))/8; // D-Anteil = neuerWert - AlterWert |
- | |
425 | Luftdruck = (tmpLuftdruck + 3 * Luftdruck) / 4; |
- | |
426 | HoehenWert = 255 * ExpandBaro + StartLuftdruck - Luftdruck; |
- | |
427 | tmpLuftdruck = 0; |
- | |
428 | } |
- | |
429 | kanal = AD_NICK; |
- | |
430 | break; |
- | |
431 | case 8: |
- | |
432 | J4High; |
- | |
433 | nick1 += ADC; |
- | |
434 | kanal = AD_ROLL; |
- | |
435 | break; |
- | |
436 | case 9: |
- | |
437 | roll1 += ADC; |
- | |
438 | kanal = AD_ACC_X; |
- | |
439 | break; |
- | |
440 | case 10: |
- | |
441 | Aktuell_ax = ADC - NeutralAccX; |
- | |
442 | accx = Aktuell_ax; |
- | |
443 | kanal = AD_GIER; |
- | |
444 | break; |
- | |
445 | case 11: |
- | |
446 | if(PlatinenVersion == 10) AdWertGier = (ADC + gier1) / 2; |
- | |
447 | else |
- | |
448 | if(PlatinenVersion == 20) AdWertGier = 2047 - (ADC + gier1); |
- | |
449 | else AdWertGier = (ADC + gier1); |
- | |
450 | kanal = AD_NICK; |
- | |
451 | break; |
- | |
452 | case 12: |
- | |
453 | J4High; |
- | |
454 | nick1 += ADC; |
- | |
455 | kanal = AD_ROLL; |
- | |
456 | break; |
- | |
457 | case 13: |
- | |
458 | roll1 += ADC; |
- | |
459 | kanal = AD_UBAT; |
- | |
460 | break; |
- | |
461 | case 14: |
- | |
462 | UBat = (3 * UBat + ADC / 3) / 4;//(UBat + ((ADC * 39) / 256) + 19) / 2; |
- | |
463 | kanal = AD_ACC_Y; |
- | |
464 | break; |
- | |
465 | case 15: |
- | |
466 | Aktuell_ay = NeutralAccY - ADC; |
- | |
467 | AdWertAccRoll = (Aktuell_ay + accy); |
- | |
468 | kanal = AD_NICK; |
- | |
469 | break; |
- | |
470 | case 16: |
- | |
471 | J4High; |
- | |
472 | // if(PlatinenVersion == 10) AdWertNick = (ADC + nick1) / 5; |
- | |
473 | // else AdWertNick = (5 * AdWertNick + 2*(ADC + nick1)) / 10; |
- | |
474 | AdWertNick = 2*(ADC + nick1) / 5; |
- | |
475 | nick_filter = (2 * nick_filter + 2 * (ADC + nick1)) / 3; |
- | |
476 | HiResNick = nick_filter - 5 * AdNeutralNick; |
- | |
477 | AdWertNickFilter = (long)(3L * (long)AdWertNickFilter + 4 * HiResNick) / 4; |
- | |
478 | DebugOut.Analog[21] = AdWertNickFilter / 4; |
- | |
479 | kanal = AD_ROLL; |
- | |
480 | break; |
- | |
481 | case 17: |
- | |
482 | // if(PlatinenVersion == 10) AdWertRoll = (ADC + roll1) / 5; |
- | |
483 | // else AdWertRoll = (5 * AdWertRoll + 2*(ADC + roll1)) / 10; |
- | |
484 | AdWertRoll = 2*(ADC + roll1) / 5; |
- | |
485 | roll_filter = (2 * roll_filter + 2 * (ADC + roll1)) / 3; |
- | |
486 | HiResRoll = roll_filter - 5 * AdNeutralRoll; |
- | |
487 | AdWertRollFilter = (long)(3 * (long)AdWertRollFilter + 4 * HiResRoll) / 4; |
- | |
488 | DebugOut.Analog[22] = AdWertRollFilter / 4; |
- | |
489 | kanal = AD_ACC_X; |
- | |
490 | break; |
- | |
491 | case 18: |
- | |
492 | Aktuell_ax = ADC - NeutralAccX; |
- | |
493 | AdWertAccNick = (Aktuell_ax + accx); |
- | |
494 | kanal = AD_NICK; |
- | |
495 | state = 0; |
- | |
496 | AdReady = 1; |
- | |
497 | ZaehlMessungen++; |
- | |
498 | J5High; |
- | |
499 | break; |
- | |
500 | default: |
- | |
501 | kanal = 0; |
- | |
502 | state = 0; |
- | |
503 | break; |
- | |
504 | } |
- | |
505 | ADMUX = kanal; |
- | |
506 | if(state != 0) ANALOG_ON; |
- | |
507 | J4Low; |
- | |
508 | J5Low; |
- | |
509 | } |
- | |
510 | */ |
- | |
511 | - | ||
512 | /* |
- | |
513 | //####################################################################################### |
- | |
514 | // |
- | |
515 | SIGNAL(SIG_ADC) |
- | |
516 | //####################################################################################### |
- | |
517 | { |
- | |
518 | static unsigned char kanal=0,state = 0; |
- | |
519 | static unsigned int gier1, roll1, nick1, accy, accx; |
- | |
520 | ANALOG_OFF; |
- | |
521 | switch(state++) |
- | |
522 | { |
- | |
523 | case 0: |
- | |
524 | gier1 = ADC; |
- | |
525 | kanal = AD_ROLL; |
- | |
526 | ZaehlMessungen++; |
- | |
527 | break; |
- | |
528 | case 1: |
- | |
529 | roll1 = ADC; |
- | |
530 | kanal = AD_NICK; |
- | |
531 | break; |
- | |
532 | case 2: |
- | |
533 | nick1 = ADC; |
- | |
534 | kanal = AD_ACC_Y; |
- | |
535 | break; |
- | |
536 | case 3: |
- | |
537 | Aktuell_ay = NeutralAccY - ADC; |
- | |
538 | accy = Aktuell_ay; |
- | |
539 | kanal = AD_ACC_X; |
- | |
540 | break; |
- | |
541 | case 4: |
- | |
542 | Aktuell_ax = ADC - NeutralAccX; |
- | |
543 | accx = Aktuell_ax; |
- | |
544 | kanal = AD_GIER; |
- | |
545 | break; |
- | |
546 | case 5: |
- | |
547 | gier1 += ADC; |
- | |
548 | kanal = AD_ROLL; |
- | |
549 | break; |
- | |
550 | case 6: |
- | |
551 | roll1 += ADC; |
- | |
552 | kanal = AD_NICK; |
- | |
553 | break; |
- | |
554 | case 7: |
- | |
555 | nick1 += ADC; |
- | |
556 | kanal = AD_UBAT; |
- | |
557 | break; |
- | |
558 | case 8: |
- | |
559 | UBat = (3 * UBat + ADC / 3) / 4;//(UBat + ((ADC * 39) / 256) + 19) / 2; |
- | |
560 | kanal = AD_ACC_Z; |
- | |
561 | break; |
- | |
562 | case 9: |
- | |
563 | AdWertAccHoch = (signed int) ADC - NeutralAccZ; |
- | |
564 | if(AdWertAccHoch > 1) |
- | |
565 | { |
- | |
566 | if(NeutralAccZ < 750) |
- | |
567 | { |
- | |
568 | NeutralAccZ += 0.02; |
- | |
569 | if(modell_fliegt < 500) NeutralAccZ += 0.1; |
- | |
570 | } |
- | |
571 | } |
- | |
572 | else if(AdWertAccHoch < -1) |
- | |
573 | { |
- | |
574 | if(NeutralAccZ > 550) |
- | |
575 | { |
- | |
576 | NeutralAccZ-= 0.02; |
- | |
577 | if(modell_fliegt < 500) NeutralAccZ -= 0.1; |
- | |
578 | } |
- | |
579 | } |
- | |
580 | messanzahl_AccHoch = 1; |
- | |
581 | Aktuell_az = ADC; |
- | |
582 | Mess_Integral_Hoch += AdWertAccHoch; // Integrieren |
- | |
583 | Mess_Integral_Hoch -= Mess_Integral_Hoch / 1024; // dämfen |
- | |
584 | kanal = AD_GIER; |
- | |
585 | break; |
- | |
586 | case 10: |
- | |
587 | gier1 += ADC; |
- | |
588 | kanal = AD_ROLL; |
- | |
589 | break; |
- | |
590 | case 11: |
- | |
591 | roll1 += ADC; |
- | |
592 | kanal = AD_NICK; |
- | |
593 | break; |
- | |
594 | case 12: |
- | |
595 | nick1 += ADC; |
- | |
596 | kanal = AD_DRUCK; |
- | |
597 | break; |
- | |
598 | case 13: |
- | |
599 | tmpLuftdruck += ADC; |
- | |
600 | if(++messanzahl_Druck >= 5) |
- | |
601 | { |
- | |
602 | MessLuftdruck = ADC; |
- | |
603 | messanzahl_Druck = 0; |
- | |
604 | HoeheD = (7 * HoeheD + (int) Parameter_Luftdruck_D * (int)(255 * ExpandBaro + StartLuftdruck - tmpLuftdruck - HoehenWert))/8; // D-Anteil = neuerWert - AlterWert |
- | |
605 | Luftdruck = (tmpLuftdruck + 3 * Luftdruck) / 4; |
- | |
606 | HoehenWert = 255 * ExpandBaro + StartLuftdruck - Luftdruck; |
- | |
607 | tmpLuftdruck = 0; |
- | |
608 | } |
- | |
609 | kanal = AD_ACC_Y; |
- | |
610 | break; |
- | |
611 | case 14: |
- | |
612 | Aktuell_ay = NeutralAccY - ADC; |
- | |
613 | AdWertAccRoll = (Aktuell_ay + accy); |
- | |
614 | kanal = AD_ACC_X; |
- | |
615 | break; |
- | |
616 | case 15: |
- | |
617 | Aktuell_ax = ADC - NeutralAccX; |
- | |
618 | AdWertAccNick = (Aktuell_ax + accx); |
- | |
619 | kanal = AD_GIER; |
- | |
620 | break; |
- | |
621 | case 16: |
- | |
622 | if(PlatinenVersion == 10) AdWertGier = (ADC + gier1) / 4; |
- | |
623 | else |
- | |
624 | if(PlatinenVersion == 20) AdWertGier = 2047 - (ADC + gier1)/2; |
- | |
625 | else AdWertGier = (ADC + gier1) / 2; |
- | |
626 | kanal = AD_ROLL; |
- | |
627 | break; |
- | |
628 | case 17: |
- | |
629 | if(PlatinenVersion == 10) AdWertRoll = (ADC + roll1) / 4; |
- | |
630 | else AdWertRoll = (ADC + roll1) / 2; |
- | |
631 | kanal = AD_NICK; |
- | |
632 | break; |
- | |
633 | case 18: |
- | |
634 | if(PlatinenVersion == 10) AdWertNick = (ADC + nick1) / 4; |
- | |
635 | else AdWertNick = (ADC + nick1) / 2; |
- | |
636 | kanal = AD_GIER; |
- | |
637 | state = 0; |
- | |
638 | AdReady = 1; |
- | |
639 | break; |
- | |
640 | default: |
- | |
641 | kanal = 0; |
- | |
642 | state = 0; |
- | |
643 | break; |
- | |
644 | } |
- | |
645 | ADMUX = kanal; |
- | |
646 | if(state != 0) ANALOG_ON; |
- | |
647 | } |
- | |
648 | */ |
- | |
649 | - | ||
650 | - | ||
651 | - | ||
652 | - | ||
653 | - | ||
654 | - | ||
655 | - | ||
656 | - | ||
657 | - | ||
658 | - |