WebSVN - FlightCtrl - Diff - Rev 528 and 529 - /branches/salvo_gps/Basis

 // +  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 // +  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 // +  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 // +  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 // +  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-// +  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-// +  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// +  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN// +  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 // +  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 // +  POSSIBILITY OF SUCH DAMAGE.
 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // Aenderungen von Peter Muehlenbrock ("Salvo") Stand 6.10.2007
 /*
 Linearsensor mit fixem Neutralwert
 Ersatzkompass abgeleitet aus Magnetkompass und Giergyro fuer nahezu neigungsunabhaengige Kompassfunktion
 */
+#include "main.h"
-#include "main.h"
+#include "eeprom.c"
 unsigned char h,m,s;
 volatile unsigned int I2CTimeout = 100;
 volatile int MesswertNick,MesswertRoll,MesswertGier;
-volatile int AdNeutralNick = 0,AdNeutralRoll = 0,AdNeutralGier = 0;
+volatile int AdNeutralNick = 0,AdNeutralRoll = 0,AdNeutralGier = 0,StartNeutralRoll = 0,StartNeutralNick = 0;
 volatile int Mittelwert_AccNick, Mittelwert_AccRoll,Mittelwert_AccHoch, NeutralAccX=0, NeutralAccY=0;
 volatile float NeutralAccZ = 0;
 unsigned char CosinusNickWinkel = 0, CosinusRollWinkel = 0;
+volatile long IntegralNick = 0,IntegralNick2 = 0;
-volatile long IntegralNick = 0,IntegralNick2 = 0;
+volatile long IntegralRoll = 0,IntegralRoll2 = 0;
-volatile long IntegralRoll = 0,IntegralRoll2 = 0;
+volatile long IntegralAccNick = 0,IntegralAccRoll = 0,IntegralAccZ = 0;
 volatile long Integral_Gier = 0;
 volatile long Mess_IntegralNick = 0,Mess_IntegralNick2 = 0;
+volatile long Mess_IntegralRoll = 0,Mess_IntegralRoll2 = 0;
-volatile long Mess_IntegralRoll = 0,Mess_IntegralRoll2 = 0;
+volatile long Mess_Integral_Gier = 0,Mess_Integral_Gier2 = 0;
-volatile long Mess_Integral_Gier = 0,Mess_Integral_Gier2 = 0;
+volatile long MittelIntegralNick,MittelIntegralRoll,MittelIntegralNick2,MittelIntegralRoll2;
 volatile long Mess_Integral_Hoch = 0;
 volatile int  KompassValue = 0;
 volatile int  KompassStartwert = 0;
 volatile int  KompassRichtung = 0;
 unsigned char MAX_GAS,MIN_GAS;
+unsigned char Notlandung = 0;
+unsigned char HoehenReglerAktiv = 0;
+long Umschlag180Nick = 250000L, Umschlag180Roll = 250000L;
 unsigned char Notlandung = 0;
 unsigned char HoehenReglerAktiv = 0;
 //Salvo 12.10.2007
 uint8_t magkompass_ok=0;
 uint8_t gps_cmd = GPS_CMD_STOP;
+static int       ubat_cnt =0;
-static int       ubat_cnt =0;
+static int gas_actual,gas_mittel; //Parameter fuer Gasreduzierung bei unterspannung
-static int gas_actual,gas_mittel; //Parameter fuer Gasreduzierung bei unterspannung
+int w,v;
 //Salvo End
  //Salvo 2.9.2007 Ersatzkompass
+volatile long GyroKomp_Int;
-volatile long GyroKomp_Int,GyroKomp_Int2;
+volatile int GyroKomp_Value; //  Der ermittelte Kompasswert aus Gyro und Magnetkompass
-volatile int GyroKomp_Value; //  Der ermittelte Kompasswert aus Gyro und Magnetkompass
+// Salvo End
-// Salvo End
 float GyroFaktor;
-float IntegralFaktor;
+float GyroFaktor;
 float IntegralFaktor;
 volatile int  DiffNick,DiffRoll;
 int  Poti1 = 0, Poti2 = 0, Poti3 = 0, Poti4 = 0;
 volatile unsigned char Motor_Vorne,Motor_Hinten,Motor_Rechts,Motor_Links, Count;
 unsigned char MotorWert[5];
 volatile unsigned char SenderOkay = 0;
 int StickNick = 0,StickRoll = 0,StickGier = 0;
 char MotorenEin = 0;
-int HoehenWert = 0;
-int SollHoehe = 0;
-unsigned char Looping_Nick = 0,Looping_Roll = 0;
-int w,v;
+int HoehenWert = 0;
+int SollHoehe = 0;
+int LageKorrekturRoll = 0,LageKorrekturNick = 0;
 float Ki =  FAKTOR_I;
-float Kp =  FAKTOR_P;
+unsigned char Looping_Nick = 0,Looping_Roll = 0;
-float Ki =  FAKTOR_I;
+unsigned char Looping_Links = 0, Looping_Rechts = 0, Looping_Unten = 0, Looping_Oben = 0;
 unsigned char Parameter_Luftdruck_D  = 48;      // Wert : 0-250
 unsigned char Parameter_MaxHoehe     = 251;      // Wert : 0-250
 unsigned char Parameter_Hoehe_P      = 16;      // Wert : 0-32
 unsigned char Parameter_Hoehe_ACC_Wirkung = 58; // Wert : 0-250
 unsigned char Parameter_KompassWirkung = 64;    // Wert : 0-250
-unsigned char Parameter_Gyro_P = 50;           // Wert : 10-250
+unsigned char Parameter_Gyro_P = 150;           // Wert : 10-250
 unsigned char Parameter_Gyro_I = 150;           // Wert : 0-250
 unsigned char Parameter_Gier_P = 2;             // Wert : 1-20
 unsigned char Parameter_I_Faktor = 10;          // Wert : 1-20
+unsigned char Parameter_UserParam1 = 0;
+unsigned char Parameter_UserParam2 = 0;
+unsigned char Parameter_UserParam3 = 0;
+unsigned char Parameter_UserParam4 = 0;
-unsigned char Parameter_UserParam1 = 0;
+unsigned char Parameter_UserParam5 = 0;
-unsigned char Parameter_UserParam2 = 0;
+unsigned char Parameter_UserParam6 = 0;
+unsigned char Parameter_UserParam7 = 0;
+unsigned char Parameter_UserParam8 = 0;
+unsigned char Parameter_ServoNickControl = 100;
-unsigned char Parameter_UserParam3 = 0;
+unsigned char Parameter_LoopGasLimit = 70;
+unsigned char Parameter_AchsKopplung1 = 0;
-unsigned char Parameter_UserParam4 = 0;
+unsigned char Parameter_AchsGegenKopplung1 = 0;
-unsigned char Parameter_ServoNickControl = 100;
+unsigned char Parameter_DynamicStability = 100;
-unsigned char Parameter_LoopGasLimit = 70;
+struct mk_param_struct EE_Parameter;
-struct mk_param_struct EE_Parameter;
+signed int ExternStickNick = 0,ExternStickRoll = 0,ExternStickGier = 0, ExternHoehenValue = -20;
 //############################################################################
 //  Nullwerte ermitteln
 void SetNeutral(void)
 //############################################################################
