WebSVN - FlightCtrl - Diff - Rev 885 and 886 - /branches/V0.69k Code Redesign killagreg/fc.c

 // +  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)
 // +  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 // +  POSSIBILITY OF SUCH DAMAGE.
 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#include <stdlib.h>
+#include <avr/io.h>
 #include "main.h"
+#include "eeprom.h"
+#include "timer0.h"
+#include "_Settings.h"
+#include "analog.h"
+#include "fc.h"
+#include "uart.h"
+#include "rc.h"
+#include "twimaster.h"
+#include "timer2.h"
+#ifdef USE_KILLAGREG
+#include "mm3.h"
+#include "gps.h"
+#endif
+#if  !defined (USE_KILLAGREG)  && !defined (USE_NAVICTRL)
+#include "mk3mag.h"
+#endif
+#include "led.h"
+volatile uint16_t I2CTimeout = 100;
+// gyro readings
+volatile int16_t Reading_GyroPitch, Reading_GyroRoll, Reading_GyroYaw;
+// gyro neutral readings
+volatile int16_t AdNeutralPitch = 0, AdNeutralRoll = 0, AdNeutralYaw = 0;
+volatile int16_t StartNeutralRoll = 0, StartNeutralPitch = 0;
+// mean accelerations
-#include "eeprom.c"
+volatile int16_t Mean_AccPitch, Mean_AccRoll, Mean_AccTop;
-unsigned char h,m,s;
-volatile unsigned int I2CTimeout = 100;
-volatile int MesswertNick,MesswertRoll,MesswertGier;
-volatile int AdNeutralNick = 0,AdNeutralRoll = 0,AdNeutralGier = 0,StartNeutralRoll = 0,StartNeutralNick = 0;
-volatile int Mittelwert_AccNick, Mittelwert_AccRoll,Mittelwert_AccHoch, NeutralAccX=0, NeutralAccY=0;
+// neutral acceleration readings
+volatile int16_t NeutralAccX=0, NeutralAccY=0;
-int NaviAccNick, NaviAccRoll,NaviCntAcc = 0;
+volatile float NeutralAccZ = 0;
-volatile float NeutralAccZ = 0;
-unsigned char CosinusNickWinkel = 0, CosinusRollWinkel = 0;
+// attitude gyro integrals
+volatile int32_t IntegralPitch = 0,IntegralPitch2 = 0;
+volatile int32_t IntegralRoll = 0,IntegralRoll2 = 0;
-long IntegralNick = 0,IntegralNick2 = 0;
+volatile int32_t IntegralYaw = 0;
-long IntegralRoll = 0,IntegralRoll2 = 0;
+volatile int32_t Reading_IntegralGyroPitch = 0, Reading_IntegralGyroPitch2 = 0;
-long IntegralAccNick = 0,IntegralAccRoll = 0,IntegralAccZ = 0;
+volatile int32_t Reading_IntegralGyroRoll = 0,  Reading_IntegralGyroRoll2 = 0;
-long Integral_Gier = 0;
+volatile int32_t Reading_IntegralGyroYaw = 0;
+volatile int32_t MeanIntegralPitch;
-long Mess_IntegralNick = 0,Mess_IntegralNick2 = 0;
+volatile int32_t MeanIntegralRoll;
-long Mess_IntegralRoll = 0,Mess_IntegralRoll2 = 0;
-long Mess_Integral_Gier = 0,Mess_Integral_Gier2 = 0;
+// attitude acceleration integrals
+volatile int32_t IntegralAccPitch = 0, IntegralAccRoll = 0;
-long MittelIntegralNick,MittelIntegralRoll,MittelIntegralNick2,MittelIntegralRoll2;
+volatile int32_t Reading_Integral_Top = 0;
-volatile long Mess_Integral_Hoch = 0;
+// compass course
-volatile int  KompassValue = 0;
+volatile int16_t CompassHeading = -1; // negative angle indicates invalid data.
-volatile int  KompassStartwert = 0;
+volatile int16_t CompassCourse = -1;
-volatile int  KompassRichtung = 0;
+volatile int16_t CompassOffCourse = 0;
-unsigned int  KompassSignalSchlecht = 500;
+volatile uint8_t CompassCalState = 0;
-unsigned char  MAX_GAS,MIN_GAS;
+uint8_t FunnelCourse = 0;
-unsigned char Notlandung = 0;
+uint16_t BadCompassHeading = 500;
+int32_t YawGyroHeading;
+int16_t YawGyroDrift;
-unsigned char HoehenReglerAktiv = 0;
+int16_t NaviAccPitch = 0, NaviAccRoll = 0, NaviCntAcc = 0;
-unsigned char TrichterFlug = 0;
-long Umschlag180Nick = 250000L, Umschlag180Roll = 250000L;
+// flags
-long  ErsatzKompass;
+uint8_t MotorsOn = 0;
+uint8_t EmergencyLanding = 0;
+uint16_t Model_Is_Flying = 0;
-int   ErsatzKompassInGrad; // Kompasswert in Grad
+int32_t TurnOver180Pitch = 250000L, TurnOver180Roll = 250000L;
-int   GierGyroFehler = 0;
+float Gyro_P_Factor;
-float GyroFaktor;
+float Gyro_I_Factor;
-float IntegralFaktor;
+volatile int16_t  DiffPitch, DiffRoll;
+int16_t  Poti1 = 0, Poti2 = 0, Poti3 = 0, Poti4 = 0, Poti5 = 0, Poti6 = 0, Poti7 = 0, Poti8 = 0;
-volatile int  DiffNick,DiffRoll;
+// setpoints for motors
-int  Poti1 = 0, Poti2 = 0, Poti3 = 0, Poti4 = 0;
+volatile uint8_t Motor_Front, Motor_Rear, Motor_Right, Motor_Left;
-volatile unsigned char Motor_Vorne,Motor_Hinten,Motor_Rechts,Motor_Links, Count;
-volatile unsigned char SenderOkay = 0;
+// stick values derived by rc channels readings
+int16_t StickPitch = 0, StickRoll = 0, StickYaw = 0, StickThrust = 0;
+int16_t GPS_Pitch = 0, GPS_Roll = 0;
+int16_t MaxStickPitch = 0, MaxStickRoll = 0;
+// stick values derived by uart inputs
+int16_t ExternStickPitch = 0, ExternStickRoll = 0, ExternStickYaw = 0, ExternHeightValue = -20;
-int StickNick = 0,StickRoll = 0,StickGier = 0,StickGas = 0;
-char MotorenEin = 0;
+int16_t ReadingHeight = 0;
-int HoehenWert = 0;
+int16_t SetPointHeight = 0;
-int SollHoehe = 0;
+int16_t AttitudeCorrectionRoll = 0, AttitudeCorrectionPitch = 0;
-int LageKorrekturRoll = 0,LageKorrekturNick = 0;
+float Ki =  FACTOR_I;
-float Ki =  FAKTOR_I;
-unsigned char Looping_Nick = 0,Looping_Roll = 0;
+uint8_t Looping_Pitch = 0, Looping_Roll = 0;
-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
+uint8_t Looping_Left = 0, Looping_Right = 0, Looping_Down = 0, Looping_Top = 0;
-unsigned char Parameter_Hoehe_ACC_Wirkung = 58; // Wert : 0-250
+fc_param_t FCParam = {48,251,16,58,64,150,150,2,10,0,0,0,0,0,0,0,0,100,70,0,0,100};
-unsigned char Parameter_KompassWirkung = 64;    // Wert : 0-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_UserParam5 = 0;
-unsigned char Parameter_UserParam6 = 0;
-unsigned char Parameter_UserParam7 = 0;
-unsigned char Parameter_UserParam8 = 0;
-unsigned char Parameter_ServoNickControl = 100;
-unsigned char Parameter_LoopGasLimit = 70;
-unsigned char Parameter_AchsKopplung1 = 0;
-unsigned char Parameter_AchsGegenKopplung1 = 0;
-unsigned char Parameter_DynamicStability = 100;
-struct mk_param_struct EE_Parameter;
-signed int ExternStickNick = 0,ExternStickRoll = 0,ExternStickGier = 0, ExternHoehenValue = -20;
-int MaxStickNick = 0,MaxStickRoll = 0;
-unsigned int  modell_fliegt = 0;
+/*  Creates numbeeps beeps at the speaker                               */
+/************************************************************************/
-void Piep(unsigned char Anzahl)
+void Beep(uint8_t numbeeps)
 {
- while(Anzahl--)
+        while(numbeeps--)
- {
+        {
-  if(MotorenEin) return; //auf keinen Fall im Flug!
+                if(MotorsOn) return; //auf keinen Fall im Flug!
+                BeepTime = 100; // 0.1 second
+                Delay_ms(250); // blocks 250 ms as pause to next beep,
-  beeptime = 100;
+                // this will block the flight control loop,
-  Delay_ms(250);
+                // therefore do not use this funktion if motors are running
- }
+        }
 }
 /************************************************************************/
-//############################################################################
-//  Nullwerte ermitteln
+/*  Neutral Readings                                                    */
-void SetNeutral(void)
+/************************************************************************/
-//############################################################################
+void SetNeutral(void)
+{
         NeutralAccX = 0;
         NeutralAccY = 0;
         NeutralAccZ = 0;
-    AdNeutralNick = 0;
+    AdNeutralPitch = 0;
         AdNeutralRoll = 0;
-        AdNeutralGier = 0;
+        AdNeutralYaw = 0;
-    Parameter_AchsKopplung1 = 0;
+    FCParam.Yaw_PosFeedback = 0;
-    Parameter_AchsGegenKopplung1 = 0;
+    FCParam.Yaw_NegFeedback = 0;
-    CalibrierMittelwert();
+    CalibMean();
     Delay_ms_Mess(100);
-        CalibrierMittelwert();
+        CalibMean();
-    if((EE_Parameter.GlobalConfig & CFG_HOEHENREGELUNG))  // Höhenregelung aktiviert?
+    if((ParamSet.GlobalConfig & CFG_HEIGHT_CONTROL))  // Height Control activated?
-     {
-      if((MessLuftdruck > 950) || (MessLuftdruck < 750)) SucheLuftruckOffset();
+    {
-     }
+                if((ReadingAirPressure > 950) || (ReadingAirPressure < 750)) SearchAirPressureOffset();
+    }
-     AdNeutralNick= AdWertNick;
+        AdNeutralPitch = AdValueGyrPitch;
-         AdNeutralRoll= AdWertRoll;
+        AdNeutralRoll  = AdValueGyrRoll;
-         AdNeutralGier= AdWertGier;
+        AdNeutralYaw   = AdValueGyrYaw;
-     StartNeutralRoll = AdNeutralRoll;
+        StartNeutralRoll  = AdNeutralRoll;
-     StartNeutralNick = AdNeutralNick;
+        StartNeutralPitch = AdNeutralPitch;
-    if(eeprom_read_byte(&EEPromArray[EEPROM_ADR_ACC_NICK]) > 4)
+    if(GetParamWord(PID_ACC_PITCH) > 1023)
     {
-      NeutralAccY = abs(Mittelwert_AccRoll) / ACC_AMPLIFY;
+                NeutralAccY = abs(Mean_AccRoll) / ACC_AMPLIFY;
-          NeutralAccX = abs(Mittelwert_AccNick) / ACC_AMPLIFY;
+                NeutralAccX = abs(Mean_AccPitch) / ACC_AMPLIFY;
-          NeutralAccZ = Aktuell_az;
+                NeutralAccZ = Current_AccZ;
     }
     else
     {
-      NeutralAccX = (int)eeprom_read_byte(&EEPromArray[EEPROM_ADR_ACC_NICK]) * 256 + (int)eeprom_read_byte(&EEPromArray[EEPROM_ADR_ACC_NICK+1]);
+                NeutralAccX = (int16_t)GetParamWord(PID_ACC_PITCH);
-          NeutralAccY = (int)eeprom_read_byte(&EEPromArray[EEPROM_ADR_ACC_ROLL]) * 256 + (int)eeprom_read_byte(&EEPromArray[EEPROM_ADR_ACC_ROLL+1]);
-          NeutralAccZ = (int)eeprom_read_byte(&EEPromArray[EEPROM_ADR_ACC_Z]) * 256 + (int)eeprom_read_byte(&EEPromArray[EEPROM_ADR_ACC_Z+1]);
+            NeutralAccY = (int16_t)GetParamWord(PID_ACC_ROLL);
-    }
+            NeutralAccZ = (int16_t)GetParamWord(PID_ACC_Z);
+    }
-        Mess_IntegralNick = 0;
+        Reading_IntegralGyroPitch = 0;
-    Mess_IntegralNick2 = 0;
+    Reading_IntegralGyroPitch2 = 0;
-    Mess_IntegralRoll = 0;
+    Reading_IntegralGyroRoll = 0;
-    Mess_IntegralRoll2 = 0;
+    Reading_IntegralGyroRoll2 = 0;
-    Mess_Integral_Gier = 0;
+    Reading_IntegralGyroYaw = 0;
-    MesswertNick = 0;
+    Reading_GyroPitch = 0;
-    MesswertRoll = 0;
+    Reading_GyroRoll = 0;
-    MesswertGier = 0;
+    Reading_GyroYaw = 0;
-    StartLuftdruck = Luftdruck;
+    StartAirPressure = AirPressure;
-    HoeheD = 0;
-    Mess_Integral_Hoch = 0;
+    HeightD = 0;
-    KompassStartwert = KompassValue;
+    Reading_Integral_Top = 0;
-    GPS_Neutral();
+    CompassCourse = CompassHeading;
-    beeptime = 50;
+    BeepTime = 50;
-        Umschlag180Nick = ((long) EE_Parameter.WinkelUmschlagNick * 2500L) + 15000L;
+        TurnOver180Pitch = ((int32_t) ParamSet.AngleTurnOverPitch * 2500L) +15000L;
-        Umschlag180Roll = ((long) EE_Parameter.WinkelUmschlagRoll * 2500L) + 15000L;
+        TurnOver180Roll =  ((int32_t) ParamSet.AngleTurnOverRoll *  2500L) +15000L;
+    ExternHeightValue = 0;
-    ExternHoehenValue = 0;
+    GPS_Pitch = 0;
-    ErsatzKompass = KompassValue * GIER_GRAD_FAKTOR;
+    GPS_Roll = 0;
-    GierGyroFehler = 0;
+    YawGyroHeading = CompassHeading * YAW_GYRO_DEG_FACTOR;
-    SendVersionToNavi = 1;
+    YawGyroDrift = 0;
 }
