Subversion Repositories FlightCtrl

Rev

Rev 1695 | Rev 1702 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 1695 Rev 1701
Line 153... Line 153...
153 
        case 7:
 153 
        case 7:
154 
            UBat = (3 * UBat + ADC / 3) / 4;
 154 
            UBat = (3 * UBat + ADC / 3) / 4;
155 
                    kanal = AD_ACC_Z;
 155 
                    kanal = AD_ACC_Z;
156 
            break;
 156 
            break;
157 
       case 8:
 157 
       case 8:
158 
 
 - 
 
159 
            AdWertAccHoch =  (signed int) ADC - NeutralAccZ;
 158 
            AdWertAccHoch =  (signed int) ADC - NeutralAccZ;
160 
            if(AdWertAccHoch > 1)
 159 
            if(AdWertAccHoch > 1)
161 
             {
 160 
             {
162 
              if(NeutralAccZ < 750)
 161 
              if(NeutralAccZ < 750)
163 
               {
 162 
               {
164 
                subcount += 5;
 163 
                subcount += 5;
165 
//                if(modell_fliegt < 500) subcount += 10;
 164 
                if(modell_fliegt < 500) subcount += 10;
166 
               }
 165 
               }
167 
              if(subcount > 100) { NeutralAccZ++; subcount -= 100;}
 166 
              if(subcount > 100) { NeutralAccZ++; subcount -= 100;}
168 
             }
 167 
             }
169 
             else if(AdWertAccHoch < -1)
 168 
             else if(AdWertAccHoch < -1)
170 
             {
 169 
             {
171 
              if(NeutralAccZ > 550)
 170 
              if(NeutralAccZ > 550)
172 
                {
 171 
                {
173 
                 subcount -= 5;
 172 
                 subcount -= 5;
174 
//                 if(modell_fliegt < 500) subcount -= 10;
 173 
                 if(modell_fliegt < 500) subcount -= 10;
175 
                 if(subcount < -100) { NeutralAccZ--; subcount += 100;}
 174 
                 if(subcount < -100) { NeutralAccZ--; subcount += 100;}
176 
                }
 175 
                }
177 
             }
 176 
             }
178 
/*
 - 
 
179 
            AdWertAccHoch =  (signed int) ADC - NeutralAccZ_float;
 - 
 
180 
            if(AdWertAccHoch > 1)
 - 
 
181 
             {
 - 
 
182 
              if(NeutralAccZ_float < 750)
 - 
 
183 
               {
 - 
 
184 
                NeutralAccZ_float += 0.02;
 - 
 
185 
                if(modell_fliegt < 500) NeutralAccZ_float += 0.1;
 - 
 
186 
               }
 - 
 
187 
             }
 - 
 
188 
             else if(AdWertAccHoch < -1)
 - 
 
189 
             {
 - 
 
190 
              if(NeutralAccZ_float > 550)
 - 
 
191 
                {
 - 
 
192 
                 NeutralAccZ_float-= 0.02;
 - 
 
193 
                 if(modell_fliegt < 500) NeutralAccZ_float -= 0.1;
 - 
 
194 
                }
 - 
 
195 
             }
 - 
 
196 
*/
 - 
 
197 
            messanzahl_AccHoch = 1;
 177 
            messanzahl_AccHoch = 1;
198 
            Aktuell_az = ADC;
 178 
            Aktuell_az = ADC;
199 
            Mess_Integral_Hoch += AdWertAccHoch;      // Integrieren
 179 
            Mess_Integral_Hoch += AdWertAccHoch;      // Integrieren
200 
            Mess_Integral_Hoch -= Mess_Integral_Hoch / 1024; // dämfen
 180 
            Mess_Integral_Hoch -= Mess_Integral_Hoch / 1024; // dämfen
201 
                kanal = AD_DRUCK;
 181 
                kanal = AD_DRUCK;
202 
            break;
 182 
            break;
203 
   // "case 8:" fehlt hier absichtlich
 183 
   // "case 9:" fehlt hier absichtlich
204 
        case 10:
 184 
        case 10:
205 
            nick1 += ADC;
 185 
            nick1 += ADC;
206 
            kanal = AD_ROLL;
 186 
            kanal = AD_ROLL;