+{
-    unsigned int timer;
         NeutralAccX = 0;
         NeutralAccY = 0;
         NeutralAccZ = 0;
     AdNeutralNick = 0;
         AdNeutralRoll = 0;
         AdNeutralGier = 0;
-        GPS_Neutral();
+    Parameter_AchsKopplung1 = 0;
+    Parameter_AchsGegenKopplung1 = 0;
     CalibrierMittelwert();
-    timer = SetDelay(5);
+    Delay_ms_Mess(100);
-        while (!CheckDelay(timer));
         CalibrierMittelwert();
     if((EE_Parameter.GlobalConfig & CFG_HOEHENREGELUNG))  // Höhenregelung aktiviert?
+     {
       if((MessLuftdruck > 950) || (MessLuftdruck < 750)) SucheLuftruckOffset();
+     }
+     AdNeutralNick= AdWertNick;
+         AdNeutralRoll= AdWertRoll;
+         AdNeutralGier= AdWertGier;
+     StartNeutralRoll = AdNeutralRoll;
+     StartNeutralNick = AdNeutralNick;
-    if(PlatinenVersion == 10)
+    if(eeprom_read_byte(&EEPromArray[EEPROM_ADR_ACC_NICK]) > 4)
     {
-     AdNeutralNick= abs(MesswertNick);
+      NeutralAccY = abs(Mittelwert_AccRoll) / ACC_AMPLIFY;
-         AdNeutralRoll= abs(MesswertRoll);
+          NeutralAccX = abs(Mittelwert_AccNick) / ACC_AMPLIFY;
-         AdNeutralGier= abs(MesswertGier);
+          NeutralAccZ = Aktuell_az;
+    }
     else
     {
-     AdNeutralNick= abs(MesswertNick) / 2;
+      NeutralAccX = (int)eeprom_read_byte(&EEPromArray[EEPROM_ADR_ACC_NICK]) * 256 + (int)eeprom_read_byte(&EEPromArray[EEPROM_ADR_ACC_NICK+1]);
-         AdNeutralRoll= abs(MesswertRoll) / 2;
+          NeutralAccY = (int)eeprom_read_byte(&EEPromArray[EEPROM_ADR_ACC_ROLL]) * 256 + (int)eeprom_read_byte(&EEPromArray[EEPROM_ADR_ACC_ROLL+1]);
-         AdNeutralGier= abs(MesswertGier) / 2;
+          NeutralAccZ = (int)eeprom_read_byte(&EEPromArray[EEPROM_ADR_ACC_Z]) * 256 + (int)eeprom_read_byte(&EEPromArray[EEPROM_ADR_ACC_Z+1]);
-    }
-// Salvo 1.9.2007 ACC mit festen neutralwerten *****
-        if (ACC_NEUTRAL_FIXED > 0)
-        {
-                NeutralAccX     = ACC_NICK_NEUTRAL;
-                NeutralAccY     = ACC_ROLL_NEUTRAL;
-        }
-        else
-        { // Automatisch bei Offsetabgleich ermitteln
-                NeutralAccX = abs(Mittelwert_AccNick) / ACC_AMPLIFY;
-                NeutralAccY = abs(Mittelwert_AccRoll) / ACC_AMPLIFY;
-        }
- // Salvo End
         NeutralAccZ = Aktuell_az;
         Mess_IntegralNick = 0;
     Mess_IntegralNick2 = 0;
     MesswertGier = 0;
     StartLuftdruck = Luftdruck;
     HoeheD = 0;
     Mess_Integral_Hoch = 0;
     KompassStartwert = KompassValue;
+    GPS_Neutral();
     beeptime = 50;
+        Umschlag180Nick = (long) EE_Parameter.WinkelUmschlagNick * 2500L;
+        Umschlag180Roll = (long) EE_Parameter.WinkelUmschlagRoll * 2500L;
+    ExternHoehenValue = 0;
 //Salvo 13.10.2007 Ersatzkompass und Gas
         GyroKomp_Int =  KompassValue * GYROKOMP_INC_GRAD_DEFAULT; //Neu ab 3.1.2007
         gas_mittel      =       30;
         gas_actual      =       gas_mittel;
 // Salvo End
+}
 //############################################################################