+/************************************************************************/
-//############################################################################
-// Bearbeitet die Messwerte
+/*  Averaging Measurement Readings                                      */
-void Mittelwert(void)
+/************************************************************************/
+void Mean(void)
+{
-//############################################################################
+    static int32_t tmpl,tmpl2;
-{
-    static signed long tmpl,tmpl2;
+ // Get offset corrected gyro readings (~ to angular velocity)
-    MesswertGier = (signed int) AdNeutralGier - AdWertGier;
+    Reading_GyroYaw   = AdNeutralYaw    - AdValueGyrYaw;
-    MesswertRoll = (signed int) AdWertRoll - AdNeutralRoll;
+    Reading_GyroRoll  = AdValueGyrRoll  - AdNeutralRoll;
-    MesswertNick = (signed int) AdWertNick - AdNeutralNick;
+    Reading_GyroPitch = AdValueGyrPitch - AdNeutralPitch;
-//DebugOut.Analog[26] = MesswertNick;
-DebugOut.Analog[28] = MesswertRoll;
+// Acceleration Sensor
-// Beschleunigungssensor  ++++++++++++++++++++++++++++++++++++++++++++++++
+        // sliding average sensor readings
+        Mean_AccPitch = ((int32_t)Mean_AccPitch * 1 + ((ACC_AMPLIFY * (int32_t)AdValueAccPitch))) / 2L;
+        Mean_AccRoll  = ((int32_t)Mean_AccRoll * 1 + ((ACC_AMPLIFY * (int32_t)AdValueAccRoll))) / 2L;
-        Mittelwert_AccNick = ((long)Mittelwert_AccNick * 1 + ((ACC_AMPLIFY * (long)AdWertAccNick))) / 2L;
+        Mean_AccTop   = ((int32_t)Mean_AccTop * 1 + ((int32_t)AdValueAccTop)) / 2L;
-        Mittelwert_AccRoll = ((long)Mittelwert_AccRoll * 1 + ((ACC_AMPLIFY * (long)AdWertAccRoll))) / 2L;
+        // sum sensor readings for later averaging
-        Mittelwert_AccHoch = ((long)Mittelwert_AccHoch * 1 + ((long)AdWertAccHoch)) / 2L;
+    IntegralAccPitch += ACC_AMPLIFY * AdValueAccPitch;
-    IntegralAccNick += ACC_AMPLIFY * AdWertAccNick;
+    IntegralAccRoll  += ACC_AMPLIFY * AdValueAccRoll;
     IntegralAccRoll += ACC_AMPLIFY * AdWertAccRoll;
+    NaviAccPitch += AdValueAccPitch;
+    NaviAccRoll  += AdValueAccRoll;
-    NaviAccNick    += AdWertAccNick;
+    NaviCntAcc++;
-    NaviAccRoll    += AdWertAccRoll;
-    NaviCntAcc++;
-    IntegralAccZ    += Aktuell_az - NeutralAccZ;
-// Gier  ++++++++++++++++++++++++++++++++++++++++++++++++
+// Yaw
-            ErsatzKompass +=  MesswertGier;
+        // calculate yaw gyro integral (~ to rotation angle)
-            Mess_Integral_Gier +=  MesswertGier;
+        Reading_IntegralGyroYaw  += Reading_GyroYaw;
+        YawGyroHeading += Reading_GyroYaw;
+    if(YawGyroHeading >= (360L * YAW_GYRO_DEG_FACTOR)) YawGyroHeading -= 360L * YAW_GYRO_DEG_FACTOR;  // 360° Wrap
-            Mess_Integral_Gier2 += MesswertGier;
+        if(YawGyroHeading < 0)                             YawGyroHeading += 360L * YAW_GYRO_DEG_FACTOR;
-                    if(ErsatzKompass >= (360L * GIER_GRAD_FAKTOR)) ErsatzKompass -= 360L * GIER_GRAD_FAKTOR;  // 360° Umschlag
                     if(ErsatzKompass < 0)                          ErsatzKompass += 360L * GIER_GRAD_FAKTOR;
-// Kopplungsanteil  +++++++++++++++++++++++++++++++++++++
+        // Coupling fraction
-      if(!Looping_Nick && !Looping_Roll && (EE_Parameter.GlobalConfig & CFG_ACHSENKOPPLUNG_AKTIV))
+        if(!Looping_Pitch && !Looping_Roll && (ParamSet.GlobalConfig & CFG_AXIS_COUPLING_ACTIVE))
+        {
-            tmpl = (MesswertGier * Mess_IntegralNick) / 2048L;
+                tmpl = (Reading_GyroYaw * Reading_IntegralGyroPitch) / 2048L;
-            tmpl *= Parameter_AchsKopplung1;  //125
+                tmpl *= FCParam.Yaw_PosFeedback;
-            tmpl /= 4096L;
+                tmpl /= 4096L;
-            tmpl2 = (MesswertGier * Mess_IntegralRoll) / 2048L;
+                tmpl2 = ( Reading_GyroYaw * Reading_IntegralGyroRoll) / 2048L;
-            tmpl2 *= Parameter_AchsKopplung1;
+                tmpl2 *= FCParam.Yaw_PosFeedback;
-            tmpl2 /= 4096L;
+                tmpl2 /= 4096L;
+                if(labs(tmpl) > 128 || labs(tmpl2) > 128) FunnelCourse = 1;
-            if(labs(tmpl) > 128 || labs(tmpl2) > 128) TrichterFlug = 1;
+        }
-         }
+        else  tmpl = tmpl2 = 0;
-      else  tmpl = tmpl2 = 0;
-// Roll  ++++++++++++++++++++++++++++++++++++++++++++++++
+// Roll
-            MesswertRoll += tmpl;
+        Reading_GyroRoll += tmpl;
-            MesswertRoll += (tmpl2*Parameter_AchsGegenKopplung1)/512L; //109
+        Reading_GyroRoll += (tmpl2 * FCParam.Yaw_NegFeedback) / 512L;
-            Mess_IntegralRoll2 += MesswertRoll;
+        Reading_IntegralGyroRoll2 += Reading_GyroRoll;
-            Mess_IntegralRoll +=  MesswertRoll - LageKorrekturRoll;
+        Reading_IntegralGyroRoll +=  Reading_GyroRoll - AttitudeCorrectionRoll;
-            if(Mess_IntegralRoll > Umschlag180Roll)
+        if(Reading_IntegralGyroRoll > TurnOver180Roll)
-            {
+        {
-             Mess_IntegralRoll  = -(Umschlag180Roll - 25000L);
+                Reading_IntegralGyroRoll  = -(TurnOver180Roll - 10000L);
-             Mess_IntegralRoll2 = Mess_IntegralRoll;
+                Reading_IntegralGyroRoll2 = Reading_IntegralGyroRoll;
-            }
+        }
-            if(Mess_IntegralRoll <-Umschlag180Roll)
+        if(Reading_IntegralGyroRoll < -TurnOver180Roll)
-            {
+        {
-             Mess_IntegralRoll =  (Umschlag180Roll - 25000L);
+                Reading_IntegralGyroRoll =  (TurnOver180Roll - 10000L);
-             Mess_IntegralRoll2 = Mess_IntegralRoll;
+                Reading_IntegralGyroRoll2 = Reading_IntegralGyroRoll;
-            }
+        }
-            if(AdWertRoll < 15)   MesswertRoll = -1000;
+        if(AdValueGyrRoll < 15)   Reading_GyroRoll = -1000;
-            if(AdWertRoll <  7)   MesswertRoll = -2000;
+        if(AdValueGyrRoll <  7)   Reading_GyroRoll = -2000;
-            if(PlatinenVersion == 10)
+        if(BoardRelease == 10)
+        {
-              if(AdWertRoll > 1010) MesswertRoll = +1000;
+                if(AdValueGyrRoll > 1010) Reading_GyroRoll = +1000;
-              if(AdWertRoll > 1017) MesswertRoll = +2000;
+                if(AdValueGyrRoll > 1017) Reading_GyroRoll = +2000;
-                         }
+        }
-                         else
+        else
+        {
-              if(AdWertRoll > 2020) MesswertRoll = +1000;
+                if(AdValueGyrRoll > 2020) Reading_GyroRoll = +1000;
-              if(AdWertRoll > 2034) MesswertRoll = +2000;
+                if(AdValueGyrRoll > 2034) Reading_GyroRoll = +2000;
-                         }
+        }
-// Nick  ++++++++++++++++++++++++++++++++++++++++++++++++
+// Pitch
-            MesswertNick -= tmpl2;
+        Reading_GyroPitch -= tmpl2;
+        Reading_GyroPitch -= (tmpl*FCParam.Yaw_NegFeedback) / 512L;
+        Reading_IntegralGyroPitch2 += Reading_GyroPitch;
+        Reading_IntegralGyroPitch  += Reading_GyroPitch - AttitudeCorrectionPitch;
+        if(Reading_IntegralGyroPitch > TurnOver180Pitch)
-            MesswertNick -= (tmpl*Parameter_AchsGegenKopplung1)/512L;
+        {
-            Mess_IntegralNick2 += MesswertNick;
+         Reading_IntegralGyroPitch = -(TurnOver180Pitch - 25000L);
+         Reading_IntegralGyroPitch2 = Reading_IntegralGyroPitch;
+        }
+        if(Reading_IntegralGyroPitch < -TurnOver180Pitch)
+        {
+         Reading_IntegralGyroPitch =  (TurnOver180Pitch - 25000L);
+         Reading_IntegralGyroPitch2 = Reading_IntegralGyroPitch;
+        }
-            Mess_IntegralNick  += MesswertNick - LageKorrekturNick;
+        if(AdValueGyrPitch < 15)   Reading_GyroPitch = -1000;
+        if(AdValueGyrPitch <  7)   Reading_GyroPitch = -2000;
-            if(Mess_IntegralNick > Umschlag180Nick)
+        if(BoardRelease == 10)
+        {
-              Mess_IntegralNick = -(Umschlag180Nick - 25000L);
+                if(AdValueGyrPitch > 1010) Reading_GyroPitch = +1000;
-              Mess_IntegralNick2 = Mess_IntegralNick;
+                if(AdValueGyrPitch > 1017) Reading_GyroPitch = +2000;
-             }
+        }
-            if(Mess_IntegralNick <-Umschlag180Nick)
+        else
+        {
+                if(AdValueGyrPitch > 2020) Reading_GyroPitch = +1000;
+                if(AdValueGyrPitch > 2034) Reading_GyroPitch = +2000;
+        }
-             Mess_IntegralNick =  (Umschlag180Nick - 25000L);
+// start ADC again to capture measurement values for the next loop
-             Mess_IntegralNick2 = Mess_IntegralNick;
+    ADC_Enable();
-            }
+    IntegralYaw    = Reading_IntegralGyroYaw;
+    IntegralPitch  = Reading_IntegralGyroPitch;
+    IntegralRoll   = Reading_IntegralGyroRoll;
+    IntegralPitch2 = Reading_IntegralGyroPitch2;
-            if(AdWertNick < 15)   MesswertNick = -1000;
+    IntegralRoll2  = Reading_IntegralGyroRoll2;
-            if(AdWertNick <  7)   MesswertNick = -2000;
+        if((ParamSet.GlobalConfig & CFG_ROTARY_RATE_LIMITER) && !Looping_Pitch && !Looping_Roll)
-            if(PlatinenVersion == 10)
+        {
+                if(Reading_GyroPitch > 200)       Reading_GyroPitch += 4 * (Reading_GyroPitch - 200);
                 else if(Reading_GyroPitch < -200) Reading_GyroPitch += 4 * (Reading_GyroPitch + 200);
-              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;
-//++++++++++++++++++++++++++++++++++++++++++++++++
-    Integral_Gier  = Mess_Integral_Gier;
-    IntegralNick = Mess_IntegralNick;
-    IntegralRoll = Mess_IntegralRoll;
-    IntegralNick2 = Mess_IntegralNick2;
-    IntegralRoll2 = Mess_IntegralRoll2;
-  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(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--;
-    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(Reading_GyroRoll > 200)        Reading_GyroRoll  += 4 * (Reading_GyroRoll - 200);
-    if(Poti3 < 0) Poti3 = 0; else if(Poti3 > 255) Poti3 = 255;
+                else if(Reading_GyroRoll < -200)  Reading_GyroRoll  += 4 * (Reading_GyroRoll + 200);
-    if(Poti4 < 0) Poti4 = 0; else if(Poti4 > 255) Poti4 = 255;
+        }
+}
-}
-//############################################################################
+/************************************************************************/
-// Messwerte beim Ermitteln der Nullage
+/*  Averaging Measurement Readings  for Calibration                     */
-void CalibrierMittelwert(void)
+/************************************************************************/
-//############################################################################
-{
-    // ADC auschalten, damit die Werte sich nicht während der Berechnung ändern
-        ANALOG_OFF;
-        MesswertNick = AdWertNick;
-        MesswertRoll = AdWertRoll;
-        MesswertGier = AdWertGier;
-        Mittelwert_AccNick = ACC_AMPLIFY * (long)AdWertAccNick;
-        Mittelwert_AccRoll = ACC_AMPLIFY * (long)AdWertAccRoll;
-        Mittelwert_AccHoch = (long)AdWertAccHoch;
-   // 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--;
+void CalibMean(void)
+{
+    // stop ADC to avoid changing values during calculation
+        ADC_Disable();
+        Reading_GyroPitch = AdValueGyrPitch;
+        Reading_GyroRoll  = AdValueGyrRoll;
+        Reading_GyroYaw   = AdValueGyrYaw;
+        Mean_AccPitch = ACC_AMPLIFY * (int32_t)AdValueAccPitch;
+        Mean_AccRoll  = ACC_AMPLIFY * (int32_t)AdValueAccRoll;
-    if(Poti1 < 0) Poti1 = 0; else if(Poti1 > 255) Poti1 = 255;
+        Mean_AccTop   = (int32_t)AdValueAccTop;
-    if(Poti2 < 0) Poti2 = 0; else if(Poti2 > 255) Poti2 = 255;
+    // start ADC (enables internal trigger so that the ISR in analog.c
-    if(Poti3 < 0) Poti3 = 0; else if(Poti3 > 255) Poti3 = 255;
+    // updates the readings once)
-    if(Poti4 < 0) Poti4 = 0; else if(Poti4 > 255) Poti4 = 255;
+    ADC_Enable();
+        TurnOver180Pitch = (int32_t) ParamSet.AngleTurnOverPitch * 2500L;
-        Umschlag180Nick = (long) EE_Parameter.WinkelUmschlagNick * 2500L;
+        TurnOver180Roll =  (int32_t) ParamSet.AngleTurnOverRoll  * 2500L;
-        Umschlag180Roll = (long) EE_Parameter.WinkelUmschlagRoll * 2500L;
+}
-//############################################################################
+/************************************************************************/
-// Senden der Motorwerte per I2C-Bus
+/*  Transmit Motor Data via I2C                                         */
-void SendMotorData(void)
+/************************************************************************/
-//############################################################################
+void SendMotorData(void)
 {
-    if(MOTOR_OFF || !MotorenEin)
+    if(MOTOR_OFF || !MotorsOn)
-        {
+    {
-        Motor_Hinten = 0;
+        Motor_Rear = 0;
-        Motor_Vorne = 0;
+        Motor_Front = 0;
-        Motor_Rechts = 0;
+        Motor_Right = 0;
-        Motor_Links = 0;
+        Motor_Left = 0;
-        if(MotorTest[0]) Motor_Vorne = MotorTest[0];
+        if(MotorTest[0]) Motor_Front = MotorTest[0];
-        if(MotorTest[1]) Motor_Hinten = MotorTest[1];
+        if(MotorTest[1]) Motor_Rear  = MotorTest[1];
-        if(MotorTest[2]) Motor_Links = MotorTest[2];
+        if(MotorTest[2]) Motor_Left  = MotorTest[2];
-        if(MotorTest[3]) Motor_Rechts = MotorTest[3];
+        if(MotorTest[3]) Motor_Right = MotorTest[3];
+     }
-    DebugOut.Analog[12] = Motor_Vorne;
+    DebugOut.Analog[12] = Motor_Front;
-    DebugOut.Analog[13] = Motor_Hinten;
+    DebugOut.Analog[13] = Motor_Rear;
-    DebugOut.Analog[14] = Motor_Links;
+    DebugOut.Analog[14] = Motor_Left;
-    DebugOut.Analog[15] = Motor_Rechts;
+    DebugOut.Analog[15] = Motor_Right;
+    //Start I2C Interrupt Mode
-    //Start I2C Interrupt Mode
+    twi_state = 0;
-    twi_state = 0;
     motor = 0;
+    I2C_Start();
+}
-    i2c_start();
+/************************************************************************/
+/*  Maps the parameter to poti values                                   */
+/************************************************************************/
-//############################################################################
+void ParameterMapping(void)
-// Trägt ggf. das Poti als Parameter ein
+{
-void ParameterZuordnung(void)
+        if(RC_Quality > 160) // do the mapping of RC-Potis only if the rc-signal is ok
-//############################################################################
+        // else the last updated values are used
-{
+        {
+                 //update poti values by rc-signals
- #define CHK_POTI(b,a,min,max) { if(a > 250) { if(a == 251) b = Poti1; else if(a == 252) b = Poti2; else if(a == 253) b = Poti3; else if(a == 254) b = Poti4;} else b = a; if(b <= min) b = min; else if(b >= max) b = max;}
+                #define CHK_POTI(b,a,min,max) { if(a > 250) { if(a == 251) b = Poti1; else if(a == 252) b = Poti2; else if(a == 253) b = Poti3; else if(a == 254) b = Poti4;} else b = a; if(b <= min) b = min; else if(b >= max) b = max;}
- CHK_POTI(Parameter_MaxHoehe,EE_Parameter.MaxHoehe,0,255);
+                CHK_POTI(FCParam.MaxHeight,ParamSet.MaxHeight,0,255);
- CHK_POTI(Parameter_Luftdruck_D,EE_Parameter.Luftdruck_D,0,100);
+                CHK_POTI(FCParam.Height_D,ParamSet.Height_D,0,100);
- CHK_POTI(Parameter_Hoehe_P,EE_Parameter.Hoehe_P,0,100);
+                CHK_POTI(FCParam.Height_P,ParamSet.Height_P,0,100);
- CHK_POTI(Parameter_Hoehe_ACC_Wirkung,EE_Parameter.Hoehe_ACC_Wirkung,0,255);
+                CHK_POTI(FCParam.Height_ACC_Effect,ParamSet.Height_ACC_Effect,0,255);
- CHK_POTI(Parameter_KompassWirkung,EE_Parameter.KompassWirkung,0,255);
+                CHK_POTI(FCParam.CompassYawEffect,ParamSet.CompassYawEffect,0,255);
- CHK_POTI(Parameter_Gyro_P,EE_Parameter.Gyro_P,10,255);
+                CHK_POTI(FCParam.Gyro_P,ParamSet.Gyro_P,10,255);
- CHK_POTI(Parameter_Gyro_I,EE_Parameter.Gyro_I,0,255);
+                CHK_POTI(FCParam.Gyro_I,ParamSet.Gyro_I,0,255);
- CHK_POTI(Parameter_I_Faktor,EE_Parameter.I_Faktor,0,255);
+                CHK_POTI(FCParam.I_Factor,ParamSet.I_Factor,0,255);
- CHK_POTI(Parameter_UserParam1,EE_Parameter.UserParam1,0,255);
+                CHK_POTI(FCParam.UserParam1,ParamSet.UserParam1,0,255);
- CHK_POTI(Parameter_UserParam2,EE_Parameter.UserParam2,0,255);
+                CHK_POTI(FCParam.UserParam2,ParamSet.UserParam2,0,255);
- CHK_POTI(Parameter_UserParam3,EE_Parameter.UserParam3,0,255);
+                CHK_POTI(FCParam.UserParam3,ParamSet.UserParam3,0,255);
+                CHK_POTI(FCParam.UserParam4,ParamSet.UserParam4,0,255);
+                CHK_POTI(FCParam.UserParam5,ParamSet.UserParam5,0,255);
+                CHK_POTI(FCParam.UserParam6,ParamSet.UserParam6,0,255);
+                CHK_POTI(FCParam.UserParam7,ParamSet.UserParam7,0,255);
+                CHK_POTI(FCParam.UserParam8,ParamSet.UserParam8,0,255);
+                CHK_POTI(FCParam.ServoPitchControl,ParamSet.ServoPitchControl,0,255);
+                CHK_POTI(FCParam.LoopThrustLimit,ParamSet.LoopThrustLimit,0,255);
+                CHK_POTI(FCParam.Yaw_PosFeedback,ParamSet.Yaw_PosFeedback,0,255);
- CHK_POTI(Parameter_UserParam4,EE_Parameter.UserParam4,0,255);
+                CHK_POTI(FCParam.Yaw_NegFeedback,ParamSet.Yaw_NegFeedback,0,255);
- CHK_POTI(Parameter_UserParam5,EE_Parameter.UserParam5,0,255);
+                CHK_POTI(FCParam.DynamicStability,ParamSet.DynamicStability,0,255);
+                Ki = (float) FCParam.I_Factor * FACTOR_I;
- CHK_POTI(Parameter_UserParam6,EE_Parameter.UserParam6,0,255);
+        }
+}
+void SetCompassCalState(void)
+{
- CHK_POTI(Parameter_UserParam7,EE_Parameter.UserParam7,0,255);
+        static uint8_t stick = 1;
- CHK_POTI(Parameter_UserParam8,EE_Parameter.UserParam8,0,255);
+    // if pitch is centered or top set stick to zero
+        if(PPM_in[ParamSet.ChannelAssignment[CH_PITCH]] > -20) stick = 0;
+        // if pitch is down trigger to next cal state
+        if((PPM_in[ParamSet.ChannelAssignment[CH_PITCH]] < -70) && !stick)
+        {
+                stick = 1;
+                CompassCalState++;
+                if(CompassCalState < 5) Beep(CompassCalState);
+                else BeepTime = 1000;
+        }
+}
+/************************************************************************/
+/*  MotorControl                                                        */
+/************************************************************************/
+void MotorControl(void)
+{
- 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;
-}
-//############################################################################
-//
-void MotorRegler(void)
-//############################################################################
-{
-         int motorwert,pd_ergebnis,h,tmp_int;
+        int16_t MotorValue, pd_result, h, tmp_int;
-         int GierMischanteil,GasMischanteil;
-     static long SummeNick=0,SummeRoll=0;
+        int16_t YawMixFraction, ThrustMixFraction;
+        static int32_t SumPitch = 0, SumRoll = 0;
-     static long sollGier = 0,tmp_long,tmp_long2;
+        static int32_t SetPointYaw = 0;
-     static long IntegralFehlerNick = 0;
+        static int32_t IntegralErrorPitch = 0;
-     static long IntegralFehlerRoll = 0;
+        static int32_t IntegralErrorRoll = 0;
-         static unsigned int RcLostTimer;
+        static uint16_t RcLostTimer;
-         static unsigned char delay_neutral = 0;
+        static uint8_t delay_neutral = 0, delay_startmotors = 0, delay_stopmotors = 0;
-         static unsigned char delay_einschalten = 0,delay_ausschalten = 0;
+        static uint8_t HeightControlActive = 0;
-     static int hoehenregler = 0;
+        static int16_t HeightControlThrust = 0;
-     static char TimerWerteausgabe = 0;
+        static int8_t TimerDebugOut = 0;
-     static char NeueKompassRichtungMerken = 0;
+        static uint16_t UpdateCompassCourse = 0;
-     static long ausgleichNick, ausgleichRoll;
+        static int32_t CorrectionPitch, CorrectionRoll;
-        Mittelwert();
+        Mean();
+        GRN_ON;
     GRN_ON;
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-// Gaswert ermitteln
+// determine thrust value
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-        GasMischanteil = StickGas;
+        ThrustMixFraction = StickThrust;
-    if(GasMischanteil < MIN_GAS + 10) GasMischanteil = MIN_GAS + 10;
+    if(ThrustMixFraction < ParamSet.Trust_Min + 10) ThrustMixFraction = ParamSet.Trust_Min + 10;
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-// Empfang schlecht
+// RC-signal is bad
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-   if(SenderOkay < 100)
+        if(RC_Quality < 120)  // the rc-frame signal is not reveived or noisy
+        {
-        if(!PcZugriff)
+                if(!PcAccess) // if also no PC-Access via UART
-         {
+                {
-           if(BeepMuster == 0xffff)
+                        if(BeepModulation == 0xFFFF)
+                        {
-            {
+                         BeepTime = 15000; // 1.5 seconds
-             beeptime = 15000;
+                         BeepModulation = 0x0C00;
-             BeepMuster = 0x0c00;
+                        }
-            }
+                }
-         }
+                if(RcLostTimer) RcLostTimer--; // decremtent timer after rc sigal lost
-        if(RcLostTimer) RcLostTimer--;
+                else // rc lost countdown finished
-        else
+                {
-         {
-          MotorenEin = 0;
+                  MotorsOn = 0; // stop all motors
-          Notlandung = 0;
+                  EmergencyLanding = 0; // emergency landing is over
+                }
+                ROT_ON; // set red led
                 if(Model_Is_Flying > 1000)  // wahrscheinlich in der Luft --> langsam absenken
         ROT_ON;
-        if(modell_fliegt > 1000)  // wahrscheinlich in der Luft --> langsam absenken
+                        ThrustMixFraction = ParamSet.EmergencyThrust; // set emergency thrust
                         EmergencyLanding = 1; // enable emergency landing
-            GasMischanteil = EE_Parameter.NotGas;
+                        // set neutral rc inputs
-            Notlandung = 1;
-            PPM_diff[EE_Parameter.Kanalbelegung[K_NICK]] = 0;
-            PPM_diff[EE_Parameter.Kanalbelegung[K_ROLL]] = 0;
-            PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] = 0;
-            PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] = 0;
+                        PPM_diff[ParamSet.ChannelAssignment[CH_PITCH]] = 0;
+                        PPM_diff[ParamSet.ChannelAssignment[CH_ROLL]] = 0;
+                        PPM_diff[ParamSet.ChannelAssignment[CH_YAW]] = 0;
+                        PPM_in[ParamSet.ChannelAssignment[CH_PITCH]] = 0;
+                        PPM_in[ParamSet.ChannelAssignment[CH_ROLL]] = 0;
+                        PPM_in[ParamSet.ChannelAssignment[CH_YAW]] = 0;
-            PPM_in[EE_Parameter.Kanalbelegung[K_GIER]] = 0;
+                }
+                else MotorsOn = 0; // switch of all motors
+        } // eof RC_Quality < 120
+        else
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// RC-signal is good
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+        if(RC_Quality > 140)
+        {
+                EmergencyLanding = 0; // switch off emergency landing if RC-signal is okay
+                // reset emergency timer
+                RcLostTimer = ParamSet.EmergencyThrustDuration * 50;
+                if(ThrustMixFraction > 40)
+                {
+                        if(Model_Is_Flying < 0xFFFF) Model_Is_Flying++;
+                }
+                if(Model_Is_Flying < 256)
+                {
+                        SumPitch = 0;
+                        SumRoll = 0;
+                        StickYaw = 0;
+                        if(Model_Is_Flying == 250) UpdateCompassCourse = 1;
+                }
+                if(Poti1 < PPM_in[ParamSet.ChannelAssignment[CH_POTI1]] + 110) Poti1++; else if(Poti1 > PPM_in[ParamSet.ChannelAssignment[CH_POTI1]] + 110 && Poti1) Poti1--;
+                if(Poti2 < PPM_in[ParamSet.ChannelAssignment[CH_POTI2]] + 110) Poti2++; else if(Poti2 > PPM_in[ParamSet.ChannelAssignment[CH_POTI2]] + 110 && Poti2) Poti2--;
+                if(Poti3 < PPM_in[ParamSet.ChannelAssignment[CH_POTI3]] + 110) Poti3++; else if(Poti3 > PPM_in[ParamSet.ChannelAssignment[CH_POTI3]] + 110 && Poti3) Poti3--;
+                if(Poti4 < PPM_in[ParamSet.ChannelAssignment[CH_POTI4]] + 110) Poti4++; else if(Poti4 > PPM_in[ParamSet.ChannelAssignment[CH_POTI4]] + 110 && Poti4) Poti4--;
+                //PPM24-Extension
+                if(Poti5 < PPM_in[9] + 110)  Poti5++; else if(Poti5 >  PPM_in[9] + 110 && Poti5) Poti5--;
+                if(Poti6 < PPM_in[10] + 110) Poti6++; else if(Poti6 > PPM_in[10] + 110 && Poti6) Poti6--;
+                if(Poti7 < PPM_in[11] + 110) Poti7++; else if(Poti7 > PPM_in[11] + 110 && Poti7) Poti7--;
+                if(Poti8 < PPM_in[12] + 110) Poti8++; else if(Poti8 > PPM_in[12] + 110 && Poti8) Poti8--;
+                //limit poti values
+                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;
+                //PPM24-Extension
+                if(Poti5 < 0) Poti5 = 0; else if(Poti5 > 255) Poti5 = 255;
+                if(Poti6 < 0) Poti6 = 0; else if(Poti6 > 255) Poti6 = 255;
+                if(Poti7 < 0) Poti7 = 0; else if(Poti7 > 255) Poti7 = 255;
+                if(Poti8 < 0) Poti8 = 0; else if(Poti8 > 255) Poti8 = 255;
-            }
+                // if motors are off and the thrust stick is in the upper position
-         else MotorenEin = 0;
+                if((PPM_in[ParamSet.ChannelAssignment[CH_THRUST]] > 80) && MotorsOn == 0)
+                {
+                        // and if the yaw stick is in the leftmost position
                         if(PPM_in[ParamSet.ChannelAssignment[CH_YAW]] > 75)
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// calibrate the neutral readings of all attitude sensors
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+                        {
+                                // thrust/yaw joystick is top left
+                                //  _________
+                                // |x        |
+                                // |         |
+                                // |         |
+                                // |         |
+                                // |         |
+                                //  ¯¯¯¯¯¯¯¯¯
+                                if(++delay_neutral > 200)  // not immediately (wait 200 loops = 200 * 2ms = 0.4 s)
+                                {
-        else
+                                        delay_neutral = 0;
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+                                        GRN_OFF;
+                                        Model_Is_Flying = 0;
-// Emfang gut
+                                        // check roll/pitch stick position
+                                        // if pitch stick is top or roll stick is left or right --> change parameter setting
+                                        // according to roll/pitch stick position
+                                        if(PPM_in[ParamSet.ChannelAssignment[CH_PITCH]] > 70 || abs(PPM_in[ParamSet.ChannelAssignment[CH_ROLL]]) > 70)
+                                        {
+                                                 uint8_t setting = 1; // default
+                                                 // pitch/roll joystick
+                                                 //  _________
+                                                 // |2   3   4|
+                                                 // |         |
+                                                 // |1       5|
+                                                 // |         |
+                                                 // |         |
+                                                 //  ¯¯¯¯¯¯¯¯¯
+                                                 // roll stick leftmost and pitch stick centered --> setting 1
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+                                                 if(PPM_in[ParamSet.ChannelAssignment[CH_ROLL]] > 70 && PPM_in[ParamSet.ChannelAssignment[CH_PITCH]] < 70) setting = 1;
-        if(SenderOkay > 140)
-            {
+                                                 // roll stick leftmost and pitch stick topmost --> setting 2
-            Notlandung = 0;
-            RcLostTimer = EE_Parameter.NotGasZeit * 50;
-            if(GasMischanteil > 40)
-                {
-                if(modell_fliegt < 0xffff) modell_fliegt++;
+                                                 if(PPM_in[ParamSet.ChannelAssignment[CH_ROLL]] > 70 && PPM_in[ParamSet.ChannelAssignment[CH_PITCH]] > 70) setting = 2;
-                }
+                                                 // roll stick centered an pitch stick topmost --> setting 3
-            if((modell_fliegt < 256))
+                                                 if(PPM_in[ParamSet.ChannelAssignment[CH_ROLL]] < 70 && PPM_in[ParamSet.ChannelAssignment[CH_PITCH]] > 70) setting = 3;
-                {
-                SummeNick = 0;
+                                                 // roll stick rightmost and pitch stick topmost --> setting 4
-                SummeRoll = 0;
-                if(modell_fliegt == 250) NeueKompassRichtungMerken = 1;
-                }
+                                                 if(PPM_in[ParamSet.ChannelAssignment[CH_ROLL]] <-70 && PPM_in[ParamSet.ChannelAssignment[CH_PITCH]] > 70) setting = 4;
-            if((PPM_in[EE_Parameter.Kanalbelegung[K_GAS]] > 80) && MotorenEin == 0)
+                                                 // roll stick rightmost and pitch stick centered --> setting 5
+                                                 if(PPM_in[ParamSet.ChannelAssignment[CH_ROLL]] <-70 && PPM_in[ParamSet.ChannelAssignment[CH_PITCH]] < 70) setting = 5;
+                                                 // update active parameter set in eeprom
-                {
+                                                 SetActiveParamSet(setting);
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+                                                 ParamSet_ReadFromEEProm(GetActiveParamSet());
-// auf Nullwerte kalibrieren
+                                                 SetNeutral();
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+                                                 Beep(GetActiveParamSet());
-                if(PPM_in[EE_Parameter.Kanalbelegung[K_GIER]] > 75)  // Neutralwerte
+                                        }
+                                        else
-                    {
+                                        {
-                    if(++delay_neutral > 200)  // nicht sofort
+                                                if((ParamSet.GlobalConfig & CFG_COMPASS_ACTIVE))
+                                                {
                                                         // if roll stick is centered and pitch stick is down
-                        GRN_OFF;
+                                                        if (abs(PPM_in[ParamSet.ChannelAssignment[CH_ROLL]]) < 20 && PPM_in[ParamSet.ChannelAssignment[CH_PITCH]] < -70)
-                        MotorenEin = 0;
                         delay_neutral = 0;
-                        modell_fliegt = 0;
+                                                                // pitch/roll joystick
+                                                                //  _________
-                        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
+                                                                // |         |
+                                                                // |         |
+                                                                // |    x    |
+                                                                //  ¯¯¯¯¯¯¯¯¯
                                                                 // enable calibration state of compass
-//                        else
+                                                                CompassCalState = 1;
-                         if(abs(PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]]) < 20 && PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] < -70)
+                                                                BeepTime = 1000;
+                                                        }
-                           WinkelOut.CalcState = 1;
+                                                        else // pitch and roll are centered
+                                                        {
+                                                                ParamSet_ReadFromEEProm(GetActiveParamSet());
-                           beeptime = 1000;
+                                                                SetNeutral();
-                          }
+                                                                Beep(GetActiveParamSet());
                           else
-                          {
+                                                }
-                               ReadParameterSet(GetActiveParamSetNumber(), (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);
+                                                else // pitch and roll are centered
-                           if((EE_Parameter.GlobalConfig & CFG_HOEHENREGELUNG))  // Höhenregelung aktiviert?
-                            {
-                             if((MessLuftdruck > 950) || (MessLuftdruck < 750)) SucheLuftruckOffset();
+                                                {
+                                                        ParamSet_ReadFromEEProm(GetActiveParamSet());
+                                                        SetNeutral();
-                           SetNeutral();
+                                                        Beep(GetActiveParamSet());
                            Piep(GetActiveParamSetNumber());
-                         }
-                        }
-                    }
+                                        }
-                 else
+                                }
-                if(PPM_in[EE_Parameter.Kanalbelegung[K_GIER]] < -75)  // ACC Neutralwerte speichern
+                        }
-                    {
+                        // and if the yaw stick is in the rightmost position
-                    if(++delay_neutral > 200)  // nicht sofort
+                        // save the ACC neutral setting to eeprom
                         else if(PPM_in[ParamSet.ChannelAssignment[CH_YAW]] < -75)
                         GRN_OFF;
-                        eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACC_NICK],0xff); // Werte löschen
+                                if(++delay_neutral > 200)  // not immediately (wait 200 loops = 200 * 2ms = 0.4 s)
                         MotorenEin = 0;
-                        delay_neutral = 0;
+                                        delay_neutral = 0;
-                        modell_fliegt = 0;
+                                        GRN_OFF;
-                        SetNeutral();
+                                        SetParamWord(PID_ACC_PITCH, 0xFFFF); // make value invalid
-                        eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACC_NICK],NeutralAccX / 256); // ACC-NeutralWerte speichern
+                                        Model_Is_Flying = 0;
-                        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);
+                                        SetNeutral();
-                        eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACC_Z+1],(int)NeutralAccZ % 256);
+                                        // Save ACC neutral settings to eeprom
-                        Piep(GetActiveParamSetNumber());
+                                        SetParamWord(PID_ACC_PITCH, (uint16_t)NeutralAccX);
                                         SetParamWord(PID_ACC_ROLL,  (uint16_t)NeutralAccY);
