Subversion Repositories FlightCtrl

Rev

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

Rev 858 Rev 887
Line 5... Line 5...
5 
// + see the File "License.txt" for further Informations
 5 
// + see the File "License.txt" for further Informations
6 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 6 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Line 7... Line 7...
7 
 
 7 
 
Line 8... Line 8...
8 
#include "main.h"
 8 
#include "main.h"
9 
 
 9 
 
10 
volatile int  Aktuell_Nick,Aktuell_Roll,Aktuell_Gier,Aktuell_ax, Aktuell_ay,Aktuell_az, UBat = 100;
 10 
volatile int  Aktuell_Nick,Aktuell_Roll,Aktuell_Gier,Aktuell_az, UBat = 100;
11 
volatile int  AdWertNick = 0, AdWertRoll = 0, AdWertGier = 0;
 11 
volatile int  AdWertNick = 0, AdWertRoll = 0, AdWertGier = 0;
12 
volatile int  AdWertAccRoll = 0,AdWertAccNick = 0,AdWertAccHoch = 0;
 12 
volatile int  AdWertAccRoll = 0,AdWertAccNick = 0,AdWertAccHoch = 0;
13 
volatile char MessanzahlNick = 0, MessanzahlRoll = 0, MessanzahlGier = 0;
 13 
volatile char MessanzahlNick = 0, MessanzahlRoll = 0, MessanzahlGier = 0;
Line 24... Line 24...
24 
//#######################################################################################
 24 
//#######################################################################################
25 
//
 25 
//
26 
void ADC_Init(void)
 26 
void ADC_Init(void)
27 
//#######################################################################################
 27 
//#######################################################################################
28 
{
 28 
{
29 
    ADMUX = 0;//Referenz ist extern
 29 
    ADMUX = 0;  // Referenz extern, Right Adjust, ADC0
30 
    ADCSRA=(1<<ADEN)|(1<<ADSC)|(1<<ADATE)|(1<<ADPS2)|(1<<ADPS1)|(1<<ADPS0)|(1<<ADIE);
 30 
    ADCSRA = (1<<ADEN)|(1<<ADSC)|(1<<ADPS2)|(1<<ADPS1)|(1<<ADPS0)|(1<<ADIE);
31 
    //Free Running Mode, Division Factor 128, Interrupt on
 31 
    // Single Conversion, Division Factor 128, Interrupt on
- 
 
 32 
        // ~12 kSPS
32 
}
 33 
}
Line 33... Line 34...
33 
 
 34 
 
34 
void SucheLuftruckOffset(void)
 35 