-// Bildet den Mittelwert aus den Messwerten
+// Bearbeitet die Messwerte
 void Mittelwert(void)
 //############################################################################
 {
-    // ADC auschalten, damit die Werte sich nicht während der Berechnung ändern
-    ANALOG_OFF;
+    static signed long tmpl,tmpl2;
-        if(MessanzahlNick)    (MesswertNick = AccumulateNick / MessanzahlNick);
+    MesswertGier = (signed int) AdNeutralGier - AdWertGier;
-        if(MessanzahlRoll)    (MesswertRoll = AccumulateRoll / MessanzahlRoll);
+    MesswertRoll = (signed int) AdWertRoll - AdNeutralRoll;
+    MesswertNick = (signed int) AdWertNick - AdNeutralNick;
-        if(MessanzahlGier)    (MesswertGier = AccumulateGier / MessanzahlGier);
+// Beschleunigungssensor  ++++++++++++++++++++++++++++++++++++++++++++++++
-        if(messanzahl_AccNick) Mittelwert_AccNick = ((long)Mittelwert_AccNick * 7 + ((ACC_AMPLIFY * (long)accumulate_AccNick) / messanzahl_AccNick)) / 8L;
+        Mittelwert_AccNick = ((long)Mittelwert_AccNick * 1 + ((ACC_AMPLIFY * (long)AdWertAccNick))) / 2L;
-        if(messanzahl_AccRoll) Mittelwert_AccRoll = ((long)Mittelwert_AccRoll * 7 + ((ACC_AMPLIFY * (long)accumulate_AccRoll) / messanzahl_AccRoll)) / 8L;
+        Mittelwert_AccRoll = ((long)Mittelwert_AccRoll * 1 + ((ACC_AMPLIFY * (long)AdWertAccRoll))) / 2L;
+        Mittelwert_AccHoch = ((long)Mittelwert_AccHoch * 1 + ((long)AdWertAccHoch)) / 2L;
+    IntegralAccNick += ACC_AMPLIFY * AdWertAccNick;
+    IntegralAccRoll += ACC_AMPLIFY * AdWertAccRoll;
+    IntegralAccZ    += Aktuell_az - NeutralAccZ;
+// Gier  ++++++++++++++++++++++++++++++++++++++++++++++++
+//Salvo 12.11.2007
+                        GyroKomp_Int  += MesswertGier;
+//Salvo End
+            Mess_Integral_Gier +=  MesswertGier;
+            Mess_Integral_Gier2 += MesswertGier;
+// Kopplungsanteil  +++++++++++++++++++++++++++++++++++++
+      if(!Looping_Nick && !Looping_Roll && (EE_Parameter.GlobalConfig & CFG_ACHSENKOPPLUNG_AKTIV))
-        if(messanzahl_AccHoch) Mittelwert_AccHoch = ((long)Mittelwert_AccHoch * 7 + ((long)accumulate_AccHoch) / messanzahl_AccHoch) / 8L;
+         {
+            tmpl = Mess_IntegralNick / 4096L;
+            tmpl *= MesswertGier;
+            tmpl *= Parameter_AchsKopplung1;  //125
-    AccumulateNick = 0;   MessanzahlNick = 0;
+            tmpl /= 2048L;
-    AccumulateRoll = 0;   MessanzahlRoll = 0;
+            tmpl2 = Mess_IntegralRoll / 4096L;
+            tmpl2 *= MesswertGier;
+            tmpl2 *= Parameter_AchsKopplung1;
+            tmpl2 /= 2048L;
+         }
+      else  tmpl = tmpl2 = 0;
+// Roll  ++++++++++++++++++++++++++++++++++++++++++++++++
+            MesswertRoll += tmpl;
+            MesswertRoll += (tmpl2*Parameter_AchsGegenKopplung1)/512L; //109
+            Mess_IntegralRoll2 += MesswertRoll;
+            Mess_IntegralRoll +=  MesswertRoll - LageKorrekturRoll;
+            if(Mess_IntegralRoll > Umschlag180Roll)
+            {
+             Mess_IntegralRoll  = -(Umschlag180Roll - 10000L);
+             Mess_IntegralRoll2 = Mess_IntegralRoll;
+            }
+            if(Mess_IntegralRoll <-Umschlag180Roll)
+            {
+             Mess_IntegralRoll =  (Umschlag180Roll - 10000L);
+             Mess_IntegralRoll2 = Mess_IntegralRoll;
+            }
-    AccumulateGier = 0;   MessanzahlGier = 0;
+            if(AdWertRoll < 15)   MesswertRoll = -1000;
+            if(AdWertRoll <  7)   MesswertRoll = -2000;
+            if(PlatinenVersion == 10)
+                         {
+              if(AdWertRoll > 1010) MesswertRoll = +1000;
+              if(AdWertRoll > 1017) MesswertRoll = +2000;
+                         }
+                         else
+                         {
+              if(AdWertRoll > 2020) MesswertRoll = +1000;
+              if(AdWertRoll > 2034) MesswertRoll = +2000;
+                         }
+// Nick  ++++++++++++++++++++++++++++++++++++++++++++++++
+            MesswertNick -= tmpl2;
+            MesswertNick -= (tmpl*Parameter_AchsGegenKopplung1)/512L;
+            Mess_IntegralNick2 += MesswertNick;
+            Mess_IntegralNick  += MesswertNick - LageKorrekturNick;
+            if(Mess_IntegralNick > Umschlag180Nick)
+            {
+             Mess_IntegralNick = -(Umschlag180Nick - 10000L);
+             Mess_IntegralNick2 = Mess_IntegralNick;
+            }
+            if(Mess_IntegralNick <-Umschlag180Nick)
+            {
+             Mess_IntegralNick =  (Umschlag180Nick - 10000L);
+             Mess_IntegralNick2 = Mess_IntegralNick;
-    accumulate_AccRoll = 0;messanzahl_AccRoll = 0;
+            }
-    accumulate_AccNick = 0;messanzahl_AccNick = 0;
+            if(AdWertNick < 15)   MesswertNick = -1000;
+            if(AdWertNick <  7)   MesswertNick = -2000;
+            if(PlatinenVersion == 10)
+                         {
+              if(AdWertNick > 1010) MesswertNick = +1000;
+              if(AdWertNick > 1017) MesswertNick = +2000;
+                         }
+                         else
+                         {
+              if(AdWertNick > 2020) MesswertNick = +1000;
+              if(AdWertNick > 2034) MesswertNick = +2000;
+                         }
+//++++++++++++++++++++++++++++++++++++++++++++++++
+// ADC einschalten
+    ANALOG_ON;
+//++++++++++++++++++++++++++++++++++++++++++++++++
     accumulate_AccHoch = 0;messanzahl_AccHoch = 0;
-    Integral_Gier  = Mess_Integral_Gier;
-//    Integral_Gier2 = Mess_Integral_Gier2;
+    Integral_Gier  = Mess_Integral_Gier;
     IntegralNick = Mess_IntegralNick;
     IntegralRoll = Mess_IntegralRoll;
     IntegralNick2 = Mess_IntegralNick2;
-    IntegralRoll2 = Mess_IntegralRoll2;
-    // ADC einschalten
+    IntegralRoll2 = Mess_IntegralRoll2;
-    ANALOG_ON;
-/*
+  if(EE_Parameter.GlobalConfig & CFG_DREHRATEN_BEGRENZER && !Looping_Nick && !Looping_Roll)
-//------------------------------------------------------------------------------
-    if(MesswertNick > 200)  MesswertNick += 4 * (MesswertNick - 200);
+  {
-    else
+    if(MesswertNick > 200)       MesswertNick += 4 * (MesswertNick - 200);
-    if(MesswertNick < -200) MesswertNick += 4 * (MesswertNick + 200);
-    if(MesswertRoll > 200)  MesswertRoll += 4 * (MesswertRoll - 200);
+    else if(MesswertNick < -200) MesswertNick += 4 * (MesswertNick + 200);
-    else
-    if(MesswertRoll < -200) MesswertRoll += 4 * (MesswertRoll + 200);
+    if(MesswertRoll > 200)       MesswertRoll += 4 * (MesswertRoll - 200);
-//------------------------------------------------------------------------------
+    else if(MesswertRoll < -200) MesswertRoll += 4 * (MesswertRoll + 200);
 */
     if(Poti1 < PPM_in[EE_Parameter.Kanalbelegung[K_POTI1]] + 110) Poti1++; else if(Poti1 > PPM_in[EE_Parameter.Kanalbelegung[K_POTI1]] + 110 && Poti1) Poti1--;
     if(Poti2 < PPM_in[EE_Parameter.Kanalbelegung[K_POTI2]] + 110) Poti2++; else if(Poti2 > PPM_in[EE_Parameter.Kanalbelegung[K_POTI2]] + 110 && Poti2) Poti2--;
     if(Poti3 < PPM_in[EE_Parameter.Kanalbelegung[K_POTI3]] + 110) Poti3++; else if(Poti3 > PPM_in[EE_Parameter.Kanalbelegung[K_POTI3]] + 110 && Poti3) Poti3--;
 void CalibrierMittelwert(void)
 //############################################################################
+{
     // ADC auschalten, damit die Werte sich nicht während der Berechnung ändern
         ANALOG_OFF;
-    if(MessanzahlNick)    (MesswertNick = AccumulateNick / MessanzahlNick);
-        if(MessanzahlRoll)    (MesswertRoll = AccumulateRoll / MessanzahlRoll);
-        if(MessanzahlGier)    (MesswertGier = AccumulateGier / MessanzahlGier);
-        if(messanzahl_AccNick) Mittelwert_AccNick = ((ACC_AMPLIFY * (long)accumulate_AccNick) / messanzahl_AccNick);
-        if(messanzahl_AccRoll) Mittelwert_AccRoll = (ACC_AMPLIFY * (long)accumulate_AccRoll) / messanzahl_AccRoll;
-        if(messanzahl_AccHoch) Mittelwert_AccHoch = ((long)accumulate_AccHoch) / messanzahl_AccHoch;
-    AccumulateNick = 0;   MessanzahlNick = 0;
+        MesswertNick = AdWertNick;
-    AccumulateRoll = 0;   MessanzahlRoll = 0;
+        MesswertRoll = AdWertRoll;
-    AccumulateGier = 0;   MessanzahlGier = 0;
+        MesswertGier = AdWertGier;
-    accumulate_AccRoll = 0;messanzahl_AccRoll = 0;
+        Mittelwert_AccNick = ACC_AMPLIFY * (long)AdWertAccNick;
-    accumulate_AccNick = 0;messanzahl_AccNick = 0;
+        Mittelwert_AccRoll = ACC_AMPLIFY * (long)AdWertAccRoll;
-    accumulate_AccHoch = 0;messanzahl_AccHoch = 0;
+        Mittelwert_AccHoch = (long)AdWertAccHoch;
-    // ADC einschalten
+   // ADC einschalten
     ANALOG_ON;
     if(Poti1 < PPM_in[EE_Parameter.Kanalbelegung[K_POTI1]] + 110) Poti1++; else if(Poti1 > PPM_in[EE_Parameter.Kanalbelegung[K_POTI1]] + 110 && Poti1) Poti1--;
     if(Poti2 < PPM_in[EE_Parameter.Kanalbelegung[K_POTI2]] + 110) Poti2++; else if(Poti2 > PPM_in[EE_Parameter.Kanalbelegung[K_POTI2]] + 110 && Poti2) Poti2--;
     if(Poti3 < PPM_in[EE_Parameter.Kanalbelegung[K_POTI3]] + 110) Poti3++; else if(Poti3 > PPM_in[EE_Parameter.Kanalbelegung[K_POTI3]] + 110 && Poti3) Poti3--;
     if(Poti4 < PPM_in[EE_Parameter.Kanalbelegung[K_POTI4]] + 110) Poti4++; else if(Poti4 > PPM_in[EE_Parameter.Kanalbelegung[K_POTI4]] + 110 && Poti4) Poti4--;
     if(Poti1 < 0) Poti1 = 0; else if(Poti1 > 255) Poti1 = 255;
     if(Poti2 < 0) Poti2 = 0; else if(Poti2 > 255) Poti2 = 255;
     if(Poti3 < 0) Poti3 = 0; else if(Poti3 > 255) Poti3 = 255;
     if(Poti4 < 0) Poti4 = 0; else if(Poti4 > 255) Poti4 = 255;
+        Umschlag180Nick = (long) EE_Parameter.WinkelUmschlagNick * 2500L;
+        Umschlag180Roll = (long) EE_Parameter.WinkelUmschlagNick * 2500L;
+}
 //############################################################################
 // Senden der Motorwerte per I2C-Bus
     twi_state = 0;
     motor = 0;
     i2c_start();
+}
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-// + Konstanten
-// + 0-250 -> normale Werte
-// + 251 -> Poti1
-// + 252 -> Poti2
-// + 253 -> Poti3
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-void DefaultKonstanten1(void)
-{
- EE_Parameter.Kanalbelegung[K_NICK]  = 1;
- EE_Parameter.Kanalbelegung[K_ROLL]  = 2;
- EE_Parameter.Kanalbelegung[K_GAS]   = 3;
- EE_Parameter.Kanalbelegung[K_GIER]  = 4;
- EE_Parameter.Kanalbelegung[K_POTI1] = 5;
- EE_Parameter.Kanalbelegung[K_POTI2] = 6;
- EE_Parameter.Kanalbelegung[K_POTI3] = 7;
- EE_Parameter.Kanalbelegung[K_POTI4] = 8;
- EE_Parameter.GlobalConfig = 0;//CFG_HOEHENREGELUNG | /*CFG_HOEHEN_SCHALTER |*/ CFG_KOMPASS_AKTIV | CFG_KOMPASS_FIX;//0x01;
- EE_Parameter.Hoehe_MinGas = 30;
- EE_Parameter.MaxHoehe     = 251;      // Wert : 0-32   251 -> Poti1
- EE_Parameter.Hoehe_P      = 10;       // Wert : 0-32
- EE_Parameter.Luftdruck_D  = 50;       // Wert : 0-250
- EE_Parameter.Hoehe_ACC_Wirkung = 50;  // Wert : 0-250
- EE_Parameter.Hoehe_Verstaerkung = 4;  // Wert : 0-50
- EE_Parameter.Stick_P = 2; //2         // Wert : 1-6
- EE_Parameter.Stick_D = 4; //8         // Wert : 0-64
- EE_Parameter.Gier_P = 16;             // Wert : 1-20
- EE_Parameter.Gas_Min = 15;            // Wert : 0-32
- EE_Parameter.Gas_Max = 250;           // Wert : 33-250
- EE_Parameter.GyroAccFaktor = 26;      // Wert : 1-64
- EE_Parameter.KompassWirkung = 128;    // Wert : 0-250
- EE_Parameter.Gyro_P = 120; //80          // Wert : 0-250
- EE_Parameter.Gyro_I = 150;               // Wert : 0-250
- EE_Parameter.UnterspannungsWarnung = 100; // Wert : 0-250
- EE_Parameter.NotGas = 100;                // Wert : 0-250     // Gaswert bei Empangsverlust
- EE_Parameter.NotGasZeit = 60;            // Wert : 0-250     // Zeit bis auf NotGas geschaltet wird, wg. Rx-Problemen
- EE_Parameter.UfoAusrichtung = 0;         // X oder + Formation
- EE_Parameter.I_Faktor = 0;
- EE_Parameter.UserParam1 = 8;             //zur freien Verwendung
- EE_Parameter.UserParam2 = 2;             //zur freien Verwendung
- EE_Parameter.UserParam3 = 12;             //zur freien Verwendung
- EE_Parameter.UserParam4 = 0;             //zur freien Verwendung
- EE_Parameter.ServoNickControl = 100;     // Wert : 0-250     // Stellung des Servos
- EE_Parameter.ServoNickComp = 40;         // Wert : 0-250     // Einfluss Gyro/Servo
- EE_Parameter.ServoNickCompInvert = 0;    // Wert : 0-250     // Richtung Einfluss Gyro/Servo
- EE_Parameter.ServoNickMin = 50;          // Wert : 0-250     // Anschlag
- EE_Parameter.ServoNickMax = 150;         // Wert : 0-250     // Anschlag
- EE_Parameter.ServoNickRefresh = 5;
- EE_Parameter.LoopGasLimit = 50;
- EE_Parameter.LoopThreshold = 90;         // Wert: 0-250  Schwelle für Stickausschlag
- EE_Parameter.LoopConfig = 0;             // Bitcodiert: 0x01=oben, 0x02=unten, 0x04=links, 0x08=rechts / wird getrennt behandelt
- memcpy(EE_Parameter.Name, "Sport\0", 12);
-}
-void DefaultKonstanten2(void)
-{
- EE_Parameter.Kanalbelegung[K_NICK]  = 1;
- EE_Parameter.Kanalbelegung[K_ROLL]  = 2;
- EE_Parameter.Kanalbelegung[K_GAS]   = 3;
- EE_Parameter.Kanalbelegung[K_GIER]  = 4;
- EE_Parameter.Kanalbelegung[K_POTI1] = 5;
- EE_Parameter.Kanalbelegung[K_POTI2] = 6;
- EE_Parameter.Kanalbelegung[K_POTI3] = 7;
- EE_Parameter.Kanalbelegung[K_POTI4] = 8;
- EE_Parameter.GlobalConfig = 0;//CFG_HOEHENREGELUNG | /*CFG_HOEHEN_SCHALTER |*/ CFG_KOMPASS_AKTIV;//0x01;
- EE_Parameter.Hoehe_MinGas = 30;
- EE_Parameter.MaxHoehe     = 251;     // Wert : 0-32   251 -> Poti1
- EE_Parameter.Hoehe_P      = 10;      // Wert : 0-32
- EE_Parameter.Luftdruck_D  = 50;      // Wert : 0-250
- EE_Parameter.Hoehe_ACC_Wirkung = 50; // Wert : 0-250
- EE_Parameter.Hoehe_Verstaerkung = 2; // Wert : 0-50
- EE_Parameter.Stick_P = 2; //2           // Wert : 1-6
- EE_Parameter.Stick_D = 0; //8           // Wert : 0-64
- EE_Parameter.Gier_P = 16;            // Wert : 1-20
- EE_Parameter.Gas_Min = 15;            // Wert : 0-32
- EE_Parameter.Gas_Max = 250;          // Wert : 33-250
- EE_Parameter.GyroAccFaktor = 26;     // Wert : 1-64
- EE_Parameter.KompassWirkung = 64;    // Wert : 0-250
- EE_Parameter.Gyro_P = 175; //80           // Wert : 0-250
- EE_Parameter.Gyro_I = 175;           // Wert : 0-250
- EE_Parameter.UnterspannungsWarnung = 100;  // Wert : 0-250
- EE_Parameter.NotGas = 100;                 // Wert : 0-250     // Gaswert bei Empangsverlust
- EE_Parameter.NotGasZeit = 60;             // Wert : 0-250     // Zeit bis auf NotGas geschaltet wird, wg. Rx-Problemen
- EE_Parameter.UfoAusrichtung = 0;         // X oder + Formation
- EE_Parameter.I_Faktor = 5;
- EE_Parameter.UserParam1 = 12;   //zur freien Verwendung
- EE_Parameter.UserParam2 = 2;   //zur freien Verwendung
- EE_Parameter.UserParam3 = 16;   //zur freien Verwendung
- EE_Parameter.UserParam4 = 0;   //zur freien Verwendung
- EE_Parameter.ServoNickControl = 100;     // Wert : 0-250     // Stellung des Servos
- EE_Parameter.ServoNickComp = 40;         // Wert : 0-250     // Einfluss Gyro/Servo
- EE_Parameter.ServoNickCompInvert = 0;    // Wert : 0-250     // Richtung Einfluss Gyro/Servo
- EE_Parameter.ServoNickMin = 50;           // Wert : 0-250     // Anschlag
- EE_Parameter.ServoNickMax = 150;         // Wert : 0-250     // Anschlag
- EE_Parameter.ServoNickRefresh = 5;
- EE_Parameter.LoopGasLimit = 50;
- EE_Parameter.LoopThreshold = 90;         // Wert: 0-250  Schwelle für Stickausschlag
- EE_Parameter.LoopConfig = 0;              // Bitcodiert: 0x01=oben, 0x02=unten, 0x04=links, 0x08=rechts
- memcpy(EE_Parameter.Name, "Kamera\0", 12);
  CHK_POTI(Parameter_I_Faktor,EE_Parameter.I_Faktor,0,255);
  CHK_POTI(Parameter_UserParam1,EE_Parameter.UserParam1,0,255);
  CHK_POTI(Parameter_UserParam2,EE_Parameter.UserParam2,0,255);
  CHK_POTI(Parameter_UserParam3,EE_Parameter.UserParam3,0,255);
  CHK_POTI(Parameter_UserParam4,EE_Parameter.UserParam4,0,255);
- CHK_POTI(Parameter_ServoNickControl,EE_Parameter.ServoNickControl,0,255);
+ CHK_POTI(Parameter_UserParam5,EE_Parameter.UserParam5,0,255);
- CHK_POTI(Parameter_ServoNickControl,EE_Parameter.ServoNickControl,0,255);
+ CHK_POTI(Parameter_UserParam6,EE_Parameter.UserParam6,0,255);
+ CHK_POTI(Parameter_UserParam7,EE_Parameter.UserParam7,0,255);
+ CHK_POTI(Parameter_UserParam8,EE_Parameter.UserParam8,0,255);
  CHK_POTI(Parameter_ServoNickControl,EE_Parameter.ServoNickControl,0,255);
  CHK_POTI(Parameter_LoopGasLimit,EE_Parameter.LoopGasLimit,0,255);
+ CHK_POTI(Parameter_AchsKopplung1,    EE_Parameter.AchsKopplung1,0,255);
+ CHK_POTI(Parameter_AchsGegenKopplung1,EE_Parameter.AchsGegenKopplung1,0,255);
+ CHK_POTI(Parameter_DynamicStability,EE_Parameter.DynamicStability,0,255);
  Ki = (float) Parameter_I_Faktor * 0.0001;
  MAX_GAS = EE_Parameter.Gas_Max;
  MIN_GAS = EE_Parameter.Gas_Min;
+{
          int motorwert,pd_ergebnis,h,tmp_int;
          int GierMischanteil,GasMischanteil;
      static long SummeNick=0,SummeRoll=0;
      static long sollGier = 0,tmp_long,tmp_long2;
-     long IntegralFehlerNick = 0;
+     static long IntegralFehlerNick = 0;
-     long IntegralFehlerRoll = 0;
+     static long IntegralFehlerRoll = 0;
          static unsigned int RcLostTimer;
          static unsigned char delay_neutral = 0;
          static unsigned char delay_einschalten = 0,delay_ausschalten = 0;
          static unsigned int  modell_fliegt = 0;
      static int hoehenregler = 0;
      static char TimerWerteausgabe = 0;
      static char NeueKompassRichtungMerken = 0;
+     static long ausgleichNick, ausgleichRoll;
         Mittelwert();
 //****** GPS Daten holen ***************
         short int n;
         if (gps_alive_cnt > 0) gps_alive_cnt--; //Dekrementieren. Wenn 0 kommen keine ausreichenden GPS Meldungen (Timeout)
         n = Get_Rel_Position();
                 ROT_ON; //led blitzen lassen
+        }
 //******PROVISORISCH***************
     GRN_ON;
     GRN_ON;
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // Gaswert ermitteln
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+        GasMischanteil = PPM_in[EE_Parameter.Kanalbelegung[K_GAS]] + 120;
-        GasMischanteil = PPM_in[EE_Parameter.Kanalbelegung[K_GAS]] + 120;
+    if(GasMischanteil > MAX_GAS - 20) GasMischanteil = MAX_GAS - 20;
 //Salvo 13.10.2007 langsame Gasreduktion bei Unterspannung. Als Ausgangswert wird der bei UBAT=k gemessen Mittelwert genommen
-// und dieser dann langsam zwangsweise reduziert
-        ANALOG_OFF; // ADC ausschalten, damit die Werte sich nicht während der Berechnung ändern
+// und dieser dann langsam zwangsweise reduziert
         if (UBat <= EE_Parameter.UnterspannungsWarnung - 2)     //Unterhalb der Piepser Schwelle aktivieren
+        {
                 if (ubat_cnt > 700)
+                {
                                 else gas_actual = GasMischanteil;
+                }
+                }
                 GasMischanteil = gas_actual;
+        }
-        ANALOG_ON;      // ADC einschalten
 // Salvo End
     if(GasMischanteil < 0) GasMischanteil = 0;
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // Empfang schlecht
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    if(SenderOkay < 100)
+        {
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // auf Nullwerte kalibrieren
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
                 if(PPM_in[EE_Parameter.Kanalbelegung[K_GIER]] > 75)  // Neutralwerte
+                    {
-                    unsigned char setting;
                     if(++delay_neutral > 200)  // nicht sofort
+                        {
                         GRN_OFF;
                         SetNeutral();
                         MotorenEin = 0;
                         delay_neutral = 0;
                         modell_fliegt = 0;
                         if(PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] > 70 || abs(PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]]) > 70)