-                    }
+                                        SetParamWord(PID_ACC_Z,     (uint16_t)NeutralAccZ);
+                                        Beep(GetActiveParamSet());
+                                }
                  else delay_neutral = 0;
-                }
+                        else delay_neutral = 0;
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+                }
-// Gas ist unten
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// thrust stick is down
-            if(PPM_in[EE_Parameter.Kanalbelegung[K_GAS]] < 35-120)
-                {
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-                // Starten
+                if(PPM_in[ParamSet.ChannelAssignment[CH_THRUST]] < -85)
-                if(PPM_in[EE_Parameter.Kanalbelegung[K_GIER]] < -75)
+                {
-                    {
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// and yaw stick is rightmost --> start motors
-// Einschalten
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+                        if(PPM_in[ParamSet.ChannelAssignment[CH_YAW]] < -75)
+                        {
+                                if(++delay_startmotors > 200) // not immediately (wait 200 loops = 200 * 2ms = 0.4 s)
+                                {
+                                        delay_startmotors = 200; // do not repeat if once executed
+                                        Model_Is_Flying = 1;
+                                        MotorsOn = 1;
-                    if(++delay_einschalten > 200)
+                                        SetPointYaw = 0;
                                         Reading_IntegralGyroYaw = 0;
-                        delay_einschalten = 200;
+                                        Reading_IntegralGyroPitch = 0;
-                        modell_fliegt = 1;
-                        MotorenEin = 1;
+                                        Reading_IntegralGyroRoll = 0;
-                        sollGier = 0;
+                                        Reading_IntegralGyroPitch2 = IntegralPitch;
-                        Mess_Integral_Gier = 0;
+                                        Reading_IntegralGyroRoll2 = IntegralRoll;
-                        Mess_Integral_Gier2 = 0;
+                                        SumPitch = 0;
-                        Mess_IntegralNick = 0;
+                                        SumRoll = 0;
-                        Mess_IntegralRoll = 0;
+                                        #ifdef USE_KILLAGREG
-                        Mess_IntegralNick2 = IntegralNick;
+                                        if(ParamSet.GlobalConfig & CFG_GPS_ACTIVE)
+                                        {
+                                                GPS_SetHomePosition();
-                        Mess_IntegralRoll2 = IntegralRoll;
+                                        }
+                                        #endif
-                        SummeNick = 0;
+                                }
+                        }
-                        SummeRoll = 0;
+                        else delay_startmotors = 0; // reset delay timer if sticks are not in this position
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// and yaw stick is leftmost --> stop motors
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-                    else delay_einschalten = 0;
-                //Auf Neutralwerte setzen
+                        if(PPM_in[ParamSet.ChannelAssignment[CH_YAW]] > 75)
+                                {
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+                                if(++delay_stopmotors > 200)  // not immediately (wait 200 loops = 200 * 2ms = 0.4 s)
-// Auschalten
+                                {
+                                        delay_stopmotors = 200; // do not repeat if once executed
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+                                        Model_Is_Flying = 0;
-                if(PPM_in[EE_Parameter.Kanalbelegung[K_GIER]] > 75)
+                                        MotorsOn = 0;
                                         #ifdef USE_KILLAGREG
-                    if(++delay_ausschalten > 200)  // nicht sofort
+                                        if(ParamSet.GlobalConfig & CFG_GPS_ACTIVE)
+                                        {
-                        MotorenEin = 0;
+                                                GPS_ClearHomePosition();
-                        delay_ausschalten = 200;
+                                        }
-                        modell_fliegt = 0;
+                                        #endif
-                        }
+                                }
-                    }
+                        }
-                else delay_ausschalten = 0;
+                        else delay_stopmotors = 0; // reset delay timer if sticks are not in this position
-                }
-            }
+                }
+                        // remapping of paameters only if the signal rc-sigbnal conditions are good
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+        } // eof RC_Quality > 150
-// neue Werte von der Funke
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// new values from RC
- if(!NewPpmData-- || Notlandung)
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-  {
-    int tmp_int;
+        if(!NewPpmData-- || EmergencyLanding) // NewData = 0 means new data from RC
-        static int stick_nick,stick_roll;
+        {
-    ParameterZuordnung();
+                int tmp_int;
-    stick_nick = (stick_nick * 3 + PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] * EE_Parameter.Stick_P) / 4;
+                ParameterMapping(); // remapping params (online poti replacement)
-    stick_nick += PPM_diff[EE_Parameter.Kanalbelegung[K_NICK]] * EE_Parameter.Stick_D;
-    StickNick = stick_nick - (GPS_Nick + GPS_Nick2);
-//    StickNick  = (StickNick  * 3 + PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] * EE_Parameter.Stick_P) / 4;
-    stick_roll = (stick_roll * 3 + PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] * EE_Parameter.Stick_P) / 4;
+                // calculate Stick inputs by rc channels (P) and changing of rc channels (D)
-    stick_roll += PPM_diff[EE_Parameter.Kanalbelegung[K_ROLL]] * EE_Parameter.Stick_D;
+                StickPitch = (StickPitch * 3 + PPM_in[ParamSet.ChannelAssignment[CH_PITCH]] * ParamSet.Stick_P) / 4;
-    StickRoll = stick_roll - (GPS_Roll + GPS_Roll2);
+                StickPitch += PPM_diff[ParamSet.ChannelAssignment[CH_PITCH]] * ParamSet.Stick_D;
+                StickPitch -= (GPS_Pitch);
 //    StickRoll = (StickRoll * 3 + PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] * EE_Parameter.Stick_P) / 4;
