Subversion Repositories FlightCtrl

// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

// + Copyright (c) 04.2007 Holger Buss

// + only for non-profit use

// + www.MikroKopter.com

// + see the File "License.txt" for further Informations

// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

#include "main.h"

volatile int  Aktuell_Nick,Aktuell_Roll,Aktuell_Gier,Aktuell_az, UBat = 100;

volatile int  AdWertNick = 0, AdWertRoll = 0, AdWertGier = 0;

volatile int  AdWertAccRoll = 0,AdWertAccNick = 0,AdWertAccHoch = 0;

volatile char MessanzahlNick = 0, MessanzahlRoll = 0, MessanzahlGier = 0;

volatile char messanzahl_AccNick = 0, messanzahl_AccRoll = 0, messanzahl_AccHoch = 0;

volatile long Luftdruck = 32000;

volatile int  StartLuftdruck;

volatile unsigned int  MessLuftdruck = 1023;

unsigned char DruckOffsetSetting;

volatile int HoeheD = 0;

volatile char messanzahl_Druck;

volatile int  tmpLuftdruck;

volatile unsigned int ZaehlMessungen = 0;

//#######################################################################################

//

void ADC_Init(void)

//#######################################################################################

{

    ADMUX = 0;  // Referenz extern, Right Adjust, ADC0

    ADCSRA = (1<<ADEN)|(1<<ADSC)|(1<<ADPS2)|(1<<ADPS1)|(1<<ADPS0)|(1<<ADIE);

    // Single Conversion, Division Factor 128, Interrupt on

        // ~12 kSPS

}

void SucheLuftruckOffset(void)

{

 unsigned int off;

 off = eeprom_read_byte(&EEPromArray[EEPROM_ADR_LAST_OFFSET]);

 if(off > 20) off -= 10;

 OCR0A = off;

 Delay_ms_Mess(100);

 if(MessLuftdruck < 850) off = 0;

 for(; off < 250;off++)

  {

  OCR0A = off;

  Delay_ms_Mess(50);

  printf(".");  

  if(MessLuftdruck < 900) break;

  }

 eeprom_write_byte(&EEPromArray[EEPROM_ADR_LAST_OFFSET], off);

 DruckOffsetSetting = off;

 Delay_ms_Mess(300);

}

//#######################################################################################

//

SIGNAL(SIG_ADC)

//#######################################################################################

{

    static unsigned char state = 0;

    static unsigned int gier1, roll1, nick1;

    switch(state++)

        {

        case 0:

            gier1 = ADC;

            ADMUX = 1;

            ZaehlMessungen++;

            break;

        case 1:

            roll1 = ADC;

            ADMUX = 2;

            break;

        case 2:

            nick1 = ADC;

            ADMUX = 4;

            break;

        case 3:

            UBat = (3 * UBat + ADC / 3) / 4;

            ADMUX = 6;

            break;

        case 4:

            AdWertAccRoll = acc_neutral.Y - ADC;

            ADMUX = 7;

            break;

        case 5:

            AdWertAccNick = ADC - acc_neutral.X;

                    ADMUX = 0;

            break;

        case 6:

            #if (PlatinenVersion == 10)

                         AdWertGier = (ADC + gier1) / 2;

                        #else

                         AdWertGier = ADC + gier1;

                        #endif

            ADMUX = 1;

            break;

        case 7:

            #if (PlatinenVersion == 10)

                         AdWertRoll = (ADC + roll1) / 2;

                        #else

                         AdWertRoll = ADC + roll1;

                        #endif

            ADMUX = 2;

            break;

        case 8:

            #if (PlatinenVersion == 10)

                         AdWertNick = (ADC + nick1) / 2;

                        #else

                         AdWertNick = ADC + nick1;

                        #endif           

            ADMUX = 5;

            break;

        case 9:

            AdWertAccHoch = (signed int) ADC - acc_neutral.Z;

            AdWertAccHoch += abs(AdWertAccRoll) / 4 + abs(AdWertAccNick) / 4;

            if(AdWertAccHoch > 1)

             {

              if(acc_neutral.Z < 800) acc_neutral.Z += 0.02;

             }  

             else if(AdWertAccHoch < -1)

             {

              if(acc_neutral.Z > 600) acc_neutral.Z -= 0.02;

             }

            messanzahl_AccHoch = 1;

            Aktuell_az = ADC;

            Mess_Integral_Hoch += AdWertAccHoch;      // Integrieren

            Mess_Integral_Hoch -= Mess_Integral_Hoch / 1024; // dämpfen

                ADMUX = 3;

            break;

        case 10:

            tmpLuftdruck += ADC;

            if(++messanzahl_Druck >= 5)

                {

                MessLuftdruck = ADC;

                messanzahl_Druck = 0;

                                HoeheD = (int)(StartLuftdruck - tmpLuftdruck - HoehenWert);  // D-Anteil = neuerWert - AlterWert

                Luftdruck = (tmpLuftdruck + 3 * Luftdruck) / 4;

                HoehenWert = StartLuftdruck - Luftdruck;

                tmpLuftdruck = 0;

                }

            ADMUX = 0;

            state = 0;

            break;

        default:

            ADMUX = 0;

            state = 0;

            break;

        }

    if (state != 0) ANALOG_ON;  // Nach einer kompletten Runde ADC nicht neu starten. Neustart wird in der fc.c initiiert.

}