+                        {
+                         unsigned char setting=1;
                          if(PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] > 70 && PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] < 70) setting = 1;
                          if(PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] > 70 && PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] > 70) setting = 2;
                          if(PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] < 70 && PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] > 70) setting = 3;
                          if(PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] <-70 && PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] > 70) setting = 4;
                          if(PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] <-70 && PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] < 70) setting = 5;
                          eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACTIVE_SET], setting);  // aktiven Datensatz merken
+                        }
                             ReadParameterSet(GetActiveParamSetNumber(), (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);
                                                         beeptime = 2000;
                                                         Delay_ms(500);
+                                                }
+                       }
+                    }
+                 else
+                if(PPM_in[EE_Parameter.Kanalbelegung[K_GIER]] < -75)  // ACC Neutralwerte speichern
+                    {
+                    if(++delay_neutral > 200)  // nicht sofort
+                        {
+                        GRN_OFF;
+                        eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACC_NICK],0xff); // Werte löschen
+                        MotorenEin = 0;
+                        delay_neutral = 0;
+                        modell_fliegt = 0;
+                        SetNeutral();
+                        eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACC_NICK],NeutralAccX / 256); // ACC-NeutralWerte speichern
+                        eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACC_NICK+1],NeutralAccX % 256); // ACC-NeutralWerte speichern
+                        eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACC_ROLL],NeutralAccY / 256);
+                        eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACC_ROLL+1],NeutralAccY % 256);
+                        eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACC_Z],(int)NeutralAccZ / 256);
+                        eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACC_Z+1],(int)NeutralAccZ % 256);
+                        Piep(GetActiveParamSetNumber());
+                        }
+                    }
                  else delay_neutral = 0;