207 
            break;
 187 
            break;
208 
        case 11:
 188 
        case 11:
Line 268... Line 248...
268 
            kanal = 0; state = 0; kanal = AD_NICK;
 248 
            kanal = 0; state = 0; kanal = AD_NICK;
269 
            break;
 249 
            break;
270 
        }
 250 
        }
271 
    ADMUX = kanal;
 251 
    ADMUX = kanal;
272 
    if(state != 0) ANALOG_ON;
 252 
    if(state != 0) ANALOG_ON;
273 
 
 - 
 
274 
}
 253 
}
Line 275... Line -...
275 
 
 - 
 
276 
 
 - 
 
277 
 
 - 
 
278 
/*
 - 
 
279 
//#######################################################################################
 - 
 
280 
//
 - 
 
281 
SIGNAL(SIG_ADC)
 - 
 
282 
//#######################################################################################
 - 
 
283 
{
 - 
 
284 
    static unsigned char kanal=0,state = 0;
 - 
 
285 
    static signed int gier1, roll1, nick1;
 - 
 
286 
        static signed long nick_filter, roll_filter;
 - 
 
287 
        static signed int accy, accx;
 - 
 
288 
    switch(state++)
 - 
 
289 
        {
 - 
 
290 
        case 0:
 - 
 
291 
            nick1 = ADC;
 - 
 
292 
            kanal = AD_ROLL;
 - 
 
293 
            break;
 - 
 
294 
        case 1:
 - 
 
295 
            roll1 = ADC;
 - 
 
296 
                    kanal = AD_GIER;
 - 
 
297 
            break;
 - 
 
298 
        case 2:
 - 
 
299 
            gier1 = ADC;
 - 
 
300 
            kanal = AD_ACC_Y;
 - 
 
301 
            break;
 - 
 
302 
        case 3:
 - 
 
303 
            Aktuell_ay = NeutralAccY - ADC;
 - 
 
304 
            accy = Aktuell_ay;
 - 
 
305 
            kanal = AD_NICK;
 - 
 
306 
            break;
 - 
 
307 
        case 4:
 - 
 
308 
            nick1 += ADC;
 - 
 
309 
            kanal = AD_ROLL;
 - 
 
310 
            break;
 - 
 
311 
        case 5:
 - 
 
312 
            roll1 += ADC;
 - 
 
313 
                    kanal = AD_ACC_Z;
 - 
 
314 
            break;
 - 
 
315 
       case 6:
 - 
 
316 
            AdWertAccHoch =  (signed int) ADC - NeutralAccZ;
 - 
 
317 
            if(AdWertAccHoch > 1)
 - 
 
318 
             {
 - 
 
319 
              if(NeutralAccZ < 750)
 - 
 
320 
               {
 - 
 
321 
                NeutralAccZ += 0.02;
 - 
 
322 
                if(modell_fliegt < 500) NeutralAccZ += 0.1;
 - 
 
323 
               }
 - 
 
324 
             }
 - 
 
325 
             else if(AdWertAccHoch < -1)
 - 
 
326 
             {
 - 
 
327 
              if(NeutralAccZ > 550)
 - 
 
328 
                {
 - 
 
329 
                 NeutralAccZ-= 0.02;
 - 
 
330 
                 if(modell_fliegt < 500) NeutralAccZ -= 0.1;
 - 
 
331 
                }
 - 
 
332 
             }
 - 
 
333 
            messanzahl_AccHoch = 1;
 - 
 
334 
            Aktuell_az = ADC;
 - 
 
335 
            Mess_Integral_Hoch += AdWertAccHoch;      // Integrieren
 - 
 
336 
            Mess_Integral_Hoch -= Mess_Integral_Hoch / 1024; // dämfen
 - 
 
337 
            kanal = AD_NICK;
 - 
 
338 
            break;
 - 
 
339 
        case 7:
 - 
 
340 
            nick1 += ADC;
 - 
 
341 
            kanal = AD_ROLL;
 - 
 
342 
            break;
 - 
 
343 
        case 8:
 - 
 
344 
            roll1 += ADC;
 - 
 
345 
                    kanal = AD_ACC_X;
 - 
 
346 
            break;
 - 
 
347 
        case 9:
 - 
 
348 
            Aktuell_ax = ADC - NeutralAccX;
 - 
 
349 
            accx =  Aktuell_ax;
 - 
 
350 
                    kanal = AD_GIER;
 - 
 
351 
            break;
 - 
 
352 
        case 10:
 - 
 
353 
            gier1 += ADC;
 - 
 
354 
            kanal = AD_NICK;
 - 
 
355 
            break;
 - 
 
356 
        case 11:
 - 
 
357 
            nick1 += ADC;
 - 
 
358 
            kanal = AD_ROLL;
 - 
 
359 
            break;
 - 
 
360 
        case 12:
 - 
 
361 
            roll1 += ADC;
 - 
 
362 
            kanal = AD_UBAT;
 - 
 
363 
            break;
 - 
 
364 
        case 13:
 - 
 
365 
            UBat = (3 * UBat + ADC / 3) / 4;//(UBat + ((ADC * 39) / 256) + 19)  / 2;
 - 
 
366 
            kanal = AD_ACC_Y;
 - 
 
367 
            break;
 - 
 
368 
        case 14:
 - 
 
369 
            Aktuell_ay = NeutralAccY - ADC;
 - 
 
370 
            accy += Aktuell_ay;
 - 
 
371 
            kanal = AD_NICK;
 - 
 
372 
            break;
 - 
 
373 
        case 15:
 - 
 
374 
            nick1 += ADC;
 - 
 
375 
            kanal = AD_ROLL;
 - 
 
376 
            break;
 - 
 
377 
        case 16:
 - 
 
378 
            roll1 += ADC;
 - 
 
379 
            kanal = AD_ACC_X;
 - 
 
380 
            break;
 - 
 
381 
        case 17:
 - 
 
382 
            Aktuell_ax = ADC - NeutralAccX;
 - 
 
383 
            accx += Aktuell_ax;
 - 
 
384 
                    kanal = AD_NICK;
 - 
 
385 
            break;
 - 
 
386 
        case 18:
 - 
 
387 
            nick1 += ADC;
 - 
 
388 
            kanal = AD_ROLL;
 - 
 
389 
            break;
 - 
 
390 
        case 19:
 - 
 
391 
            roll1 += ADC;
 - 
 
392 
                    kanal = AD_GIER;
 - 
 
393 
            break;
 - 
 
394 
        case 20:
 - 
 
395 
            gier1 += ADC;
 - 
 
396 
            kanal = AD_ACC_Y;
 - 
 
397 
            break;
 - 
 
398 
        case 21:
 - 
 
399 
            Aktuell_ay = NeutralAccY - ADC;
 - 
 
400 
            accy += Aktuell_ay;
 - 
 
401 
            kanal = AD_NICK;
 - 
 
402 
            break;
 - 
 
403 
        case 22:
 - 
 
404 
            nick1 += ADC;
 - 
 
405 
            kanal = AD_ROLL;
 - 
 
406 
            break;
 - 
 
407 
        case 23:
 - 
 
408 
            roll1 += ADC;
 - 
 
409 
                kanal = AD_DRUCK;
 - 
 
410 
            break;
 - 
 
411 
        case 24:
 - 
 
412 
            tmpLuftdruck += ADC;
 - 
 
413 
            if(++messanzahl_Druck >= 5)
 - 
 
414 
                {
 - 
 
415 
                MessLuftdruck = ADC;
 - 
 
416 
                messanzahl_Druck = 0;
 - 
 
417 
                                HoeheD = (7 * HoeheD + (int) Parameter_Luftdruck_D * (int)(255 * ExpandBaro + StartLuftdruck - tmpLuftdruck - HoehenWert)) / 8;  // D-Anteil = neuerWert - AlterWert
 - 
 
418 
                Luftdruck = (tmpLuftdruck + 3 * Luftdruck) / 4;
 - 
 
419 
                HoehenWert = 255 * ExpandBaro + StartLuftdruck - Luftdruck;
 - 
 
420 
                tmpLuftdruck = 0;
 - 
 
421 
                }
 - 
 
422 
            kanal = AD_NICK;
 - 
 
423 
            break;
 - 
 
424 
        case 25:
 - 
 
425 
            nick1 += ADC;
 - 
 
426 
            kanal = AD_ROLL;
 - 
 
427 
            break;
 - 
 
428 
        case 26:
 - 
 
429 
            roll1 += ADC;
 - 
 
430 
                    kanal = AD_ACC_X;
 - 
 
431 
            break;
 - 
 
432 
        case 27:
 - 
 
433 
            Aktuell_ax = ADC - NeutralAccX;
 - 
 
434 
            accx +=  Aktuell_ax;
 - 
 
435 
                    kanal = AD_GIER;
 - 
 
436 
            break;
 - 
 
437 
        case 28:
 - 
 
438 
            if(PlatinenVersion == 10)  AdWertGier = (ADC + gier1 + 2) / 4;
 - 
 
439 
            else
 - 
 
440 
            if(PlatinenVersion >= 20)  AdWertGier = 2047 - (ADC + gier1 + 1) / 2;
 - 
 
441 
                        else                                       AdWertGier = (ADC + gier1 + 1) / 2;
 - 
 
442 
            kanal = AD_NICK;
 - 
 
443 
            break;
 - 
 
444 
        case 29:
 - 
 
445 
            nick1 += ADC;
 - 
 
446 
            kanal = AD_ROLL;
 - 
 
447 
            break;
 - 
 
448 
        case 30:
 - 
 
449 
            roll1 += ADC;
 - 
 
450 
            kanal = AD_ACC_Y;
 - 
 
451 
            break;
 - 
 
452 
        case 31:
 - 
 
453 
            Aktuell_ay = NeutralAccY - ADC;
 - 
 
454 
            AdWertAccRoll = (Aktuell_ay + accy);
 - 
 
455 
            kanal = AD_NICK;
 - 
 
456 
            break;
 - 
 
457 
        case 32:
 - 
 
458 
            AdWertNick = (ADC + nick1 + 3) / 5;
 - 
 
459 
            nick_filter = (long) (1 * (long) nick_filter + 4 * (long)(ADC + nick1) + 1) / 2;
 - 
 
460 
            if(PlatinenVersion == 10) { AdWertNick /= 2;nick_filter /=2;}
 - 
 
461 
            HiResNick = nick_filter - 20 * AdNeutralNick;
 - 
 
462 
            AdWertNickFilter = (long)(3L * (long)AdWertNickFilter + HiResNick + 2) / 4;
 - 
 
463 
            DebugOut.Analog[21] = AdWertNickFilter / 4;
 - 
 
464 
            kanal = AD_ROLL;
 - 
 
465 
            break;
 - 
 
466 
        case 33:
 - 
 
467 
            AdWertRoll = (ADC + roll1 + 3) / 5;
 - 
 
468 
            roll_filter = (long)(1 * (long)roll_filter + 4 * (long)(ADC + roll1) + 1) / 2;
 - 
 
469 
            if(PlatinenVersion == 10) { AdWertRoll /= 2;roll_filter /=2;}
 - 
 
470 
            HiResRoll = roll_filter - 20 * AdNeutralRoll;
 - 
 
471 
            AdWertRollFilter = (long)(3L * (long)AdWertRollFilter + HiResRoll + 2) / 4;
 - 
 
472 
            DebugOut.Analog[22] = AdWertRollFilter / 4;
 - 
 
473 
            kanal = AD_ACC_X;
 - 
 
474 
            break;
 - 
 
475 
        case 34:
 - 
 
476 
            Aktuell_ax = ADC - NeutralAccX;
 - 
 
477 
            AdWertAccNick =  (Aktuell_ax + accx);
 - 
 
478 
                    kanal = AD_NICK;
 - 
 
479 
            state = 0;
 - 
 
480 
                        AdReady = 1;
 - 
 
481 
            ZaehlMessungen++;
 - 
 
482 
            break;
 - 
 
483 
        default:
 - 
 
484 
            kanal = 0;
 - 
 
485 
            state = 0;
 - 
 
486 
            break;
 - 
 
487 
        }
 - 
 
488 
    ADMUX = kanal;
 - 
 
489 
    if(state != 0) ANALOG_ON;
 - 
 
490 
}
 -