void SucheLuftruckOffset(void)
35 
{
 36 
{
Line 55... Line 56...
55 
//#######################################################################################
 56 
//#######################################################################################
56 
//
 57 
//
57 
SIGNAL(SIG_ADC)
 58 
SIGNAL(SIG_ADC)
58 
//#######################################################################################
 59 
//#######################################################################################
59 
{
 60 
{
60 
    static unsigned char kanal=0,state = 0;
 61 
    static unsigned char state = 0;
61 
    static unsigned int gier1, roll1, nick1;
 62 
    static unsigned int gier1, roll1, nick1;
62 
    ANALOG_OFF;
 63 
 
63 
    switch(state++)
 64 
    switch(state++)
64 
        {
 65 
        {
65 
        case 0:
 66 
        case 0:
66 
            gier1 = ADC;
 67 
            gier1 = ADC;
67 
            kanal = 1;
 68 
            ADMUX = 1;
68 
            ZaehlMessungen++;
 69 
            ZaehlMessungen++;
69 
            break;
 70 
            break;
70 
        case 1:
 71 
        case 1:
71 
            roll1 = ADC;
 72 
            roll1 = ADC;
72 
            kanal = 2;
 73 
            ADMUX = 2;
73 
            break;
 74 
            break;
74 
        case 2:
 75 
        case 2:
75 
            nick1 = ADC;
 76 
            nick1 = ADC;
76 
            kanal = 4;
 77 
            ADMUX = 4;
77 
            break;
 78 
            break;
78 
        case 3:
 79 
        case 3:
79 
            UBat = (3 * UBat + ADC / 3) / 4;
 80 
            UBat = (3 * UBat + ADC / 3) / 4;
80 
            kanal = 6;
 81 
            ADMUX = 6;
81 
            break;
 82 
            break;
82 
        case 4:
 83 
        case 4:
83 
            Aktuell_ay = acc_neutral.Y - ADC;
 84 
            AdWertAccRoll = acc_neutral.Y - ADC;
84 
            AdWertAccRoll = Aktuell_ay;
 - 
 
85 
            kanal = 7;
 85 
            ADMUX = 7;
86 
            break;
 86 
            break;
87 
        case 5:
 87 
        case 5:
88 
            Aktuell_ax = ADC - acc_neutral.X;
 88 
            AdWertAccNick = ADC - acc_neutral.X;
89 
            AdWertAccNick =  Aktuell_ax;
 - 
 
90 
                    kanal = 0;
 89 
                    ADMUX = 0;
91 
            break;
 90 
            break;
92 
        case 6:
 91 
        case 6:
93 
            #if (PlatinenVersion == 10)
 92 
            #if (PlatinenVersion == 10)
94 
                         AdWertGier = (ADC + gier1) / 2;
 93 
                         AdWertGier = (ADC + gier1) / 2;
95 
                        #else
 94 
                        #else
96 
                         AdWertGier = ADC + gier1;
 95 
                         AdWertGier = ADC + gier1;
97 
                        #endif
 96 
                        #endif
98 
            kanal = 1;
 97 
            ADMUX = 1;
99 
            break;
 98 
            break;
100 
        case 7:
 99 
        case 7:
101 
            #if (PlatinenVersion == 10)
 100 
            #if (PlatinenVersion == 10)
102 
                         AdWertRoll = (ADC + roll1) / 2;
 101 
                         AdWertRoll = (ADC + roll1) / 2;
103 
                        #else
 102 
                        #else
104 
                         AdWertRoll = ADC + roll1;
 103 
                         AdWertRoll = ADC + roll1;
105 
                        #endif
 104 
                        #endif
106 
            kanal = 2;
 105 
            ADMUX = 2;
107 
            break;
 106 
            break;
108 
        case 8:
 107 
        case 8:
109 
            #if (PlatinenVersion == 10)
 108 
            #if (PlatinenVersion == 10)
110 
                         AdWertNick = (ADC + nick1) / 2;
 109 
                         AdWertNick = (ADC + nick1) / 2;
111 
                        #else
 110 
                        #else
112 
                         AdWertNick = ADC + nick1;
 111 
                         AdWertNick = ADC + nick1;
113 
                        #endif          
112 
                        #endif          
114 
            kanal = 5;
 113 
            ADMUX = 5;
115 
            break;
 114 
            break;
116 
       case 9:
 115 
        case 9:
117 
            AdWertAccHoch =  (signed int) ADC - acc_neutral.Z;
 116 
            AdWertAccHoch = (signed int) ADC - acc_neutral.Z;
118 
            AdWertAccHoch += abs(Aktuell_ay) / 4 + abs(Aktuell_ax) / 4;
 117 
            AdWertAccHoch += abs(AdWertAccRoll) / 4 + abs(AdWertAccNick) / 4;
119 
            if(AdWertAccHoch > 1)
 118 
            if(AdWertAccHoch > 1)
120 
             {
 119 
             {
121 
              if(acc_neutral.Z < 800) acc_neutral.Z+= 0.02;
 120 
              if(acc_neutral.Z < 800) acc_neutral.Z += 0.02;
122 
             }  
 121 
             }  
123 
             else if(AdWertAccHoch < -1)
 122 
             else if(AdWertAccHoch < -1)
124 
             {
 123 
             {
125 
              if(acc_neutral.Z > 600) acc_neutral.Z-= 0.02;
 124 
              if(acc_neutral.Z > 600) acc_neutral.Z -= 0.02;
126 
             }
 125 
             }
127 
            messanzahl_AccHoch = 1;
 126 
            messanzahl_AccHoch = 1;
128 
            Aktuell_az = ADC;
 127 
            Aktuell_az = ADC;
129 
            Mess_Integral_Hoch += AdWertAccHoch;      // Integrieren
 128 
            Mess_Integral_Hoch += AdWertAccHoch;      // Integrieren
130 
            Mess_Integral_Hoch -= Mess_Integral_Hoch / 1024; // dämfen
 129 
            Mess_Integral_Hoch -= Mess_Integral_Hoch / 1024; // dämpfen
131 
                kanal = 3;
 130 
                ADMUX = 3;
132 
            break;
 131 
            break;
133 
        case 10:
 132 
        case 10:
134 
            tmpLuftdruck += ADC;
 133 
            tmpLuftdruck += ADC;
135 
            if(++messanzahl_Druck >= 5)
 134 
            if(++messanzahl_Druck >= 5)
136 
                {
 135 
                {
Line 139... Line 138...
139 
                                HoeheD = (int)(StartLuftdruck - tmpLuftdruck - HoehenWert);  // D-Anteil = neuerWert - AlterWert
 138 
                                HoeheD = (int)(StartLuftdruck - tmpLuftdruck - HoehenWert);  // D-Anteil = neuerWert - AlterWert
140 
                Luftdruck = (tmpLuftdruck + 3 * Luftdruck) / 4;
 139 
                Luftdruck = (tmpLuftdruck + 3 * Luftdruck) / 4;
141 
                HoehenWert = StartLuftdruck - Luftdruck;
 140 
                HoehenWert = StartLuftdruck - Luftdruck;
142 
                tmpLuftdruck = 0;
 141 
                tmpLuftdruck = 0;
143 
                }
 142 
                }
144 
            kanal = 0;
 143 
            ADMUX = 0;
145 
            state = 0;
 144 
            state = 0;
146 
            break;
 145 
            break;
147 
        default:
 146 
        default:
148 
            kanal = 0;
 147 
            ADMUX = 0;
149 
            state = 0;
 148 
            state = 0;
150 
            break;
 149 
            break;
151 
        }
 150 
        }
152 
    ADMUX = kanal;
 - 
 
153 
    if(state != 0) ANALOG_ON;
 151 
    if (state != 0) ANALOG_ON;  // Nach einer kompletten Runde ADC nicht neu starten. Neustart wird in der fc.c initiiert.
154 
}
 152 
}