+                }
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // Gas ist unten
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // neue Werte von der Funke
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  if(!NewPpmData-- || Notlandung)
+  {
+    int tmp_int;
     ParameterZuordnung();
     StickNick = PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] * EE_Parameter.Stick_P;
     StickNick += PPM_diff[EE_Parameter.Kanalbelegung[K_NICK]] * EE_Parameter.Stick_D;
     StickRoll = PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] * EE_Parameter.Stick_P;
     StickRoll += PPM_diff[EE_Parameter.Kanalbelegung[K_ROLL]] * EE_Parameter.Stick_D;
     StickGier = -PPM_in[EE_Parameter.Kanalbelegung[K_GIER]];
     GyroFaktor     = ((float)Parameter_Gyro_P + 10.0) / 256.0;
     IntegralFaktor = ((float) Parameter_Gyro_I) / 44000;
+#define KEY_VALUE (Parameter_UserParam1 * 4)  //(Poti3 * 8)
+if(DubWiseKeys[1]) beeptime = 10;
+    if(DubWiseKeys[1] & DUB_KEY_UP)    tmp_int = KEY_VALUE;   else
+    if(DubWiseKeys[1] & DUB_KEY_DOWN)  tmp_int = -KEY_VALUE;  else   tmp_int = 0;
+    ExternStickNick = (ExternStickNick * 7 + tmp_int) / 8;
+    if(DubWiseKeys[1] & DUB_KEY_LEFT)  tmp_int = KEY_VALUE; else
+    if(DubWiseKeys[1] & DUB_KEY_RIGHT) tmp_int = -KEY_VALUE; else tmp_int = 0;
+    ExternStickRoll = (ExternStickRoll * 7 + tmp_int) / 8;
+    if(DubWiseKeys[0] & 8)  ExternStickGier = 50;else
+    if(DubWiseKeys[0] & 4)  ExternStickGier =-50;else ExternStickGier = 0;
+    if(DubWiseKeys[0] & 2)  ExternHoehenValue++;
+    if(DubWiseKeys[0] & 16) ExternHoehenValue--;
+    StickNick += ExternStickNick / 8;
+    StickRoll += ExternStickRoll / 8;
+    StickGier += ExternStickGier;
     if(EE_Parameter.GlobalConfig & CFG_HEADING_HOLD) IntegralFaktor =  0;
     if(GyroFaktor < 0) GyroFaktor = 0;
     if(IntegralFaktor < 0) IntegralFaktor = 0;
     // greift in den Stick ein, um ungewolltes überschlagen zu verhindern
+      {
        StickRoll += 8 * EE_Parameter.Stick_P;
        if(IntegralRoll >  80000) StickRoll -= 16 * EE_Parameter.Stick_P;
+      }
+     }
-  }
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // Looping?
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-  if(((PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] > EE_Parameter.LoopThreshold) && EE_Parameter.LoopConfig & CFG_LOOP_LINKS) ||
+  if((PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] > EE_Parameter.LoopThreshold) && EE_Parameter.LoopConfig & CFG_LOOP_LINKS)  Looping_Links = 1;
-     ((PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] < -EE_Parameter.LoopThreshold) && EE_Parameter.LoopConfig & CFG_LOOP_RECHTS))
+  else
+   {
-    Looping_Roll = 1;
+     {
-    if(GasMischanteil > EE_Parameter.LoopGasLimit) GasMischanteil = EE_Parameter.LoopGasLimit;
+      if((PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] < (EE_Parameter.LoopThreshold - EE_Parameter.LoopHysterese))) Looping_Links = 0;
+     }
    }
+  if((PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] < -EE_Parameter.LoopThreshold) && EE_Parameter.LoopConfig & CFG_LOOP_RECHTS) Looping_Rechts = 1;
+   else
+   {
-   else Looping_Roll = 0;
+   if(Looping_Rechts) // Hysterese
+     {
+      if(PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] > -(EE_Parameter.LoopThreshold - EE_Parameter.LoopHysterese)) Looping_Rechts = 0;
+     }
+   }
-  if(((PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] > EE_Parameter.LoopThreshold) && EE_Parameter.LoopConfig & CFG_LOOP_OBEN) ||
+  if((PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] > EE_Parameter.LoopThreshold) && EE_Parameter.LoopConfig & CFG_LOOP_OBEN) Looping_Oben = 1;
-     ((PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] < -EE_Parameter.LoopThreshold) && EE_Parameter.LoopConfig & CFG_LOOP_UNTEN))
+  else
    {
+    if(Looping_Oben)  // Hysterese
+     {
+      if((PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] < (EE_Parameter.LoopThreshold - EE_Parameter.LoopHysterese))) Looping_Oben = 0;
+     }
+   }
+  if((PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] < -EE_Parameter.LoopThreshold) && EE_Parameter.LoopConfig & CFG_LOOP_UNTEN) Looping_Unten = 1;
+   else
+   {
+    if(Looping_Unten) // Hysterese
+     {
+      if(PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] > -(EE_Parameter.LoopThreshold - EE_Parameter.LoopHysterese)) Looping_Unten = 0;
+     }
+   }
+   if(Looping_Links || Looping_Rechts)   Looping_Roll = 1; else Looping_Roll = 0;
+   if(Looping_Oben  || Looping_Unten) {Looping_Nick = 1; Looping_Roll = 0; Looping_Links = 0; Looping_Rechts = 0;} else Looping_Nick = 0;
+  } // Ende neue Funken-Werte
-    Looping_Nick = 1;
+  if(Looping_Roll) beeptime = 100;
+  if(Looping_Roll || Looping_Nick)
     Looping_Roll = 0;
     if(GasMischanteil > EE_Parameter.LoopGasLimit) GasMischanteil = EE_Parameter.LoopGasLimit;
-   }
    else Looping_Nick = 0;
      GyroFaktor  = 0.1;
      IntegralFaktor = 0.005;
      Looping_Roll = 0;
      Looping_Nick = 0;