+                StickRoll = (StickRoll * 3 + PPM_in[ParamSet.ChannelAssignment[CH_ROLL]] * ParamSet.Stick_P) / 4;
+                StickRoll += PPM_diff[ParamSet.ChannelAssignment[CH_ROLL]] * ParamSet.Stick_D;
-    StickGier = -PPM_in[EE_Parameter.Kanalbelegung[K_GIER]];
+                StickRoll -= (GPS_Roll);
-        StickGas  = PPM_in[EE_Parameter.Kanalbelegung[K_GAS]] + 120;
+                // direct mapping of yaw and thrust
+                StickYaw = -PPM_in[ParamSet.ChannelAssignment[CH_YAW]];
-/*   if(abs(PPM_in[EE_Parameter.Kanalbelegung[K_NICK]]) > MaxStickNick)
+                StickThrust  = PPM_in[ParamSet.ChannelAssignment[CH_THRUST]] + 120;// shift to positive numbers
-     MaxStickNick = abs(PPM_in[EE_Parameter.Kanalbelegung[K_NICK]]); else MaxStickNick--;
-   if(abs(PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]]) > MaxStickRoll)
+                // update gyro control loop factors
+                Gyro_P_Factor = ((float) FCParam.Gyro_P + 10.0) / (256.0 / STICK_GAIN);
-     MaxStickRoll = abs(PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]]); else MaxStickRoll--;
+                Gyro_I_Factor = ((float) FCParam.Gyro_I) / (44000 / STICK_GAIN);
-*/
-    GyroFaktor     = ((float)Parameter_Gyro_P + 10.0) / (256.0/STICK_GAIN);
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-    IntegralFaktor = ((float) Parameter_Gyro_I) / (44000 / STICK_GAIN);
+// Digital Control via DubWise
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-//+ Digitale Steuerung per DubWise
+                #define KEY_VALUE (FCParam.UserParam8 * 4) // step width
-//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+                if(DubWiseKeys[1]) BeepTime = 10;
+                if(DubWiseKeys[1] & DUB_KEY_UP)  tmp_int = KEY_VALUE;
-#define KEY_VALUE (Parameter_UserParam8 * 4)  //(Poti3 * 8)
+                else if(DubWiseKeys[1] & DUB_KEY_DOWN)  tmp_int = -KEY_VALUE;
-if(DubWiseKeys[1]) beeptime = 10;
+                else tmp_int = 0;
-    if(DubWiseKeys[1] & DUB_KEY_UP)    tmp_int = KEY_VALUE;   else
+                ExternStickPitch = (ExternStickPitch * 7 + tmp_int) / 8;
+                if(DubWiseKeys[1] & DUB_KEY_LEFT)  tmp_int = KEY_VALUE;
-    if(DubWiseKeys[1] & DUB_KEY_DOWN)  tmp_int = -KEY_VALUE;  else   tmp_int = 0;
+                else if(DubWiseKeys[1] & DUB_KEY_RIGHT) tmp_int = -KEY_VALUE;
-    ExternStickNick = (ExternStickNick * 7 + tmp_int) / 8;
+                else tmp_int = 0;
-    if(DubWiseKeys[1] & DUB_KEY_LEFT)  tmp_int = KEY_VALUE; else
+                ExternStickRoll = (ExternStickRoll * 7 + tmp_int) / 8;
-    if(DubWiseKeys[1] & DUB_KEY_RIGHT) tmp_int = -KEY_VALUE; else tmp_int = 0;
-    ExternStickRoll = (ExternStickRoll * 7 + tmp_int) / 8;
+                if(DubWiseKeys[0] & 8)  ExternStickYaw = 50;else
+                if(DubWiseKeys[0] & 4)  ExternStickYaw =-50;else ExternStickYaw = 0;
-    if(DubWiseKeys[0] & 8)  ExternStickGier = 50;else
+                if(DubWiseKeys[0] & 2)  ExternHeightValue++;
-    if(DubWiseKeys[0] & 4)  ExternStickGier =-50;else ExternStickGier = 0;
+                if(DubWiseKeys[0] & 16) ExternHeightValue--;
-    if(DubWiseKeys[0] & 2)  ExternHoehenValue++;
-    if(DubWiseKeys[0] & 16) ExternHoehenValue--;
+                StickPitch += (STICK_GAIN * ExternStickPitch) / 8;
+                StickRoll  += (STICK_GAIN * ExternStickRoll) / 8;
+                StickYaw   += (STICK_GAIN * ExternStickYaw);
-    StickNick += (STICK_GAIN * ExternStickNick) / 8;
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-    StickRoll += (STICK_GAIN * ExternStickRoll) / 8;
+//+ Analog control via serial communication
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+                if(ExternControl.Config & 0x01 && FCParam.UserParam8 > 128)
-    StickGier += STICK_GAIN * ExternStickGier;
+                {
-//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+                         StickPitch += (int16_t) ExternControl.Pitch * (int16_t) ParamSet.Stick_P;
+                         StickRoll += (int16_t) ExternControl.Roll * (int16_t) ParamSet.Stick_P;
-//+ Analoge Steuerung per Seriell
+                         StickYaw += ExternControl.Yaw;
-//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+                         ExternHeightValue =  (int16_t) ExternControl.Height * (int16_t)ParamSet.Height_Gain;
-   if(ExternControl.Config & 0x01 && Parameter_UserParam8 > 128)
+                         if(ExternControl.Thrust < StickThrust) StickThrust = ExternControl.Thrust;
+                }
-         StickNick += (int) ExternControl.Nick * (int) EE_Parameter.Stick_P;
+                if(StickThrust < 0) StickThrust = 0;
-         StickRoll += (int) ExternControl.Roll * (int) EE_Parameter.Stick_P;
+                // disable I part of gyro control feedback
-         StickGier += ExternControl.Gier;
+                if(ParamSet.GlobalConfig & CFG_HEADING_HOLD) Gyro_I_Factor =  0;
-     ExternHoehenValue =  (int) ExternControl.Hight * (int)EE_Parameter.Hoehe_Verstaerkung;
+                // avoid negative scaling factors
+                if(Gyro_P_Factor < 0) Gyro_P_Factor = 0;
-     if(ExternControl.Gas < StickGas) StickGas = ExternControl.Gas;
+                if(Gyro_I_Factor < 0) Gyro_I_Factor = 0;
-    }
     if(StickGas < 0) StickGas = 0;
                 // update max stick positions for pitch and roll