+    }
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-// Gyro-Drift kompensieren
+// Integrale auf ACC-Signal abgleichen
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-#define DRIFT_FAKTOR 3
+#define ABGLEICH_ANZAHL 256L
-    if(ZaehlMessungen >= 1000 / DRIFT_FAKTOR)
-        {
-        IntegralFehlerNick = IntegralNick2 - IntegralNick;
-        IntegralFehlerRoll = IntegralRoll2 - IntegralRoll;
-        ZaehlMessungen = 0;
-        if(IntegralFehlerNick > 500/DRIFT_FAKTOR)   AdNeutralNick++;
-        if(IntegralFehlerNick < -500/DRIFT_FAKTOR)  AdNeutralNick--;
-        if(IntegralFehlerRoll > 500/DRIFT_FAKTOR)   AdNeutralRoll++;
-        if(IntegralFehlerRoll < -500/DRIFT_FAKTOR)  AdNeutralRoll--;
+ MittelIntegralNick  += IntegralNick;    // Für die Mittelwertbildung aufsummieren
+ MittelIntegralRoll  += IntegralRoll;
+ MittelIntegralNick2 += IntegralNick2;
+ MittelIntegralRoll2 += IntegralRoll2;
+ if(Looping_Nick || Looping_Roll)
+  {
+    IntegralAccNick = 0;
-        ANALOG_OFF; // ADC ausschalten, damit die Werte sich nicht während der Berechnung ändern
+    IntegralAccRoll = 0;
-        Mess_IntegralNick2 = IntegralNick;
+    MittelIntegralNick = 0;
-        Mess_IntegralRoll2 = IntegralRoll;
-        Mess_Integral_Gier2 = Integral_Gier;
+    MittelIntegralRoll = 0;
+    MittelIntegralNick2 = 0;
-//Salvo Ersatzkompass Ueberlauf korrigieren
+    MittelIntegralRoll2 = 0;
+    Mess_IntegralNick2 = Mess_IntegralNick;
-                if (GyroKomp_Int >= ((long)360 * GYROKOMP_INC_GRAD_DEFAULT)) GyroKomp_Int = GyroKomp_Int - (GYROKOMP_INC_GRAD_DEFAULT *(long)360); //neu ab 3.11.2007
+    Mess_IntegralRoll2 = Mess_IntegralRoll;
-                if (GyroKomp_Int < 0) GyroKomp_Int = GyroKomp_Int + (GYROKOMP_INC_GRAD_DEFAULT *(long)360); //neu ab 3.11.2007
+    ZaehlMessungen = 0;
-                ANALOG_ON;      // ADC einschalten
+    LageKorrekturNick = 0;
-                ROT_OFF;
-// Salvo End
     LageKorrekturRoll = 0;
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  }
 // Integrale auf ACC-Signal abgleichen
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  if(!Looping_Nick && !Looping_Roll)
-  if(IntegralFaktor && !Looping_Nick && !Looping_Roll)
   {
-    tmp_long = (long)(IntegralNick / EE_Parameter.GyroAccFaktor - (long)Mittelwert_AccNick);
+   long tmp_long, tmp_long2;
-    if(labs(Mittelwert_AccNick) < 200) tmp_long /= 8;
-    else tmp_long /= 16;
+    tmp_long = (long)(IntegralNick / EE_Parameter.GyroAccFaktor - (long)Mittelwert_AccNick);
-    tmp_long2 = (long)(IntegralRoll / EE_Parameter.GyroAccFaktor - (long)Mittelwert_AccRoll);
-    if(labs(Mittelwert_AccRoll) < 200) tmp_long2 /= 8;
+    tmp_long /= 16;
-    else tmp_long2 /= 16;
+    tmp_long2 = (long)(IntegralRoll / EE_Parameter.GyroAccFaktor - (long)Mittelwert_AccRoll);
     tmp_long2 /= 16;
- #define AUSGLEICH 500
+ #define AUSGLEICH 32 //(Parameter_UserParam1 / 2)
     if(tmp_long >  AUSGLEICH)  tmp_long  = AUSGLEICH;
+    if(tmp_long < -AUSGLEICH)  tmp_long  =-AUSGLEICH;
+    if(tmp_long2 > AUSGLEICH)  tmp_long2 = AUSGLEICH;
+    if(tmp_long2 <-AUSGLEICH)  tmp_long2 =-AUSGLEICH;
+    Mess_IntegralNick -= tmp_long;
+    Mess_IntegralRoll -= tmp_long2;
+  }
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ if(ZaehlMessungen >= ABGLEICH_ANZAHL)
+ {
+  static int cnt = 0;
+  static char last_n_p,last_n_n,last_r_p,last_r_n;
+  static long MittelIntegralNick_Alt,MittelIntegralRoll_Alt;
+  if(!Looping_Nick && !Looping_Roll)
+  {
+    MittelIntegralNick  /= ABGLEICH_ANZAHL;
+    MittelIntegralRoll  /= ABGLEICH_ANZAHL;
+        IntegralAccNick = (EE_Parameter.GyroAccFaktor * IntegralAccNick) / ABGLEICH_ANZAHL;
+        IntegralAccRoll = (EE_Parameter.GyroAccFaktor * IntegralAccRoll) / ABGLEICH_ANZAHL;
+    IntegralAccZ    = IntegralAccZ / ABGLEICH_ANZAHL;
+#define MAX_I 0//(Poti2/10)
+// Nick ++++++++++++++++++++++++++++++++++++++++++++++++
+    IntegralFehlerNick = (long)(MittelIntegralNick - (long)IntegralAccNick);
+    ausgleichNick = IntegralFehlerNick / EE_Parameter.GyroAccAbgleich;
+    LageKorrekturNick = ausgleichNick / ABGLEICH_ANZAHL;
+// Roll ++++++++++++++++++++++++++++++++++++++++++++++++
+    IntegralFehlerRoll = (long)(MittelIntegralRoll - (long)IntegralAccRoll);
+    ausgleichRoll = IntegralFehlerRoll / EE_Parameter.GyroAccAbgleich;
+    LageKorrekturRoll = ausgleichRoll / ABGLEICH_ANZAHL;
+//    Mess_IntegralNick -= ausgleichNick;
+//    Mess_IntegralRoll -= ausgleichRoll;
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// Gyro-Drift ermitteln
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+    MittelIntegralNick2 /= ABGLEICH_ANZAHL;
+    MittelIntegralRoll2 /= ABGLEICH_ANZAHL;
+//    tmp_long  = (long)(MittelIntegralNick2 - (long)IntegralAccNick);
+//    tmp_long2 = (long)(MittelIntegralRoll2 - (long)IntegralAccRoll);
+    tmp_long  = IntegralNick2 - IntegralNick;
+    tmp_long2 = IntegralRoll2 - IntegralRoll;
+    //DebugOut.Analog[25] = MittelIntegralRoll2 / 26;
+    IntegralFehlerNick = tmp_long;
+    IntegralFehlerRoll = tmp_long2;
+    Mess_IntegralNick2 -= IntegralFehlerNick;
+    Mess_IntegralRoll2 -= IntegralFehlerRoll;
+//    IntegralFehlerNick = (IntegralFehlerNick * 1 + tmp_long) / 2;
+//    IntegralFehlerRoll = (IntegralFehlerRoll * 1 + tmp_long2) / 2;
+//Salvo Ersatzkompass Ueberlauf korrigieren
+                if (GyroKomp_Int >= ((long)360 * GYROKOMP_INC_GRAD_DEFAULT)) GyroKomp_Int = GyroKomp_Int - (GYROKOMP_INC_GRAD_DEFAULT *(long)360); //neu ab 3.11.2007
+                if (GyroKomp_Int < 0) GyroKomp_Int = GyroKomp_Int + (GYROKOMP_INC_GRAD_DEFAULT *(long)360); //neu ab 3.11.2007
+                ROT_OFF;
+// Salvo End
+/*DebugOut.Analog[17] = IntegralAccNick / 26;
+DebugOut.Analog[18] = IntegralAccRoll / 26;
+DebugOut.Analog[19] = IntegralFehlerNick;// / 26;
+DebugOut.Analog[20] = IntegralFehlerRoll;// / 26;
+DebugOut.Analog[21] = MittelIntegralNick / 26;
+DebugOut.Analog[22] = MittelIntegralRoll / 26;
+DebugOut.Analog[28] = ausgleichNick;
+DebugOut.Analog[29] = ausgleichRoll;
+DebugOut.Analog[30] = LageKorrekturRoll * 10;
+*/
+#define FEHLER_LIMIT  (ABGLEICH_ANZAHL * 4)
+#define FEHLER_LIMIT2 (ABGLEICH_ANZAHL * 16)
+#define BEWEGUNGS_LIMIT 20000
+// Nick +++++++++++++++++++++++++++++++++++++++++++++++++
+        cnt = 1;// + labs(IntegralFehlerNick) / 4096;
+        if(labs(MittelIntegralNick_Alt - MittelIntegralNick) < BEWEGUNGS_LIMIT)
+        {
+        if(IntegralFehlerNick >  FEHLER_LIMIT2)
+         {
+           if(last_n_p)
+           {
+            cnt += labs(IntegralFehlerNick) / FEHLER_LIMIT2;
+            ausgleichNick = IntegralFehlerNick / 8;
+            if(ausgleichNick > 5000) ausgleichNick = 5000;
+            LageKorrekturNick += ausgleichNick / ABGLEICH_ANZAHL;
+           }
+           else last_n_p = 1;
+         } else  last_n_p = 0;
+        if(IntegralFehlerNick < -FEHLER_LIMIT2)
+         {
+           if(last_n_n)
+            {
+             cnt += labs(IntegralFehlerNick) / FEHLER_LIMIT2;
+             ausgleichNick = IntegralFehlerNick / 8;
+             if(ausgleichNick < -5000) ausgleichNick = -5000;
+             LageKorrekturNick += ausgleichNick / ABGLEICH_ANZAHL;
+            }
+           else last_n_n = 1;
+         } else  last_n_n = 0;
+        } else cnt = 0;
+        if(cnt > EE_Parameter.Driftkomp) cnt = EE_Parameter.Driftkomp;
+        if(IntegralFehlerNick >  FEHLER_LIMIT)   AdNeutralNick += cnt;
+        if(IntegralFehlerNick < -FEHLER_LIMIT)   AdNeutralNick -= cnt;
+// Roll +++++++++++++++++++++++++++++++++++++++++++++++++
+        cnt = 1;// + labs(IntegralFehlerNick) / 4096;
+        ausgleichRoll = 0;
+        if(labs(MittelIntegralRoll_Alt - MittelIntegralRoll) < BEWEGUNGS_LIMIT)
+        {
+        if(IntegralFehlerRoll >  FEHLER_LIMIT2)
+         {
+           if(last_r_p)
+           {
+            cnt += labs(IntegralFehlerRoll) / FEHLER_LIMIT2;
+            ausgleichRoll = IntegralFehlerRoll / 8;
+            if(ausgleichRoll > 5000) ausgleichRoll = 5000;
+            LageKorrekturRoll += ausgleichRoll / ABGLEICH_ANZAHL;
+           }
+           else last_r_p = 1;
+         } else  last_r_p = 0;
+        if(IntegralFehlerRoll < -FEHLER_LIMIT2)
+         {
+           if(last_r_n)
+           {
+            cnt += labs(IntegralFehlerRoll) / FEHLER_LIMIT2;
+            ausgleichRoll = IntegralFehlerRoll / 8;
+            if(ausgleichRoll < -5000) ausgleichRoll = -5000;
+            LageKorrekturRoll += ausgleichRoll / ABGLEICH_ANZAHL;
+           }
+           else last_r_n = 1;
+         } else  last_r_n = 0;
+        } else
+        {
+         cnt = 0;
+        }
+//DebugOut.Analog[27] = ausgleichRoll;
+        if(cnt > EE_Parameter.Driftkomp) cnt = EE_Parameter.Driftkomp;
+//if(cnt > 1) beeptime = 50;
+        if(IntegralFehlerRoll >  FEHLER_LIMIT)   AdNeutralRoll += cnt;
-    if(tmp_long < -AUSGLEICH)  tmp_long  =-AUSGLEICH;
+        if(IntegralFehlerRoll < -FEHLER_LIMIT)   AdNeutralRoll -= cnt;
-    if(tmp_long2 > AUSGLEICH)  tmp_long2 = AUSGLEICH;
+//DebugOut.Analog[23] = AdNeutralNick;//10*(AdNeutralNick - StartNeutralNick);
-    if(tmp_long2 <-AUSGLEICH)  tmp_long2 =-AUSGLEICH;
+//DebugOut.Analog[24] = 10*(AdNeutralRoll - StartNeutralRoll);
   }
   else
+  {
-   tmp_long = 0;
+   LageKorrekturRoll = 0;
+   LageKorrekturNick = 0;
+  }
-   tmp_long2 = 0;
+  if(!IntegralFaktor) { LageKorrekturRoll = 0; LageKorrekturNick = 0;} // z.B. bei HH
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++
+   MittelIntegralNick_Alt = MittelIntegralNick;
+   MittelIntegralRoll_Alt = MittelIntegralRoll;
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++
+    IntegralAccNick = 0;
+    IntegralAccRoll = 0;
+    IntegralAccZ = 0;
+    MittelIntegralNick = 0;
+    MittelIntegralRoll = 0;
+    MittelIntegralNick2 = 0;
-  }
- ANALOG_OFF; // ADC ausschalten, damit die Werte sich nicht während der Berechnung ändern
- // Salvo 1.9.2007 Volle Korrektur nur wenn waagrechte Lage, sonst abgeschawecht *****************
-        w = (abs(Mittelwert_AccNick));
-        v = (abs(Mittelwert_AccRoll));
-        if ((w  < ACC_WAAGRECHT_LIMIT) && (v < ACC_WAAGRECHT_LIMIT))
-        {
-        Mess_IntegralNick -= tmp_long;
-        Mess_IntegralRoll -= tmp_long2;
-        }
-        else if ((w  < 2 * ACC_WAAGRECHT_LIMIT) && (v < 2 * ACC_WAAGRECHT_LIMIT))
-        {
-        Mess_IntegralNick -= tmp_long/2; //Vorher 8
-        Mess_IntegralRoll -= tmp_long2/2;
-        }
-        else if ((w  < 4 * ACC_WAAGRECHT_LIMIT) && (v < 4 * ACC_WAAGRECHT_LIMIT))
-        {
-        Mess_IntegralNick -= tmp_long/4;
-        Mess_IntegralRoll -= tmp_long2/4;
-        }
-        else
-        {
-        Mess_IntegralNick -= tmp_long/8;
+    MittelIntegralRoll2 = 0;
-        Mess_IntegralRoll -= tmp_long2/8;
+    ZaehlMessungen = 0;
+ }
 // Salvo End ***********************
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 //  Gieren
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
     if(abs(StickGier) > 20) // war 35
+     {
       if(!(EE_Parameter.GlobalConfig & CFG_KOMPASS_FIX)) NeueKompassRichtungMerken = 1;
+     }
-    tmp_int  = EE_Parameter.Gier_P * (StickGier * abs(StickGier)) / 512; // expo  y = ax + bx²
+    tmp_int  = (long) EE_Parameter.Gier_P * ((long)StickGier * abs(StickGier)) / 512L; // expo  y = ax + bx²
     tmp_int += (EE_Parameter.Gier_P * StickGier) / 4;
-    sollGier = tmp_int;
-    Mess_Integral_Gier -= tmp_int;
-    if(Mess_Integral_Gier > 25000) Mess_Integral_Gier = 25000;  // begrenzen
-    if(Mess_Integral_Gier <-25000) Mess_Integral_Gier =-25000;
- // Salvo Gewolltes Gieren ignorieren 30.8.2007 **********************
+    sollGier = tmp_int;
-    Mess_Integral_Gier2  -= tmp_int;
+    Mess_Integral_Gier -= tmp_int;
-// Salvo End *************************
+    if(Mess_Integral_Gier > 50000) Mess_Integral_Gier = 50000;  // begrenzen
- ANALOG_ON;     // ADC einschalten
+    if(Mess_Integral_Gier <-50000) Mess_Integral_Gier =-50000;
 // Salvo Ersatzkompass  26.9.2007 **********************
         if ((Kompass_Neuer_Wert > 0))
+        {
            Kompass_Neuer_Wert = 0;
            w = (abs(Mittelwert_AccNick));
            v = (abs(Mittelwert_AccRoll));
-           if  ((w  < ACC_WAAGRECHT_LIMIT) && (v < ACC_WAAGRECHT_LIMIT)) //Ersatzkompass nur mit Magnetkompass aktualisieren wenn alles ok
            if  ((w  < ACC_WAAGRECHT_LIMIT) && (v < ACC_WAAGRECHT_LIMIT)) //Ersatzkompass nur mit Magnetkompass aktualisieren wenn alles ok
                 if  ((abs(KompassValue - Kompass_Value_Old)) <= 5) // Aufeinanderfolgende Werte duerfen nur minimal abweichen
                 if  ((abs(KompassValue - Kompass_Value_Old)) <= 5) // Aufeinanderfolgende Werte duerfen nur minimal abweichen
                   ANALOG_OFF; // ADC ausschalten, damit die Werte sich nicht während der Berechnung ändern
                   magkompass_ok = 1; // Flag dass Magnetkompass stabil arbeitet
+                  {
                    ++GyroKomp_Int;
+                  }
                   if (GyroKomp_Int < 0)  GyroKomp_Int = GyroKomp_Int + 360;
                   GyroKomp_Int = (GyroKomp_Int%360) * GYROKOMP_INC_GRAD_DEFAULT; // An Magnetkompasswert annaehern
-                  ANALOG_ON;    // ADC einschalten
                  }
+           }
            else magkompass_ok = 0;
+        }
 // Salvo End *************************
                         if ( gps_cmd == GPS_CMD_REQ_HOME) gps_cmd = GPS_CMD_STOP; // erst mal stoppen, denn altes Kommando wurde noch nicht beendet
                         else gps_cmd = GPS_CMD_REQ_HOLD;
                         n= GPS_CRTL(gps_cmd);
+                }
+        }
+        else
+        {
+                if (gps_cmd != GPS_CMD_STOP)
+                {
+                        gps_cmd = GPS_CMD_STOP;
-        else (n= GPS_CRTL(GPS_CMD_STOP)); //GPS Lageregelung beenden
+                        n= GPS_CRTL(gps_cmd); //GPS Lageregelung beenden
+                }
+        }
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 //  Kompass
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // Salvo End
        w = (w * Parameter_KompassWirkung) / 64;           // auf die Wirkung normieren
        w = Parameter_KompassWirkung - w;                  // Wirkung ggf drosseln
        if(w > 0)
+        {
-          ANALOG_OFF; // ADC ausschalten, damit die Werte sich nicht während der Berechnung ändern
 // Salvo Kompasssteuerung **********************
                  if (magkompass_ok > 0) Mess_Integral_Gier += (KompassRichtung * w) / 32;  // nach Kompass ausrichten
 // Salvo End
-          ANALOG_ON;  // ADC einschalten
+        }
+     }
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 //  Debugwerte zuordnen
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
   if(!TimerWerteausgabe--)