-    if(EE_Parameter.GlobalConfig & CFG_HEADING_HOLD) IntegralFaktor =  0;
-    if(GyroFaktor < 0) GyroFaktor = 0;
+                if(abs(StickPitch / STICK_GAIN) > MaxStickPitch) MaxStickPitch = abs(StickPitch)/STICK_GAIN;
-    if(IntegralFaktor < 0) IntegralFaktor = 0;
+                else MaxStickPitch--;
+                if(abs(StickRoll / STICK_GAIN) > MaxStickRoll) MaxStickRoll = abs(StickRoll)/STICK_GAIN;
-    if(abs(StickNick/STICK_GAIN) > MaxStickNick) MaxStickNick = abs(StickNick)/STICK_GAIN; else MaxStickNick--;
+                else MaxStickRoll--;
-    if(abs(StickRoll/STICK_GAIN) > MaxStickRoll) MaxStickRoll = abs(StickRoll)/STICK_GAIN; else MaxStickRoll--;
-    if(Notlandung)  {MaxStickNick = 0; MaxStickRoll = 0;}
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // Looping?
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // Looping?
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+                if((PPM_in[ParamSet.ChannelAssignment[CH_ROLL]] > ParamSet.LoopThreshold) && ParamSet.LoopConfig & CFG_LOOP_LEFT)  Looping_Left = 1;
-  if((PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] > EE_Parameter.LoopThreshold) && EE_Parameter.LoopConfig & CFG_LOOP_LINKS)  Looping_Links = 1;
+                else
   else
-   {
+                        if(Looping_Left) // Hysteresis
+                        {
-      if((PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] < (EE_Parameter.LoopThreshold - EE_Parameter.LoopHysterese))) Looping_Links = 0;
+                                if((PPM_in[ParamSet.ChannelAssignment[CH_ROLL]] < (ParamSet.LoopThreshold - ParamSet.LoopHysteresis))) Looping_Left = 0;
-     }
+                        }
+                }
-  if((PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] < -EE_Parameter.LoopThreshold) && EE_Parameter.LoopConfig & CFG_LOOP_RECHTS) Looping_Rechts = 1;
+                if((PPM_in[ParamSet.ChannelAssignment[CH_ROLL]] < -ParamSet.LoopThreshold) && ParamSet.LoopConfig & CFG_LOOP_RIGHT) Looping_Right = 1;
-   else
+                else
+                {
-   if(Looping_Rechts) // Hysterese
+                        if(Looping_Right) // Hysteresis
+                        {
-      if(PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] > -(EE_Parameter.LoopThreshold - EE_Parameter.LoopHysterese)) Looping_Rechts = 0;
+                                if(PPM_in[ParamSet.ChannelAssignment[CH_ROLL]] > -(ParamSet.LoopThreshold - ParamSet.LoopHysteresis)) Looping_Right = 0;
-     }
+                        }
-   }
+                }
+                if((PPM_in[ParamSet.ChannelAssignment[CH_PITCH]] > ParamSet.LoopThreshold) && ParamSet.LoopConfig & CFG_LOOP_UP) Looping_Top = 1;
-  if((PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] > EE_Parameter.LoopThreshold) && EE_Parameter.LoopConfig & CFG_LOOP_OBEN) Looping_Oben = 1;
+                else
-  else
+                {
                         if(Looping_Top)  // Hysteresis
-    if(Looping_Oben)  // Hysterese
+                        {
                                 if((PPM_in[ParamSet.ChannelAssignment[CH_PITCH]] < (ParamSet.LoopThreshold - ParamSet.LoopHysteresis))) Looping_Top = 0;
+                        }
+                }
+                if((PPM_in[ParamSet.ChannelAssignment[CH_PITCH]] < -ParamSet.LoopThreshold) && ParamSet.LoopConfig & CFG_LOOP_DOWN) Looping_Down = 1;
+                else
+                {
+                        if(Looping_Down) // Hysteresis
+                        {
-      if((PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] < (EE_Parameter.LoopThreshold - EE_Parameter.LoopHysterese))) Looping_Oben = 0;
+                                if(PPM_in[ParamSet.ChannelAssignment[CH_PITCH]] > -(ParamSet.LoopThreshold - ParamSet.LoopHysteresis)) Looping_Down = 0;
-     }
+                        }
+                }
-  if((PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] < -EE_Parameter.LoopThreshold) && EE_Parameter.LoopConfig & CFG_LOOP_UNTEN) Looping_Unten = 1;
+                if(Looping_Left || Looping_Right)   Looping_Roll = 1; else Looping_Roll = 0;
-   else
+                if(Looping_Top  || Looping_Down) {Looping_Pitch = 1; Looping_Roll = 0; Looping_Left = 0; Looping_Right = 0;} else Looping_Pitch = 0;
-   {
+        } // End of new RC-Values or Emergency Landing
-    if(Looping_Unten) // Hysterese
-      if(PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] > -(EE_Parameter.LoopThreshold - EE_Parameter.LoopHysterese)) Looping_Unten = 0;
+        if(Looping_Roll) BeepTime = 100;
-     }
+        if(Looping_Roll || Looping_Pitch)
+        {
+                if(ThrustMixFraction > ParamSet.LoopThrustLimit) ThrustMixFraction = ParamSet.LoopThrustLimit;
+        }
    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
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+//+ LED Control on J16/J17
-  if(Looping_Roll) beeptime = 100;
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-  if(Looping_Roll || Looping_Nick)
-   {
+        LED1_Time = FCParam.UserParam7;
-    if(GasMischanteil > EE_Parameter.LoopGasLimit) GasMischanteil = EE_Parameter.LoopGasLimit;
+        LED2_Time = FCParam.UserParam8;
-   }
+        LED_Update();
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// in case of emergency landing
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+        // set all inputs to save values
+        if(EmergencyLanding)
-// Bei Empfangsausfall im Flug
+        {
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+                StickYaw = 0;
+                StickPitch = 0;
-   if(Notlandung)
+                StickRoll = 0;
-    {
+                Gyro_P_Factor  = (float) 100 / (256.0 / STICK_GAIN);
-     StickGier = 0;
-     StickNick = 0;
+                Gyro_I_Factor = (float) 120 / (44000 / STICK_GAIN);
-     StickRoll = 0;
+                Looping_Roll = 0;
-     GyroFaktor     = (float) 100 / (256.0 / STICK_GAIN);
+                Looping_Pitch = 0;
-     IntegralFaktor = (float) 120 / (44000 / STICK_GAIN);
+                MaxStickPitch = 0;
-     Looping_Roll = 0;
+                MaxStickRoll = 0;
-     Looping_Nick = 0;
+        }
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// Trim Gyro-Integrals to ACC-Signals
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-// Integrale auf ACC-Signal abgleichen
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+        #define BALANCE_NUMBER 256L
-#define ABGLEICH_ANZAHL 256L
+        // sum for averaging
         MeanIntegralPitch  += IntegralPitch;
+        MeanIntegralRoll  += IntegralRoll;
  MittelIntegralNick  += IntegralNick;    // Für die Mittelwertbildung aufsummieren
+        if(Looping_Pitch || Looping_Roll) // if looping in any direction
- MittelIntegralRoll  += IntegralRoll;
+        {
- MittelIntegralNick2 += IntegralNick2;
+                // reset averaging for acc and gyro integral as well as gyro integral acc correction
- MittelIntegralRoll2 += IntegralRoll2;
+                MeasurementCounter = 0;
- if(Looping_Nick || Looping_Roll)
+                IntegralAccPitch = 0;
-  {
+                IntegralAccRoll = 0;
     IntegralAccNick = 0;
-    IntegralAccRoll = 0;
+                MeanIntegralPitch = 0;
-    MittelIntegralNick = 0;
+                MeanIntegralRoll = 0;
     MittelIntegralRoll = 0;
-    MittelIntegralNick2 = 0;
+                Reading_IntegralGyroPitch2 = Reading_IntegralGyroPitch;
+                Reading_IntegralGyroRoll2 = Reading_IntegralGyroRoll;
-    MittelIntegralRoll2 = 0;
-    Mess_IntegralNick2 = Mess_IntegralNick;
+                AttitudeCorrectionPitch = 0;
-    Mess_IntegralRoll2 = Mess_IntegralRoll;
+                AttitudeCorrectionRoll = 0;
-    ZaehlMessungen = 0;
+        }
-    LageKorrekturNick = 0;
-    LageKorrekturRoll = 0;
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-  }
+        if(!Looping_Pitch && !Looping_Roll) // if not lopping in any direction
+        {
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+                int32_t tmp_long, tmp_long2;
-  if(!Looping_Nick && !Looping_Roll)
+                // determine the deviation of gyro integral from averaged acceleration sensor
-  {
+                tmp_long   =  (int32_t)(IntegralPitch / ParamSet.GyroAccFactor - (int32_t)Mean_AccPitch);
-   long tmp_long, tmp_long2;
+                tmp_long  /= 16;
-    tmp_long = (long)(IntegralNick / EE_Parameter.GyroAccFaktor - (long)Mittelwert_AccNick);
+                tmp_long2  = (int32_t)(IntegralRoll   / ParamSet.GyroAccFactor - (int32_t)Mean_AccRoll);
-    tmp_long2 = (long)(IntegralRoll / EE_Parameter.GyroAccFaktor - (long)Mittelwert_AccRoll);
+                tmp_long2 /= 16;
-    tmp_long /= 16;
+                if((MaxStickPitch > 32) || (MaxStickRoll > 32)) // reduce effect during stick commands
+                {
+                        tmp_long  /= 3;
-    tmp_long2 /= 16;
+                        tmp_long2 /= 3;
-   if((MaxStickNick > 32) || (MaxStickRoll > 32))
+                }
+                if(abs(PPM_in[ParamSet.ChannelAssignment[CH_YAW]]) > 25) // reduce further if yaw stick is active
-    {
+                {
-    tmp_long  /= 3;
+                        tmp_long  /= 3;
+                        tmp_long2 /= 3;
-    tmp_long2 /= 3;
+                }
-    }
-   if(abs(PPM_in[EE_Parameter.Kanalbelegung[K_GIER]]) > 25)
+                #define BALANCE 32
-    {
+                // limit correction effect
-    tmp_long  /= 3;
+                if(tmp_long >  BALANCE)  tmp_long  = BALANCE;
+                if(tmp_long < -BALANCE)  tmp_long  =-BALANCE;
-    tmp_long2 /= 3;
+                if(tmp_long2 > BALANCE)  tmp_long2 = BALANCE;
-    }
+                if(tmp_long2 <-BALANCE)  tmp_long2 =-BALANCE;
+                // correct current readings
                 Reading_IntegralGyroPitch -= tmp_long;
+                Reading_IntegralGyroRoll -= tmp_long2;
- #define AUSGLEICH 32
+        }
-    if(tmp_long >  AUSGLEICH)  tmp_long  = AUSGLEICH;
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+        // MeasurementCounter is incremented in the isr of analog.c
-    if(tmp_long < -AUSGLEICH)  tmp_long  =-AUSGLEICH;
-    if(tmp_long2 > AUSGLEICH)  tmp_long2 = AUSGLEICH;
-    if(tmp_long2 <-AUSGLEICH)  tmp_long2 =-AUSGLEICH;
+        if(MeasurementCounter >= BALANCE_NUMBER) // averaging number has reached
     Mess_IntegralNick -= tmp_long;
-    Mess_IntegralRoll -= tmp_long2;
+                static int16_t cnt = 0;
-  }
+                static int8_t last_n_p, last_n_n, last_r_p, last_r_n;
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+                static int32_t MeanIntegralPitch_old, MeanIntegralRoll_old;
- if(ZaehlMessungen >= ABGLEICH_ANZAHL)
+                // if not lopping in any direction (this should be alwais the case,
                 // because the Measurement counter is reset to 0 if looping in any direction is active.)
-  static int cnt = 0;
+                if(!Looping_Pitch && !Looping_Roll && !FunnelCourse)
-  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 && !TrichterFlug)
+                        // Calculate mean value of the gyro integrals
-  {
+                        MeanIntegralPitch /= BALANCE_NUMBER;
-    MittelIntegralNick  /= ABGLEICH_ANZAHL;
-    MittelIntegralRoll  /= ABGLEICH_ANZAHL;
-        IntegralAccNick = (EE_Parameter.GyroAccFaktor * IntegralAccNick) / ABGLEICH_ANZAHL;
+                        MeanIntegralRoll  /= BALANCE_NUMBER;
-        IntegralAccRoll = (EE_Parameter.GyroAccFaktor * IntegralAccRoll) / ABGLEICH_ANZAHL;
-    IntegralAccZ    = IntegralAccZ / ABGLEICH_ANZAHL;
-#define MAX_I 0//(Poti2/10)
+                        // Calculate mean of the acceleration values
-// Nick ++++++++++++++++++++++++++++++++++++++++++++++++
-    IntegralFehlerNick = (long)(MittelIntegralNick - (long)IntegralAccNick);
-    ausgleichNick = IntegralFehlerNick / EE_Parameter.GyroAccAbgleich;
+                        IntegralAccPitch = (ParamSet.GyroAccFactor * IntegralAccPitch) / BALANCE_NUMBER;
-// Roll ++++++++++++++++++++++++++++++++++++++++++++++++
+                        IntegralAccRoll  = (ParamSet.GyroAccFactor * IntegralAccRoll ) / BALANCE_NUMBER;
-    IntegralFehlerRoll = (long)(MittelIntegralRoll - (long)IntegralAccRoll);
-    ausgleichRoll = IntegralFehlerRoll / EE_Parameter.GyroAccAbgleich;
-    LageKorrekturNick = ausgleichNick / ABGLEICH_ANZAHL;
-    LageKorrekturRoll = ausgleichRoll / ABGLEICH_ANZAHL;
-   if((MaxStickNick > 32) || (MaxStickRoll > 32) || (abs(PPM_in[EE_Parameter.Kanalbelegung[K_GIER]]) > 25))
-    {
-     LageKorrekturNick /= 2;
-     LageKorrekturRoll /= 2;
-    }
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-// Gyro-Drift ermitteln
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+                        // Pitch ++++++++++++++++++++++++++++++++++++++++++++++++
+                        // Calculate deviation of the averaged gyro integral and the averaged acceleration integral
+                        IntegralErrorPitch = (int32_t)(MeanIntegralPitch - (int32_t)IntegralAccPitch);
+                        CorrectionPitch = IntegralErrorPitch / ParamSet.GyroAccTrim;
+                        AttitudeCorrectionPitch = CorrectionPitch / BALANCE_NUMBER;
+                        // Roll ++++++++++++++++++++++++++++++++++++++++++++++++
+                        // Calculate deviation of the averaged gyro integral and the averaged acceleration integral
+                        IntegralErrorRoll = (int32_t)(MeanIntegralRoll - (int32_t)IntegralAccRoll);
-    MittelIntegralNick2 /= ABGLEICH_ANZAHL;
+                        CorrectionRoll  = IntegralErrorRoll / ParamSet.GyroAccTrim;
-    MittelIntegralRoll2 /= ABGLEICH_ANZAHL;
+                        AttitudeCorrectionRoll  = CorrectionRoll  / BALANCE_NUMBER;
     tmp_long  = IntegralNick2 - IntegralNick;
-    tmp_long2 = IntegralRoll2 - IntegralRoll;
+                        if((MaxStickPitch > 32) || (MaxStickRoll > 32) || (abs(PPM_in[ParamSet.ChannelAssignment[CH_YAW]]) > 25))
-    //DebugOut.Analog[25] = MittelIntegralRoll2 / 26;
+                        {
+                                AttitudeCorrectionPitch /= 2;
-    IntegralFehlerNick = tmp_long;
+                                AttitudeCorrectionRoll /= 2;
-    IntegralFehlerRoll = tmp_long2;
+                        }
-    Mess_IntegralNick2 -= IntegralFehlerNick;
+        // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-    Mess_IntegralRoll2 -= IntegralFehlerRoll;
+        // Gyro-Drift ermitteln
+        // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-//    IntegralFehlerNick = (IntegralFehlerNick * 1 + tmp_long) / 2;
+                        // deviation of gyro pitch integral (IntegralPitch is corrected by averaged acc sensor)
-//    IntegralFehlerRoll = (IntegralFehlerRoll * 1 + tmp_long2) / 2;
+                        IntegralErrorPitch  = IntegralPitch2 - IntegralPitch;
-    if(GierGyroFehler > ABGLEICH_ANZAHL/2) AdNeutralGier++;
+                        Reading_IntegralGyroPitch2 -= IntegralErrorPitch;
-    if(GierGyroFehler <-ABGLEICH_ANZAHL/2) AdNeutralGier--;
+                        // deviation of gyro pitch integral (IntegralPitch is corrected by averaged acc sensor)
+                        IntegralErrorRoll = IntegralRoll2 - IntegralRoll;
-DebugOut.Analog[22] = MittelIntegralRoll / 26;
+                        Reading_IntegralGyroRoll2 -= IntegralErrorRoll;
-    GierGyroFehler = 0;
+                        if(YawGyroDrift >  BALANCE_NUMBER/2) AdNeutralYaw++;
                         if(YawGyroDrift < -BALANCE_NUMBER/2) AdNeutralYaw--;
+                        YawGyroDrift = 0;
+/*
-/*DebugOut.Analog[17] = IntegralAccNick / 26;
+                        DebugOut.Analog[17] = IntegralAccPitch / 26;
-DebugOut.Analog[18] = IntegralAccRoll / 26;
+                        DebugOut.Analog[18] = IntegralAccRoll / 26;
-DebugOut.Analog[19] = IntegralFehlerNick;// / 26;
+                        DebugOut.Analog[19] = IntegralErrorPitch;// / 26;
-DebugOut.Analog[20] = IntegralFehlerRoll;// / 26;
+                        DebugOut.Analog[20] = IntegralErrorRoll;// / 26;
-*/
+                        DebugOut.Analog[21] = MeanIntegralPitch / 26;
-//DebugOut.Analog[21] = MittelIntegralNick / 26;
+                        DebugOut.Analog[22] = MeanIntegralRoll / 26;
-//MittelIntegralRoll = MittelIntegralRoll;
+                        //DebugOut.Analog[28] = CorrectionPitch;
-//DebugOut.Analog[28] = ausgleichNick;
+                        DebugOut.Analog[29] = CorrectionRoll;
-/*
+                        DebugOut.Analog[30] = AttitudeCorrectionRoll * 10;
-DebugOut.Analog[29] = ausgleichRoll;
+*/
-DebugOut.Analog[30] = LageKorrekturRoll * 10;
+                        #define ERROR_LIMIT  (BALANCE_NUMBER * 4)
-*/
+                        #define ERROR_LIMIT2 (BALANCE_NUMBER * 16)
                         #define MOVEMENT_LIMIT 20000
-#define FEHLER_LIMIT  (ABGLEICH_ANZAHL * 4)
+        // Pitch +++++++++++++++++++++++++++++++++++++++++++++++++
-#define FEHLER_LIMIT2 (ABGLEICH_ANZAHL * 16)
+                        cnt = 1;// + labs(IntegralErrorPitch) / 4096;
-#define BEWEGUNGS_LIMIT 20000
+                        CorrectionPitch = 0;
-// Nick +++++++++++++++++++++++++++++++++++++++++++++++++
+                        if(labs(MeanIntegralPitch_old - MeanIntegralPitch) < MOVEMENT_LIMIT)
-        cnt = 1;// + labs(IntegralFehlerNick) / 4096;
+                        {
+                                if(IntegralErrorPitch >  ERROR_LIMIT2)
-        if(labs(MittelIntegralNick_Alt - MittelIntegralNick) < BEWEGUNGS_LIMIT)
+                                {
-        {
+                                        if(last_n_p)
         if(IntegralFehlerNick >  FEHLER_LIMIT2)
-         {
+                                                cnt += labs(IntegralErrorPitch) / ERROR_LIMIT2;
-           if(last_n_p)
-           {
+                                                CorrectionPitch = IntegralErrorPitch / 8;
-            cnt += labs(IntegralFehlerNick) / FEHLER_LIMIT2;
+                                                if(CorrectionPitch > 5000) CorrectionPitch = 5000;
-            ausgleichNick = IntegralFehlerNick / 8;
+                                                AttitudeCorrectionPitch += CorrectionPitch / BALANCE_NUMBER;
-            if(ausgleichNick > 5000) ausgleichNick = 5000;
+                                        }
-            LageKorrekturNick += ausgleichNick / ABGLEICH_ANZAHL;
+                                        else last_n_p = 1;
+                                }
-           else last_n_p = 1;
+                                else  last_n_p = 0;
-         } else  last_n_p = 0;
+                                if(IntegralErrorPitch < -ERROR_LIMIT2)
-        if(IntegralFehlerNick < -FEHLER_LIMIT2)
+                                {
-         {
+                                        if(last_n_n)
-           if(last_n_n)
+                                        {
                                                 cnt += labs(IntegralErrorPitch) / ERROR_LIMIT2;
-             cnt += labs(IntegralFehlerNick) / FEHLER_LIMIT2;
+                                                CorrectionPitch = IntegralErrorPitch / 8;
+                                                if(CorrectionPitch < -5000) CorrectionPitch = -5000;
-             ausgleichNick = IntegralFehlerNick / 8;
+                                                AttitudeCorrectionPitch += CorrectionPitch / BALANCE_NUMBER;
-             if(ausgleichNick < -5000) ausgleichNick = -5000;
+                                        }
-             LageKorrekturNick += ausgleichNick / ABGLEICH_ANZAHL;
+                                        else last_n_n = 1;
+                                }
-           else last_n_n = 1;
+                                else  last_n_n = 0;
-         } else  last_n_n = 0;
+                        }
-        }
+                        else
-        else
+                        {
-        {
+                                cnt = 0;
-         cnt = 0;
+                                BadCompassHeading = 500;
          KompassSignalSchlecht = 500;
+                        if(cnt > ParamSet.DriftComp) cnt = ParamSet.DriftComp;
-        }
+                        // correct Gyro Offsets
+                        if(IntegralErrorPitch >  ERROR_LIMIT)   AdNeutralPitch += cnt;
-        if(cnt > EE_Parameter.Driftkomp) cnt = EE_Parameter.Driftkomp;
+                        if(IntegralErrorPitch < -ERROR_LIMIT)   AdNeutralPitch -= cnt;
         if(IntegralFehlerNick >  FEHLER_LIMIT)   AdNeutralNick += cnt;
-        if(IntegralFehlerNick < -FEHLER_LIMIT)   AdNeutralNick -= cnt;
+        // Roll +++++++++++++++++++++++++++++++++++++++++++++++++
+                        cnt = 1;// + labs(IntegralErrorPitch) / 4096;
-// Roll +++++++++++++++++++++++++++++++++++++++++++++++++
+                        CorrectionRoll = 0;
-        cnt = 1;// + labs(IntegralFehlerNick) / 4096;
+                        if(labs(MeanIntegralRoll_old - MeanIntegralRoll) < MOVEMENT_LIMIT)
+                        {
-        ausgleichRoll = 0;
+                                if(IntegralErrorRoll >  ERROR_LIMIT2)
-        if(labs(MittelIntegralRoll_Alt - MittelIntegralRoll) < BEWEGUNGS_LIMIT)
+                                {
+                                        if(last_r_p)
-        {
+                                        {
-        if(IntegralFehlerRoll >  FEHLER_LIMIT2)
+                                                cnt += labs(IntegralErrorRoll) / ERROR_LIMIT2;
                                                 CorrectionRoll = IntegralErrorRoll / 8;
-           if(last_r_p)
+                                                if(CorrectionRoll > 5000) CorrectionRoll = 5000;
                                                 AttitudeCorrectionRoll += CorrectionRoll / BALANCE_NUMBER;
-            cnt += labs(IntegralFehlerRoll) / FEHLER_LIMIT2;
+                                        }
-            ausgleichRoll = IntegralFehlerRoll / 8;
+                                        else last_r_p = 1;
-            if(ausgleichRoll > 5000) ausgleichRoll = 5000;
+                                }
-            LageKorrekturRoll += ausgleichRoll / ABGLEICH_ANZAHL;
+                                else  last_r_p = 0;
-           }
+                                if(IntegralErrorRoll < -ERROR_LIMIT2)
            else last_r_p = 1;
-         } else  last_r_p = 0;
+                                        if(last_r_n)
+                                        {
+                                                cnt += labs(IntegralErrorRoll) / ERROR_LIMIT2;
+                                                CorrectionRoll = IntegralErrorRoll / 8;
+                                                if(CorrectionRoll < -5000) CorrectionRoll = -5000;
+                                                AttitudeCorrectionRoll += CorrectionRoll / BALANCE_NUMBER;
         if(IntegralFehlerRoll < -FEHLER_LIMIT2)
-         {
+                                        else last_r_n = 1;
-           if(last_r_n)
+                                }
                                 else  last_r_n = 0;
+                        }
-            cnt += labs(IntegralFehlerRoll) / FEHLER_LIMIT2;
+                        else
             ausgleichRoll = IntegralFehlerRoll / 8;
-            if(ausgleichRoll < -5000) ausgleichRoll = -5000;
+                                cnt = 0;
-            LageKorrekturRoll += ausgleichRoll / ABGLEICH_ANZAHL;
-           }
+                                BadCompassHeading = 500;
-           else last_r_n = 1;
+                        }
-         } else  last_r_n = 0;
-        } else
+                        // correct Gyro Offsets
-        {
+                        if(cnt > ParamSet.DriftComp) cnt = ParamSet.DriftComp;
-         cnt = 0;
-         KompassSignalSchlecht = 500;
+                        if(IntegralErrorRoll >  ERROR_LIMIT)   AdNeutralRoll += cnt;
-        }
+                        if(IntegralErrorRoll < -ERROR_LIMIT)   AdNeutralRoll -= cnt;
 /*
-        if(cnt > EE_Parameter.Driftkomp) cnt = EE_Parameter.Driftkomp;
-        if(IntegralFehlerRoll >  FEHLER_LIMIT)   AdNeutralRoll += cnt;
+                        DebugOut.Analog[27] = CorrectionRoll;
-        if(IntegralFehlerRoll < -FEHLER_LIMIT)   AdNeutralRoll -= cnt;
+                        DebugOut.Analog[23] = AdNeutralPitch;//10*(AdNeutralPitch - StartNeutralPitch);
-/*DebugOut.Analog[27] = ausgleichRoll;
+                        DebugOut.Analog[24] = 10*(AdNeutralRoll - StartNeutralRoll);
-DebugOut.Analog[23] = AdNeutralNick;//10*(AdNeutralNick - StartNeutralNick);
+*/
-DebugOut.Analog[24] = 10*(AdNeutralRoll - StartNeutralRoll);
+                }
-*/
+                else // looping is active
-  }
+                {
-  else
+                        AttitudeCorrectionRoll  = 0;
                         AttitudeCorrectionPitch = 0;
+                        FunnelCourse = 0;
-   LageKorrekturRoll = 0;
+                }
-   LageKorrekturNick = 0;
-   TrichterFlug = 0;
+                // if Gyro_I_Factor == 0 , for example at Heading Hold, ignore attitude correction
+                if(!Gyro_I_Factor)
-  }
+                {
+                        AttitudeCorrectionRoll  = 0;
+                        AttitudeCorrectionPitch = 0;
-  if(!IntegralFaktor) { LageKorrekturRoll = 0; LageKorrekturNick = 0;} // z.B. bei HH
+                }
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++
+        // +++++++++++++++++++++++++++++++++++++++++++++++++++++
-   MittelIntegralNick_Alt = MittelIntegralNick;
+                MeanIntegralPitch_old = MeanIntegralPitch;
-   MittelIntegralRoll_Alt = MittelIntegralRoll;
+                MeanIntegralRoll_old  = MeanIntegralRoll;
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++
+        // +++++++++++++++++++++++++++++++++++++++++++++++++++++
+                // reset variables used for averaging
+                IntegralAccPitch = 0;
+                IntegralAccRoll = 0;
-    IntegralAccNick = 0;
+                MeanIntegralPitch = 0;
+                MeanIntegralRoll = 0;
+                MeasurementCounter = 0;
+        } // end of averaging
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+//  Yawing
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+        if(abs(StickYaw) > 15 ) // yaw stick is activated
+        {
+                if(!(ParamSet.GlobalConfig & CFG_COMPASS_FIX))
     IntegralAccRoll = 0;
+                        UpdateCompassCourse = 1;
+                        CompassCourse = YawGyroHeading;
+                        BadCompassHeading = 250;
+                }
+        }
-    IntegralAccZ = 0;
+        // exponential stick sensitivity in yawring rate
-    MittelIntegralNick = 0;
+        tmp_int  = (int32_t) ParamSet.Yaw_P * ((int32_t)StickYaw * abs(StickYaw)) / 512L; // expo  y = ax + bx²
-    MittelIntegralRoll = 0;
+        tmp_int += (ParamSet.Yaw_P * StickYaw) / 4;
-    MittelIntegralNick2 = 0;
+        SetPointYaw = tmp_int;
-    MittelIntegralRoll2 = 0;
+        // trimm drift of Reading_IntegralGyroYaw with SetPointYaw(StickYaw)
-    ZaehlMessungen = 0;
+        Reading_IntegralGyroYaw -= tmp_int;
- }
+        // limit the effect
-//DebugOut.Analog[31] = StickRoll / (26*IntegralFaktor);
+        if(Reading_IntegralGyroYaw > 50000) Reading_IntegralGyroYaw = 50000;
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+        if(Reading_IntegralGyroYaw <-50000) Reading_IntegralGyroYaw =-50000;
-//  Gieren
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+//  Compass
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-//    if(GasMischanteil < 35) { if(StickGier > 10) StickGier = 10; else if(StickGier < -10) StickGier = -10;};
+    // compass code is used if Compass option is selected
+        if((ParamSet.GlobalConfig & CFG_COMPASS_ACTIVE))
-    if(abs(StickGier) > 15) // war 35
+        {
-     {
+                int16_t w, v, r,correction, error;
-      if(!(EE_Parameter.GlobalConfig & CFG_KOMPASS_FIX))
                 if(CompassCalState && MotorsOn == 0 )
          NeueKompassRichtungMerken = 1;
-         KompassStartwert = ErsatzKompass;
+                        SetCompassCalState();
-         KompassSignalSchlecht = 250;
-        };
+                        #ifdef USE_KILLAGREG
-     }
-    tmp_int  = (long) EE_Parameter.Gier_P * ((long)StickGier * abs(StickGier)) / 512L; // expo  y = ax + bx²
-    tmp_int += (EE_Parameter.Gier_P * StickGier) / 4;
+                        MM3_Calibrate();
-    sollGier = tmp_int;
-    Mess_Integral_Gier -= tmp_int;
-    if(Mess_Integral_Gier > 50000) Mess_Integral_Gier = 50000;  // begrenzen
+                        #endif
     if(Mess_Integral_Gier <-50000) Mess_Integral_Gier =-50000;