+   {
-    TimerWerteausgabe = 49;
+    TimerWerteausgabe = 24;
     DebugOut.Analog[0] = IntegralNick / EE_Parameter.GyroAccFaktor;
     DebugOut.Analog[1] = IntegralRoll / EE_Parameter.GyroAccFaktor;
     DebugOut.Analog[2] = Mittelwert_AccNick;
     DebugOut.Analog[3] = Mittelwert_AccRoll;
     DebugOut.Analog[4] = MesswertGier;
     DebugOut.Analog[5] = HoehenWert;
-    DebugOut.Analog[6] = (Mess_Integral_Hoch / 512);
+    DebugOut.Analog[6] =(Mess_Integral_Hoch / 512);
     DebugOut.Analog[8] = KompassValue;
         DebugOut.Analog[9] = GyroKomp_Int/GYROKOMP_INC_GRAD_DEFAULT;
     if(Looping_Roll) MesswertRoll = MesswertRoll * GyroFaktor;
     else             MesswertRoll = IntegralRoll * IntegralFaktor + MesswertRoll * GyroFaktor;
 //    MesswertGier = MesswertGier * (GyroFaktor/2) + Integral_Gier * IntegralFaktor;
     MesswertGier = MesswertGier * (GyroFaktor) + Integral_Gier * IntegralFaktor/2;
+//DebugOut.Analog[28] = MesswertRoll;
+DebugOut.Analog[25] = IntegralRoll * IntegralFaktor;
+DebugOut.Analog[31] = StickRoll;// / (26*IntegralFaktor);
     // Maximalwerte abfangen
     #define MAX_SENSOR  2048
     if(MesswertNick >  MAX_SENSOR) MesswertNick =  MAX_SENSOR;
     if(MesswertNick < -MAX_SENSOR) MesswertNick = -MAX_SENSOR;
       else
         HoehenReglerAktiv = 1;
+    }
     else
+    {
-     SollHoehe = Parameter_MaxHoehe * EE_Parameter.Hoehe_Verstaerkung - 20;
+     SollHoehe = ((int) ExternHoehenValue + (int) Parameter_MaxHoehe) * (int)EE_Parameter.Hoehe_Verstaerkung - 20;
      HoehenReglerAktiv = 1;
+    }
     if(Notlandung) SollHoehe = 0;
+  }
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // + Mischer und PI-Regler
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
   DebugOut.Analog[7] = GasMischanteil;
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // Gier-Anteil
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 #define MUL_G  1.0
     GierMischanteil = MesswertGier - sollGier;     // Regler für Gier
 //GierMischanteil = 0;
-    if(GierMischanteil > (MUL_G * GasMischanteil))  GierMischanteil = MUL_G * GasMischanteil;
+    if(GierMischanteil > (GasMischanteil / 2)) GierMischanteil = GasMischanteil / 2;
-    if(GierMischanteil < -(MUL_G * GasMischanteil)) GierMischanteil = -(MUL_G * GasMischanteil);
+    if(GierMischanteil < -(GasMischanteil / 2)) GierMischanteil = -(GasMischanteil / 2);
-    if(GierMischanteil > 100)  GierMischanteil = 100;
+    if(GierMischanteil > ((MAX_GAS - GasMischanteil))) GierMischanteil = ((MAX_GAS - GasMischanteil));
-    if(GierMischanteil < -100) GierMischanteil = -100;
+    if(GierMischanteil < -((MAX_GAS - GasMischanteil))) GierMischanteil = -((MAX_GAS - GasMischanteil));
     if(GasMischanteil < 20) GierMischanteil = 0;
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // Nick-Achse
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+    DiffNick = MesswertNick - (StickNick - GPS_Nick);   // Differenz bestimmen
-    DiffNick = Kp * (MesswertNick - (StickNick - GPS_Nick));    // Differenz bestimmen
+    if(IntegralFaktor) SummeNick += IntegralNick * IntegralFaktor - (StickNick - GPS_Nick); // I-Anteil bei Winkelregelung
-    SummeNick += DiffNick;                                   // I-Anteil
+    else  SummeNick += DiffNick; // I-Anteil bei HH
-    if(SummeNick > 0) SummeNick-= (abs(SummeNick)/256 + 1); else SummeNick += abs(SummeNick)/256 + 1;
+    if(SummeNick > 0) SummeNick-= 2 ; else SummeNick += 2 ;
     if(SummeNick >  16000) SummeNick =  16000;
     if(SummeNick < -16000) SummeNick = -16000;
-    pd_ergebnis = DiffNick;// + Ki * SummeNick; // PI-Regler für Nick
+    pd_ergebnis = DiffNick + Ki * SummeNick; // PI-Regler für Nick
-    // Motor Vorn
-#define MUL  2
+    // Motor Vorn
+    tmp_int = (long)((long)Parameter_DynamicStability * (long)(GasMischanteil + abs(GierMischanteil)/2)) / 64;
-    if(pd_ergebnis >  MUL * (GasMischanteil + abs(GierMischanteil))) pd_ergebnis =  MUL * (GasMischanteil + abs(GierMischanteil));
+    if(pd_ergebnis >  tmp_int) pd_ergebnis =  tmp_int;
-    if(pd_ergebnis < -MUL * (GasMischanteil + abs(GierMischanteil))) pd_ergebnis = -MUL * (GasMischanteil + abs(GierMischanteil));
+    if(pd_ergebnis < -tmp_int) pd_ergebnis = -tmp_int;
     motorwert = GasMischanteil + pd_ergebnis + GierMischanteil;   // Mischer
         if ((motorwert < 0)) motorwert = 0;
         if (motorwert < MIN_GAS)            motorwert = MIN_GAS;
         Motor_Hinten = motorwert;
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // Roll-Achse
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-        DiffRoll = Kp * (MesswertRoll - (StickRoll  - GPS_Roll));       // Differenz bestimmen
+        DiffRoll = MesswertRoll - (StickRoll  - GPS_Roll);      // Differenz bestimmen
+    if(IntegralFaktor) SummeRoll += IntegralRoll * IntegralFaktor - (StickRoll  - GPS_Roll);// I-Anteil bei Winkelregelung
-        SummeRoll += DiffRoll;                                                              // I-Anteil
+    else                 SummeRoll += DiffRoll;  // I-Anteil bei HH
-    if(SummeRoll > 0) SummeRoll-= (abs(SummeRoll)/256 + 1); else SummeRoll += abs(SummeRoll)/256 + 1;
+    if(SummeRoll > 0) SummeRoll-= 2 ; else SummeRoll += 2 ;
     if(SummeRoll >  16000) SummeRoll =  16000;
     if(SummeRoll < -16000) SummeRoll = -16000;
-    pd_ergebnis = DiffRoll;// + Ki * SummeRoll; // PI-Regler für Roll
+    pd_ergebnis = DiffRoll + Ki * SummeRoll;    // PI-Regler für Roll
-    if(pd_ergebnis >  MUL * (GasMischanteil + abs(GierMischanteil))) pd_ergebnis =  MUL * (GasMischanteil + abs(GierMischanteil));
+    tmp_int = (long)((long)Parameter_DynamicStability * (long)(GasMischanteil + abs(GierMischanteil)/2)) / 64;
+    if(pd_ergebnis >  tmp_int) pd_ergebnis =  tmp_int;
-    if(pd_ergebnis < -MUL * (GasMischanteil + abs(GierMischanteil))) pd_ergebnis = -MUL * (GasMischanteil + abs(GierMischanteil));
+    if(pd_ergebnis < -tmp_int) pd_ergebnis = -tmp_int;
     // Motor Links
     motorwert = GasMischanteil + pd_ergebnis - GierMischanteil;
         if ((motorwert < 0)) motorwert = 0;
         else if(motorwert > MAX_GAS)            motorwert = MAX_GAS;
         if (motorwert < MIN_GAS)            motorwert = MIN_GAS;

Subversion Repositories FlightCtrl

(root)/branches/salvo_gps/Basis_v0067g/trunk/fc.c @ 534 - Rev 528 → 529