+                else
+                {
+                        #ifdef USE_KILLAGREG
+                        static uint8_t updCompass = 0;
+                        if (!updCompass--)
+                        {
+                                updCompass = 49; // update only at 2ms*50 = 100ms (10Hz)
+                                MM3_Heading();
+                        }
+                        #endif
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-//  Kompass
+                        // get maximum attitude angle
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-//DebugOut.Analog[29] = (MaxStickNick + MaxStickRoll);
+                        w = abs(IntegralPitch/512);
+                        v = abs(IntegralRoll /512);
+                        if(v > w) w = v;
-    if(KompassValue && (EE_Parameter.GlobalConfig & CFG_KOMPASS_AKTIV))
+                        // update compass course
                         if (w < 25 && UpdateCompassCourse && !BadCompassHeading)
+                        {
+                                BeepTime = 200;
+                                CompassCourse = YawGyroHeading / YAW_GYRO_DEG_FACTOR;
+                                UpdateCompassCourse = 0;
        int w,v,r,fehler,korrektur;
+                        // calculate the deviation of the yaw gyro heading and the compass heading
+                        if (CompassHeading < 0) error = 0; // disable yaw drift compensation if compass heading is undefined
+                        else error = ((540 + CompassHeading - (YawGyroHeading / YAW_GYRO_DEG_FACTOR)) % 360) - 180;
+                        correction = w / 8 + 1;
+                        YawGyroHeading += (error * 8) / correction;
+                        w = (w * FCParam.CompassYawEffect) / 64;
+                        w = FCParam.CompassYawEffect - w;
+                        if(w > 0)
+                        {
+                                if(BadCompassHeading)
+                                {       // wait a while
+                                        BadCompassHeading--;
+                                }
+                                else
+                                {   //
+                                        YawGyroDrift += error;
-       w = abs(IntegralNick /512); // mit zunehmender Neigung den Einfluss drosseln
+                                        v = 64 + (MaxStickPitch + MaxStickRoll) / 8;
-       v = abs(IntegralRoll /512);
+                                        // calc course deviation
-       if(v > w) w = v; // grösste Neigung ermitteln
+                                        r = ((540 + (YawGyroHeading / YAW_GYRO_DEG_FACTOR) - CompassCourse) % 360) - 180;
-       korrektur = w / 8 + 1;
+                                        v = (r * w) / v; // align to compass course
-       if(w < 25 && NeueKompassRichtungMerken && !KompassSignalSchlecht)
+                                        // limit yaw rate
-        {
+                                        w = 3 * FCParam.CompassYawEffect;
-         beeptime = 200;
-//         KompassStartwert = KompassValue;
+                                        if (v > w) v = w;
-         KompassStartwert = (ErsatzKompass/GIER_GRAD_FAKTOR);
+                                        else if (v < -w) v = -w;
-         NeueKompassRichtungMerken = 0;
+                                        Reading_IntegralGyroYaw += v;
-        }
+                                }
-       fehler = ((540 + KompassValue - (ErsatzKompass/GIER_GRAD_FAKTOR)) % 360) - 180;
+                        }
-       ErsatzKompass += (fehler * 8) / korrektur;
+                        else
-       w = (w * Parameter_KompassWirkung) / 64;           // auf die Wirkung normieren
+                        {  // ignore compass at extreme attitudes for a while
-       w = Parameter_KompassWirkung - w;                  // Wirkung ggf drosseln
+                                BadCompassHeading = 250;
        if(w > 0)
-        {
+                }
-          if(!KompassSignalSchlecht)
+        }
-          {
-           GierGyroFehler += fehler;
+        #ifdef USE_KILLAGREG
-           v = 64 + ((MaxStickNick + MaxStickRoll)) / 8;
-           r = ((540 + (ErsatzKompass/GIER_GRAD_FAKTOR) - KompassStartwert) % 360) - 180;
-//           r = KompassRichtung;
-           v = (r * w) / v;  // nach Kompass ausrichten
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-           w = 3 * Parameter_KompassWirkung;
-           if(v > w) v = w; // Begrenzen
-           else
+//  GPS
-           if(v < -w) v = -w;
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-           Mess_Integral_Gier += v;
+        if(ParamSet.GlobalConfig & CFG_GPS_ACTIVE)
+        {
-          if(KompassSignalSchlecht) KompassSignalSchlecht--;
+                GPS_I_Factor = FCParam.UserParam2;
                 GPS_P_Factor = FCParam.UserParam5;
-    DebugOut.Analog[21] = motor_rx[4];
+                DebugOut.Analog[21] = motor_rx[4];
-    DebugOut.Analog[22] = motor_rx[5];
+                DebugOut.Analog[22] = motor_rx[5];
-    DebugOut.Analog[23] = motor_rx[6];
+                DebugOut.Analog[23] = motor_rx[6];
-    DebugOut.Analog[24] = motor_rx[7];
+                DebugOut.Analog[24] = motor_rx[7];
-    DebugOut.Analog[25] = motor_rx[4] + motor_rx[5] + motor_rx[6] + motor_rx[7];
+                DebugOut.Analog[25] = motor_rx[4] + motor_rx[5] + motor_rx[6] + motor_rx[7];
+                DebugOut.Analog[9]  = Reading_GyroPitch;
+                DebugOut.Analog[9]  = SetPointHeight;
+                DebugOut.Analog[10] = Reading_IntegralGyroYaw / 128;
+                DebugOut.Analog[10] = FCParam.Gyro_I;
+                DebugOut.Analog[10] = ParamSet.Gyro_I;
+                DebugOut.Analog[9]  = CompassOffCourse;
+                DebugOut.Analog[10] = ThrustMixFraction;
+                DebugOut.Analog[3]  = HeightD * 32;
+                DebugOut.Analog[4]  = HeightControlThrust;
-*/
+                */
-//    DebugOut.Analog[9] = MesswertNick;
-//    DebugOut.Analog[9] = SollHoehe;
-//    DebugOut.Analog[10] = Mess_Integral_Gier / 128;
-//    DebugOut.Analog[11] = KompassStartwert;
-//    DebugOut.Analog[10] = Parameter_Gyro_I;
-//    DebugOut.Analog[10] = EE_Parameter.Gyro_I;
-//    DebugOut.Analog[9] = KompassRichtung;
-//    DebugOut.Analog[10] = GasMischanteil;
-//    DebugOut.Analog[3] = HoeheD * 32;
-//    DebugOut.Analog[4] = hoehenregler;
+        }
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-//  Drehgeschwindigkeit und -winkel zu einem Istwert zusammenfassen
+//  calculate control feedback from angle (gyro integral) and agular velocity (gyro signal)
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-    if(Looping_Nick) MesswertNick = MesswertNick * GyroFaktor;
+        if(Looping_Pitch) Reading_GyroPitch = Reading_GyroPitch * Gyro_P_Factor;
-    else             MesswertNick = IntegralNick * IntegralFaktor + MesswertNick * GyroFaktor;
+        else Reading_GyroPitch = IntegralPitch * Gyro_I_Factor + Reading_GyroPitch * Gyro_P_Factor;
-    if(Looping_Roll) MesswertRoll = MesswertRoll * GyroFaktor;
+        if(Looping_Roll) Reading_GyroRoll = Reading_GyroRoll * Gyro_P_Factor;
-    else             MesswertRoll = IntegralRoll * IntegralFaktor + MesswertRoll * GyroFaktor;
+        else Reading_GyroRoll = IntegralRoll * Gyro_I_Factor + Reading_GyroRoll * Gyro_P_Factor;
-    MesswertGier =   MesswertGier * (2 * GyroFaktor) + Integral_Gier * IntegralFaktor / 2;
+        Reading_GyroYaw = Reading_GyroYaw * (2 * Gyro_P_Factor) + IntegralYaw * Gyro_I_Factor / 2;
-    DebugOut.Analog[21] = MesswertNick;
+        DebugOut.Analog[21] = Reading_GyroPitch;
-    DebugOut.Analog[22] = MesswertRoll;
+        DebugOut.Analog[22] = Reading_GyroRoll;
-    // Maximalwerte abfangen
+        // limit control feedback
-    #define MAX_SENSOR  (4096*STICK_GAIN)
+        #define MAX_SENSOR  (4096 * STICK_GAIN)
-    if(MesswertNick >  MAX_SENSOR) MesswertNick =  MAX_SENSOR;
+        if(Reading_GyroPitch >  MAX_SENSOR) Reading_GyroPitch =  MAX_SENSOR;
-    if(MesswertNick < -MAX_SENSOR) MesswertNick = -MAX_SENSOR;
+        if(Reading_GyroPitch < -MAX_SENSOR) Reading_GyroPitch = -MAX_SENSOR;
-    if(MesswertRoll >  MAX_SENSOR) MesswertRoll =  MAX_SENSOR;
+        if(Reading_GyroRoll  >  MAX_SENSOR) Reading_GyroRoll  =  MAX_SENSOR;
-    if(MesswertRoll < -MAX_SENSOR) MesswertRoll = -MAX_SENSOR;
+        if(Reading_GyroRoll  < -MAX_SENSOR) Reading_GyroRoll  = -MAX_SENSOR;
-    if(MesswertGier >  MAX_SENSOR) MesswertGier =  MAX_SENSOR;
+        if(Reading_GyroYaw   >  MAX_SENSOR) Reading_GyroYaw   =  MAX_SENSOR;
-    if(MesswertGier < -MAX_SENSOR) MesswertGier = -MAX_SENSOR;
+        if(Reading_GyroYaw   < -MAX_SENSOR) Reading_GyroYaw   = -MAX_SENSOR;
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-// Höhenregelung
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-// Die Höhenregelung schwächt lediglich das Gas ab, erhöht es allerdings nicht
+// Height Control
+// The height control algorithm reduces the thrust but does not increase the thrust.
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 //OCR0B = 180 - (Poti1 + 120) / 4;
-//DruckOffsetSetting = OCR0B;
+        ThrustMixFraction *= STICK_GAIN;
-  GasMischanteil *= STICK_GAIN;
+        // If height control is activated and no emergency landing is active
+        if((ParamSet.GlobalConfig & CFG_HEIGHT_CONTROL) && (!EmergencyLanding) )
- if((EE_Parameter.GlobalConfig & CFG_HOEHENREGELUNG))  // Höhenregelung
+        {
-  {
+                int tmp_int;
-    int tmp_int;
+                // if height control is activated by an rc channel
-    if(EE_Parameter.GlobalConfig & CFG_HOEHEN_SCHALTER)  // Regler wird über Schalter gesteuert
+                if(ParamSet.GlobalConfig & CFG_HEIGHT_SWITCH)
-    {
+                {       // check if parameter is less than activation threshold
-     if(Parameter_MaxHoehe < 50)
-      {
+                        if(FCParam.MaxHeight < 50)
-       SollHoehe = HoehenWert - 20;  // Parameter_MaxHoehe ist der PPM-Wert des Schalters
+                        {
-       HoehenReglerAktiv = 0;
+                                SetPointHeight = ReadingHeight - 20;  // update SetPoint with current reading
-      }
+                                HeightControlActive = 0; // disable height control
-      else
+                        }
-        HoehenReglerAktiv = 1;
+                        else HeightControlActive = 1; // enable height control
-    }
+                }
-    else
-    {
+                else // no switchable height control
-     SollHoehe = ((int) ExternHoehenValue + (int) Parameter_MaxHoehe) * (int)EE_Parameter.Hoehe_Verstaerkung - 20;
+                {
+                        SetPointHeight = ((int16_t) ExternHeightValue + (int16_t) FCParam.MaxHeight) * (int16_t)ParamSet.Height_Gain - 20;
-     HoehenReglerAktiv = 1;
+                        HeightControlActive = 1;
-    }
+                }
+                // get current height
+                h = ReadingHeight;
+                // if current height is above the setpoint reduce thrust
-    if(Notlandung) SollHoehe = 0;
+                if((h > SetPointHeight) && HeightControlActive)
+                {
-    h = HoehenWert;
+                        // ThrustMixFraction - HightDeviation * P  - HeightChange * D - ACCTop * DACC
-    if((h > SollHoehe) && HoehenReglerAktiv)      // zu hoch --> drosseln
+                        // height difference -> P control part
+                        h = ((h - SetPointHeight) * (int16_t) FCParam.Height_P) / (16 / STICK_GAIN);
-     {
+                        h = ThrustMixFraction - h; // reduce gas
-      h = ((h - SollHoehe) * (int) Parameter_Hoehe_P) / (16 / STICK_GAIN); // Differenz bestimmen --> P-Anteil
+                        // height gradient --> D control part
-      h = GasMischanteil - h;         // vom Gas abziehen
+                        //h -= (HeightD * FCParam.Height_D) / (8 / STICK_GAIN);  // D control part
-//      h -= (HoeheD * Parameter_Luftdruck_D)/(8/STICK_GAIN);    // D-Anteil
+                        h -= (HeightD) / (8 / STICK_GAIN);  // D control part
+                        // acceleration sensor effect
-      h -= (HoeheD)/(8/STICK_GAIN);    // D-Anteil
+                        tmp_int = ((Reading_Integral_Top / 128) * (int32_t) FCParam.Height_ACC_Effect) / (128 / STICK_GAIN);
+                        if(tmp_int > 70 * STICK_GAIN)        tmp_int =   70 * STICK_GAIN;
-      tmp_int = ((Mess_Integral_Hoch / 128) * (signed long) Parameter_Hoehe_ACC_Wirkung) / (128 / STICK_GAIN);
+                        else if(tmp_int < -(70 * STICK_GAIN)) tmp_int = -(70 * STICK_GAIN);
-      if(tmp_int > 70*STICK_GAIN) tmp_int = 70*STICK_GAIN;
+                        h -= tmp_int;
-      else if(tmp_int < -(70*STICK_GAIN)) tmp_int = -(70*STICK_GAIN);
+                        // update height control thrust
+                        HeightControlThrust = (HeightControlThrust*15 + h) / 16;
-      h -= tmp_int;
+                        // limit thrust reduction
-      hoehenregler = (hoehenregler*15 + h) / 16;
+                        if(HeightControlThrust < ParamSet.Height_MinThrust * STICK_GAIN)
+                        {
-      if(hoehenregler < EE_Parameter.Hoehe_MinGas * STICK_GAIN) // nicht unter MIN
+                                if(ThrustMixFraction >= ParamSet.Height_MinThrust * STICK_GAIN) HeightControlThrust = ParamSet.Height_MinThrust * STICK_GAIN;
-       {
+                                // allows landing also if thrust stick is reduced below min thrust on height control
-         if(GasMischanteil >= EE_Parameter.Hoehe_MinGas * STICK_GAIN) hoehenregler = EE_Parameter.Hoehe_MinGas * STICK_GAIN;
+                                if(ThrustMixFraction < ParamSet.Height_MinThrust * STICK_GAIN) HeightControlThrust = ThrustMixFraction;
          if(GasMischanteil < EE_Parameter.Hoehe_MinGas * STICK_GAIN) hoehenregler = GasMischanteil;
+                        // limit thrust to stick setting
-       }
+                        if(HeightControlThrust > ThrustMixFraction) HeightControlThrust = ThrustMixFraction;
-      if(hoehenregler > GasMischanteil) hoehenregler = GasMischanteil; // nicht mehr als Gas
+                        ThrustMixFraction = HeightControlThrust;
-      GasMischanteil = hoehenregler;
+                }
+        }
-  }
+        // limit thrust to parameter setting
-  if(GasMischanteil > (MAX_GAS - 20) * STICK_GAIN) GasMischanteil = (MAX_GAS - 20) * STICK_GAIN;
+        if(ThrustMixFraction > (ParamSet.Trust_Max - 20) * STICK_GAIN) ThrustMixFraction = (ParamSet.Trust_Max - 20) * STICK_GAIN;
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-// + Mischer und PI-Regler
+// + Mixer and PI-Controller
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-  DebugOut.Analog[7] = GasMischanteil;
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-// Gier-Anteil
+        DebugOut.Analog[7] = ThrustMixFraction;
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// Yaw-Fraction
-#define MUL_G  1.0
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-    GierMischanteil = MesswertGier - sollGier * STICK_GAIN;     // Regler für Gier
+    YawMixFraction = Reading_GyroYaw - SetPointYaw * STICK_GAIN;     // yaw controller
-// GierMischanteil = 0;
+        #define MIN_YAWTHRUST (40 * STICK_GAIN)  // yaw also below this thrust value
-#define MIN_GIERGAS  (40*STICK_GAIN)  // unter diesem Gaswert trotzdem Gieren
+        // limit YawMixFraction
-   if(GasMischanteil > MIN_GIERGAS)
+        if(ThrustMixFraction > MIN_YAWTHRUST)
+        {
-     if(GierMischanteil > (GasMischanteil / 2)) GierMischanteil = GasMischanteil / 2;
+                if(YawMixFraction >  (ThrustMixFraction / 2)) YawMixFraction = ThrustMixFraction / 2;
-     if(GierMischanteil < -(GasMischanteil / 2)) GierMischanteil = -(GasMischanteil / 2);
+                if(YawMixFraction < -(ThrustMixFraction / 2)) YawMixFraction = -(ThrustMixFraction / 2);
+        }
-    else
+        else
-    {
+        {
-     if(GierMischanteil > (MIN_GIERGAS / 2))  GierMischanteil = MIN_GIERGAS / 2;
+                if(YawMixFraction >  (MIN_YAWTHRUST / 2)) YawMixFraction = MIN_YAWTHRUST / 2;
-     if(GierMischanteil < -(MIN_GIERGAS / 2)) GierMischanteil = -(MIN_GIERGAS / 2);
+                if(YawMixFraction < -(MIN_YAWTHRUST / 2)) YawMixFraction = -(MIN_YAWTHRUST / 2);
-    }
+        }
-    tmp_int = MAX_GAS*STICK_GAIN;
+        tmp_int = ParamSet.Trust_Max * STICK_GAIN;
-    if(GierMischanteil > ((tmp_int - GasMischanteil))) GierMischanteil = ((tmp_int - GasMischanteil));
+    if(YawMixFraction >  ((tmp_int - ThrustMixFraction))) YawMixFraction =  ((tmp_int - ThrustMixFraction));
-    if(GierMischanteil < -((tmp_int - GasMischanteil))) GierMischanteil = -((tmp_int - GasMischanteil));
+    if(YawMixFraction < -((tmp_int - ThrustMixFraction))) YawMixFraction = -((tmp_int - ThrustMixFraction));
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-// Nick-Achse
+// Pitch-Axis
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-    DiffNick = MesswertNick - StickNick;        // Differenz bestimmen
+    DiffPitch = Reading_GyroPitch - StickPitch; // get difference
-    if(IntegralFaktor) SummeNick += IntegralNick * IntegralFaktor - StickNick; // I-Anteil bei Winkelregelung
+    if(Gyro_I_Factor) SumPitch += IntegralPitch * Gyro_I_Factor - StickPitch; // I-part for attitude control
-    else  SummeNick += DiffNick; // I-Anteil bei HH
+    else SumPitch += DiffPitch; // I-part for head holding
-    if(SummeNick >  (STICK_GAIN * 16000L)) SummeNick =  (STICK_GAIN * 16000L);
+    if(SumPitch >  (STICK_GAIN * 16000L)) SumPitch =  (STICK_GAIN * 16000L);
-    if(SummeNick < -(16000L * STICK_GAIN)) SummeNick = -(16000L * STICK_GAIN);
+    if(SumPitch < -(STICK_GAIN * 16000L)) SumPitch = -(STICK_GAIN * 16000L);
-    pd_ergebnis = DiffNick + Ki * SummeNick; // PI-Regler für Nick
+    pd_result = DiffPitch + Ki * SumPitch; // PI-controller for pitch
-    // Motor Vorn
+    tmp_int = (int32_t)((int32_t)FCParam.DynamicStability * (int32_t)(ThrustMixFraction + abs(YawMixFraction)/2)) / 64;
-    tmp_int = (long)((long)Parameter_DynamicStability * (long)(GasMischanteil + abs(GierMischanteil)/2)) / 64;
+    if(pd_result >  tmp_int) pd_result =  tmp_int;
-    if(pd_ergebnis >  tmp_int) pd_ergebnis =  tmp_int;
+    if(pd_result < -tmp_int) pd_result = -tmp_int;
-    if(pd_ergebnis < -tmp_int) pd_ergebnis = -tmp_int;
+        // Motor Front
-    motorwert = GasMischanteil + pd_ergebnis + GierMischanteil;   // Mischer
+    MotorValue = ThrustMixFraction + pd_result + YawMixFraction;          // Mixer
+    MotorValue /= STICK_GAIN;
-    motorwert /= STICK_GAIN;
+        if ((MotorValue < 0)) MotorValue = 0;
-        if ((motorwert < 0)) motorwert = 0;
+        else if(MotorValue > ParamSet.Trust_Max)            MotorValue = ParamSet.Trust_Max;
-        else if(motorwert > MAX_GAS)        motorwert = MAX_GAS;
+        if (MotorValue < ParamSet.Trust_Min)            MotorValue = ParamSet.Trust_Min;
-        if (motorwert < MIN_GAS)            motorwert = MIN_GAS;
+        Motor_Front = MotorValue;
-        Motor_Vorne = motorwert;
-    // Motor Heck
+ // Motor Rear
-        motorwert = GasMischanteil - pd_ergebnis + GierMischanteil;
+        MotorValue = ThrustMixFraction - pd_result + YawMixFraction;     // Mixer
-    motorwert /= STICK_GAIN;
+        MotorValue /= STICK_GAIN;
-        if ((motorwert < 0)) motorwert = 0;
+        if ((MotorValue < 0)) MotorValue = 0;
-        else if(motorwert > MAX_GAS)        motorwert = MAX_GAS;
+        else if(MotorValue > ParamSet.Trust_Max)            MotorValue = ParamSet.Trust_Max;
-        if (motorwert < MIN_GAS)            motorwert = MIN_GAS;
+        if (MotorValue < ParamSet.Trust_Min)            MotorValue = ParamSet.Trust_Min;
-        Motor_Hinten = motorwert;
+        Motor_Rear = MotorValue;
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-// Roll-Achse
+// Roll-Axis
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-        DiffRoll = MesswertRoll - StickRoll;    // Differenz bestimmen
+        DiffRoll = Reading_GyroRoll - StickRoll;        // get difference
-    if(IntegralFaktor) SummeRoll += IntegralRoll * IntegralFaktor - StickRoll;// I-Anteil bei Winkelregelung
+    if(Gyro_I_Factor) SumRoll += IntegralRoll * Gyro_I_Factor - StickRoll; // I-part for attitude control
-    else                 SummeRoll += DiffRoll;  // I-Anteil bei HH
+    else SumRoll += DiffRoll;  // I-part for head holding
-    if(SummeRoll >  16000) SummeRoll =  16000;
+    if(SumRoll >  16000) SumRoll =  16000;
+    if(SumRoll < -16000) SumRoll = -16000;
-    if(SummeRoll < -16000) SummeRoll = -16000;
+    pd_result = DiffRoll + Ki * SumRoll;         // PI-controller for roll
-    pd_ergebnis = DiffRoll + Ki * SummeRoll;    // PI-Regler für Roll
+    tmp_int = (int32_t)((int32_t)FCParam.DynamicStability * (int32_t)(ThrustMixFraction + abs(YawMixFraction)/2)) / 64;
-    tmp_int = (long)((long)Parameter_DynamicStability * (long)(GasMischanteil + abs(GierMischanteil)/2)) / 64;
+    if(pd_result >  tmp_int) pd_result =  tmp_int;
-    if(pd_ergebnis >  tmp_int) pd_ergebnis =  tmp_int;
+    if(pd_result < -tmp_int) pd_result = -tmp_int;
-    if(pd_ergebnis < -tmp_int) pd_ergebnis = -tmp_int;
-    // Motor Links
+    // Motor Left
-    motorwert = GasMischanteil + pd_ergebnis - GierMischanteil;
+    MotorValue = ThrustMixFraction + pd_result - YawMixFraction;  // Mixer
+    MotorValue /= STICK_GAIN;
-    motorwert /= STICK_GAIN;
+        if ((MotorValue < 0)) MotorValue = 0;
-        if ((motorwert < 0)) motorwert = 0;
+        else if(MotorValue > ParamSet.Trust_Max)                MotorValue = ParamSet.Trust_Max;
-        else if(motorwert > MAX_GAS)            motorwert = MAX_GAS;
+        if (MotorValue < ParamSet.Trust_Min)            MotorValue = ParamSet.Trust_Min;
-        if (motorwert < MIN_GAS)            motorwert = MIN_GAS;
+    Motor_Left = MotorValue;
-    Motor_Links = motorwert;
-    // Motor Rechts
+ // Motor Right
-        motorwert = GasMischanteil - pd_ergebnis - GierMischanteil;
+        MotorValue = ThrustMixFraction - pd_result - YawMixFraction;  // Mixer
-    motorwert /= STICK_GAIN;
-        if ((motorwert < 0)) motorwert = 0;
+        MotorValue /= STICK_GAIN;

Subversion Repositories FlightCtrl

(root)/branches/V0.69k Code Redesign killagreg/fc.c @ 1091 - Rev 885 → 886