Subversion Repositories FlightCtrl

/*#######################################################################################

Flight Control

#######################################################################################*/

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

// + Copyright (c) 04.2007 Holger Buss

// + Nur für den privaten Gebrauch

// + www.MikroKopter.com

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

// + Es gilt für das gesamte Projekt (Hardware, Software, Binärfiles, Sourcecode und Dokumentation),

// + dass eine Nutzung (auch auszugsweise) nur für den privaten (nicht-kommerziellen) Gebrauch zulässig ist.

// + Sollten direkte oder indirekte kommerzielle Absichten verfolgt werden, ist mit uns (info@mikrokopter.de) Kontakt

// + bzgl. der Nutzungsbedingungen aufzunehmen.

// + Eine kommerzielle Nutzung ist z.B.Verkauf von MikroKoptern, Bestückung und Verkauf von Platinen oder Bausätzen,

// + Verkauf von Luftbildaufnahmen, usw.

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

// + Werden Teile des Quellcodes (mit oder ohne Modifikation) weiterverwendet oder veröffentlicht,

// + unterliegen sie auch diesen Nutzungsbedingungen und diese Nutzungsbedingungen incl. Copyright müssen dann beiliegen

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

// + Sollte die Software (auch auszugesweise) oder sonstige Informationen des MikroKopter-Projekts

// + auf anderen Webseiten oder sonstigen Medien veröffentlicht werden, muss unsere Webseite "http://www.mikrokopter.de"

// + eindeutig als Ursprung verlinkt werden

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

// + Keine Gewähr auf Fehlerfreiheit, Vollständigkeit oder Funktion

// + Benutzung auf eigene Gefahr

// + Wir übernehmen keinerlei Haftung für direkte oder indirekte Personen- oder Sachschäden

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

// + Die Portierung der Software (oder Teile davon) auf andere Systeme (ausser der Hardware von www.mikrokopter.de) ist nur

// + mit unserer Zustimmung zulässig

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

// + Die Funktion printf_P() unterliegt ihrer eigenen Lizenz und ist hiervon nicht betroffen

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

// + Redistributions of source code (with or without modifications) must retain the above copyright notice,

// + this list of conditions and the following disclaimer.

// +   * Neither the name of the copyright holders nor the names of contributors may be used to endorse or promote products derived

// +     from this software without specific prior written permission.

// +   * The use of this project (hardware, software, binary files, sources and documentation) is only permittet

// +     for non-commercial use (directly or indirectly)

// +     Commercial use (for excample: selling of MikroKopters, selling of PCBs, assembly, ...) is only permitted

// +     with our written permission

// +   * If sources or documentations are redistributet on other webpages, out webpage (http://www.MikroKopter.de) must be

// +     clearly linked as origin

// +   * porting to systems other than hardware from www.mikrokopter.de is not allowed

// +  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

// +  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

// +  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

// +  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE

// +  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

// +  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

// +  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

// +  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN// +  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

// +  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

#ifdef USE_MK3MAG

#include "mk3mag.h"

#include "gps.h"

#endif

#include "led.h"

// gyro readings

int16_t Reading_GyroNick, Reading_GyroRoll, Reading_GyroYaw;

// gyro neutral readings

int16_t AdNeutralNick = 0, AdNeutralRoll = 0, AdNeutralYaw = 0;

int16_t StartNeutralRoll = 0, StartNeutralNick = 0;

// mean accelerations

int16_t Mean_AccNick, Mean_AccRoll, Mean_AccTop;

// neutral acceleration readings

volatile int16_t NeutralAccX=0, NeutralAccY=0;

volatile float NeutralAccZ = 0;

// attitude gyro integrals

int32_t IntegralNick = 0,IntegralNick2 = 0;

int32_t IntegralRoll = 0,IntegralRoll2 = 0;

int32_t IntegralYaw = 0;

int32_t Reading_IntegralGyroNick = 0, Reading_IntegralGyroNick2 = 0;

int32_t Reading_IntegralGyroRoll = 0, Reading_IntegralGyroRoll2 = 0;

int32_t Reading_IntegralGyroYaw = 0;

int32_t MeanIntegralNick;

int32_t MeanIntegralRoll;

// attitude acceleration integrals

int32_t IntegralAccNick = 0, IntegralAccRoll = 0;

volatile int32_t Reading_Integral_Top = 0;

// compass course

volatile int16_t CompassHeading = -1; // negative angle indicates invalid data.

volatile int16_t CompassCourse = -1;

volatile int16_t CompassOffCourse = 0;

volatile uint8_t CompassCalState = 0;

uint8_t FunnelCourse = 0;

uint16_t BadCompassHeading = 500;

int32_t YawGyroHeading;

int16_t YawGyroDrift;

int16_t NaviAccNick = 0, NaviAccRoll = 0, NaviCntAcc = 0;

// MK flags

uint16_t Model_Is_Flying = 0;

volatile uint8_t MKFlags = 0;

int32_t TurnOver180Nick = 250000L, TurnOver180Roll = 250000L;

float Gyro_P_Factor;

float Gyro_I_Factor;

int16_t  DiffNick, DiffRoll;

int16_t  Poti1 = 0, Poti2 = 0, Poti3 = 0, Poti4 = 0, Poti5 = 0, Poti6 = 0, Poti7 = 0, Poti8 = 0;

// setpoints for motors

volatile uint8_t Motor_Front, Motor_Rear, Motor_Right, Motor_Left;

// stick values derived by rc channels readings

int16_t StickNick = 0, StickRoll = 0, StickYaw = 0, StickGas = 0;

int16_t GPS_Nick = 0, GPS_Roll = 0;

int16_t MaxStickNick = 0, MaxStickRoll = 0;

// stick values derived by uart inputs

int16_t ExternStickNick = 0, ExternStickRoll = 0, ExternStickYaw = 0, ExternHeightValue = -20;

int16_t ReadingHeight = 0;

int16_t SetPointHeight = 0;

int16_t AttitudeCorrectionRoll = 0, AttitudeCorrectionNick = 0;

float Ki =  FACTOR_I;

uint8_t Looping_Nick = 0, Looping_Roll = 0;

uint8_t Looping_Left = 0, Looping_Right = 0, Looping_Down = 0, Looping_Top = 0;

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};

/************************************************************************/

/*  Creates numbeeps beeps at the speaker                               */

/************************************************************************/

void Beep(uint8_t numbeeps)

{

        while(numbeeps--)

        {

                if(MKFlags & MKFLAG_MOTOR_RUN) return; //auf keinen Fall bei laufenden Motoren!

                BeepTime = 100; // 0.1 second

                Delay_ms(250); // blocks 250 ms as pause to next beep,

                // this will block the flight control loop,

                // therefore do not use this funktion if motors are running

        }

}

/************************************************************************/

/*  Neutral Readings                                                    */

/************************************************************************/

void SetNeutral(void)

{

        NeutralAccX = 0;

        NeutralAccY = 0;

        NeutralAccZ = 0;

    AdNeutralNick = 0;

        AdNeutralRoll = 0;

        AdNeutralYaw = 0;

    FCParam.Yaw_PosFeedback = 0;

    FCParam.Yaw_NegFeedback = 0;

    CalibMean();

    Delay_ms_Mess(100);

        CalibMean();

    if((ParamSet.GlobalConfig & CFG_HEIGHT_CONTROL))  // Height Control activated?

    {

                if((ReadingAirPressure > 950) || (ReadingAirPressure < 750)) SearchAirPressureOffset();

    }

        AdNeutralNick = AdValueGyrNick;

        AdNeutralRoll  = AdValueGyrRoll;

        AdNeutralYaw   = AdValueGyrYaw;

        StartNeutralRoll  = AdNeutralRoll;

        StartNeutralNick = AdNeutralNick;

    if(GetParamWord(PID_ACC_NICK) > 1023)

    {

                NeutralAccY = abs(Mean_AccRoll) / ACC_AMPLIFY;

                NeutralAccX = abs(Mean_AccNick) / ACC_AMPLIFY;

                NeutralAccZ = Current_AccZ;

    }

    else

    {

                NeutralAccX = (int16_t)GetParamWord(PID_ACC_NICK);

            NeutralAccY = (int16_t)GetParamWord(PID_ACC_ROLL);

            NeutralAccZ = (int16_t)GetParamWord(PID_ACC_Z);

    }

        Reading_IntegralGyroNick = 0;

    Reading_IntegralGyroNick2 = 0;

    Reading_IntegralGyroRoll = 0;

    Reading_IntegralGyroRoll2 = 0;

    Reading_IntegralGyroYaw = 0;

    Reading_GyroNick = 0;

    Reading_GyroRoll = 0;

    Reading_GyroYaw = 0;

    Delay_ms_Mess(100);

    StartAirPressure = AirPressure;

    HeightD = 0;

    Reading_Integral_Top = 0;

    CompassCourse = CompassHeading;

    BeepTime = 50;

        TurnOver180Nick = ((int32_t) ParamSet.AngleTurnOverNick * 2500L) +15000L;

        TurnOver180Roll =  ((int32_t) ParamSet.AngleTurnOverRoll *  2500L) +15000L;

    ExternHeightValue = 0;

    GPS_Nick = 0;

    GPS_Roll = 0;

    YawGyroHeading = CompassHeading * YAW_GYRO_DEG_FACTOR;

    YawGyroDrift = 0;

    MKFlags |= MKFLAG_CALIBRATE;

}

/************************************************************************/

/*  Averaging Measurement Readings                                      */

/************************************************************************/

void Mean(void)

{

    static int32_t tmpl,tmpl2;

 // Get offset corrected gyro readings (~ to angular velocity)

    Reading_GyroYaw   = AdNeutralYaw    - AdValueGyrYaw;

    Reading_GyroRoll  = AdValueGyrRoll  - AdNeutralRoll;

    Reading_GyroNick = AdValueGyrNick - AdNeutralNick;

// Acceleration Sensor

        // sliding average sensor readings

        Mean_AccNick = ((int32_t)Mean_AccNick * 1 + ((ACC_AMPLIFY * (int32_t)AdValueAccNick))) / 2L;

        Mean_AccRoll  = ((int32_t)Mean_AccRoll * 1 + ((ACC_AMPLIFY * (int32_t)AdValueAccRoll))) / 2L;

        Mean_AccTop   = ((int32_t)Mean_AccTop * 1 + ((int32_t)AdValueAccTop)) / 2L;

        // sum sensor readings for later averaging

    IntegralAccNick += ACC_AMPLIFY * AdValueAccNick;

    IntegralAccRoll  += ACC_AMPLIFY * AdValueAccRoll;

    NaviAccNick += AdValueAccNick;

    NaviAccRoll  += AdValueAccRoll;

    NaviCntAcc++;

// Yaw

        // calculate yaw gyro integral (~ to rotation angle)

        Reading_IntegralGyroYaw  += Reading_GyroYaw;

        YawGyroHeading += Reading_GyroYaw;

    if(YawGyroHeading >= (360L * YAW_GYRO_DEG_FACTOR)) YawGyroHeading -= 360L * YAW_GYRO_DEG_FACTOR;  // 360° Wrap

        if(YawGyroHeading < 0)                             YawGyroHeading += 360L * YAW_GYRO_DEG_FACTOR;

        // Coupling fraction

        if(!Looping_Nick && !Looping_Roll && (ParamSet.GlobalConfig & CFG_AXIS_COUPLING_ACTIVE))

        {

                tmpl = (Reading_GyroYaw * Reading_IntegralGyroNick) / 2048L;

                tmpl *= FCParam.Yaw_PosFeedback;

                tmpl /= 4096L;

                tmpl2 = ( Reading_GyroYaw * Reading_IntegralGyroRoll) / 2048L;

                tmpl2 *= FCParam.Yaw_PosFeedback;

                tmpl2 /= 4096L;

                if(labs(tmpl) > 128 || labs(tmpl2) > 128) FunnelCourse = 1;

        }

        else  tmpl = tmpl2 = 0;

// Roll

        Reading_GyroRoll += tmpl;

        Reading_GyroRoll += (tmpl2 * FCParam.Yaw_NegFeedback) / 512L;

        Reading_IntegralGyroRoll2 += Reading_GyroRoll;

        Reading_IntegralGyroRoll +=  Reading_GyroRoll - AttitudeCorrectionRoll;

        if(Reading_IntegralGyroRoll > TurnOver180Roll)

        {

                Reading_IntegralGyroRoll  = -(TurnOver180Roll - 10000L);

                Reading_IntegralGyroRoll2 = Reading_IntegralGyroRoll;

        }

        if(Reading_IntegralGyroRoll < -TurnOver180Roll)

        {

                Reading_IntegralGyroRoll =  (TurnOver180Roll - 10000L);

                Reading_IntegralGyroRoll2 = Reading_IntegralGyroRoll;

        }

        if(AdValueGyrRoll < 15)   Reading_GyroRoll = -1000;

        if(AdValueGyrRoll <  7)   Reading_GyroRoll = -2000;

        if(BoardRelease == 10)

        {

                if(AdValueGyrRoll > 1010) Reading_GyroRoll = +1000;

                if(AdValueGyrRoll > 1017) Reading_GyroRoll = +2000;

        }

        else

        {

                if(AdValueGyrRoll > 2020) Reading_GyroRoll = +1000;

                if(AdValueGyrRoll > 2034) Reading_GyroRoll = +2000;

        }

// Nick

        Reading_GyroNick -= tmpl2;

        Reading_GyroNick -= (tmpl*FCParam.Yaw_NegFeedback) / 512L;

        Reading_IntegralGyroNick2 += Reading_GyroNick;

        Reading_IntegralGyroNick  += Reading_GyroNick - AttitudeCorrectionNick;

        if(Reading_IntegralGyroNick > TurnOver180Nick)

        {

         Reading_IntegralGyroNick = -(TurnOver180Nick - 25000L);

         Reading_IntegralGyroNick2 = Reading_IntegralGyroNick;

        }

        if(Reading_IntegralGyroNick < -TurnOver180Nick)

        {

         Reading_IntegralGyroNick =  (TurnOver180Nick - 25000L);

         Reading_IntegralGyroNick2 = Reading_IntegralGyroNick;

        }

        if(AdValueGyrNick < 15)   Reading_GyroNick = -1000;

        if(AdValueGyrNick <  7)   Reading_GyroNick = -2000;

        if(BoardRelease == 10)

        {

                if(AdValueGyrNick > 1010) Reading_GyroNick = +1000;

                if(AdValueGyrNick > 1017) Reading_GyroNick = +2000;

        }

        else

        {

                if(AdValueGyrNick > 2020) Reading_GyroNick = +1000;

                if(AdValueGyrNick > 2034) Reading_GyroNick = +2000;

        }

// start ADC again to capture measurement values for the next loop

    ADC_Enable();

    IntegralYaw    = Reading_IntegralGyroYaw;

    IntegralNick  = Reading_IntegralGyroNick;

    IntegralRoll   = Reading_IntegralGyroRoll;

    IntegralNick2 = Reading_IntegralGyroNick2;

    IntegralRoll2  = Reading_IntegralGyroRoll2;

        if((ParamSet.GlobalConfig & CFG_ROTARY_RATE_LIMITER) && !Looping_Nick && !Looping_Roll)

        {

                if(Reading_GyroNick > 200)       Reading_GyroNick += 4 * (Reading_GyroNick - 200);

                else if(Reading_GyroNick < -200) Reading_GyroNick += 4 * (Reading_GyroNick + 200);

                if(Reading_GyroRoll > 200)        Reading_GyroRoll  += 4 * (Reading_GyroRoll - 200);

                else if(Reading_GyroRoll < -200)  Reading_GyroRoll  += 4 * (Reading_GyroRoll + 200);

        }

}

/************************************************************************/

/*  Averaging Measurement Readings  for Calibration                     */

/************************************************************************/

void CalibMean(void)

{

        if(BoardRelease >= 13) SearchGyroOffset();

    // stop ADC to avoid changing values during calculation

        ADC_Disable();

        Reading_GyroNick = AdValueGyrNick;

        Reading_GyroRoll  = AdValueGyrRoll;

        Reading_GyroYaw   = AdValueGyrYaw;

        Mean_AccNick = ACC_AMPLIFY * (int32_t)AdValueAccNick;

        Mean_AccRoll  = ACC_AMPLIFY * (int32_t)AdValueAccRoll;

        Mean_AccTop   = (int32_t)AdValueAccTop;

    // start ADC (enables internal trigger so that the ISR in analog.c

    // updates the readings once)

    ADC_Enable();

        TurnOver180Nick = (int32_t) ParamSet.AngleTurnOverNick * 2500L;

        TurnOver180Roll =  (int32_t) ParamSet.AngleTurnOverRoll  * 2500L;

}

/************************************************************************/

/*  Transmit Motor Data via I2C                                         */

/************************************************************************/

void SendMotorData(void)

{

    if(!(MKFlags & MKFLAG_MOTOR_RUN))

    {

        Motor_Rear = 0;

        Motor_Front = 0;

        Motor_Right = 0;

        Motor_Left = 0;

        if(MotorTest[0]) Motor_Front = MotorTest[0];

        if(MotorTest[1]) Motor_Rear  = MotorTest[1];

        if(MotorTest[2]) Motor_Left  = MotorTest[2];

        if(MotorTest[3]) Motor_Right = MotorTest[3];

        MKFlags &= ~(MKFLAG_FLY|MKFLAG_START); // clear flag FLY and START if motors are off

    }

    DebugOut.Analog[12] = Motor_Front;

    DebugOut.Analog[13] = Motor_Rear;

    DebugOut.Analog[14] = Motor_Left;

    DebugOut.Analog[15] = Motor_Right;

    //Start I2C Interrupt Mode

    twi_state = TWI_STATE_MOTOR_TX;

    I2C_Start();

}

/************************************************************************/

/*  Maps the parameter to poti values                                   */

/************************************************************************/

void ParameterMapping(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_MM(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) { 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;}

                CHK_POTI(FCParam.MaxHeight,ParamSet.MaxHeight);

                CHK_POTI_MM(FCParam.Height_D,ParamSet.Height_D,0,100);

                CHK_POTI_MM(FCParam.Height_P,ParamSet.Height_P,0,100);

                CHK_POTI(FCParam.Height_ACC_Effect,ParamSet.Height_ACC_Effect);

                CHK_POTI(FCParam.CompassYawEffect,ParamSet.CompassYawEffect);

                CHK_POTI_MM(FCParam.Gyro_P,ParamSet.Gyro_P,10,255);

                CHK_POTI(FCParam.Gyro_I,ParamSet.Gyro_I);

                CHK_POTI(FCParam.I_Factor,ParamSet.I_Factor);

                CHK_POTI(FCParam.UserParam1,ParamSet.UserParam1);

                CHK_POTI(FCParam.UserParam2,ParamSet.UserParam2);

                CHK_POTI(FCParam.UserParam3,ParamSet.UserParam3);

                CHK_POTI(FCParam.UserParam4,ParamSet.UserParam4);

                CHK_POTI(FCParam.UserParam5,ParamSet.UserParam5);

                CHK_POTI(FCParam.UserParam6,ParamSet.UserParam6);

                CHK_POTI(FCParam.UserParam7,ParamSet.UserParam7);

                CHK_POTI(FCParam.UserParam8,ParamSet.UserParam8);

                CHK_POTI(FCParam.ServoNickControl,ParamSet.ServoNickControl);

                CHK_POTI(FCParam.LoopGasLimit,ParamSet.LoopGasLimit);

                CHK_POTI(FCParam.Yaw_PosFeedback,ParamSet.Yaw_PosFeedback);

                CHK_POTI(FCParam.Yaw_NegFeedback,ParamSet.Yaw_NegFeedback);

                CHK_POTI(FCParam.DynamicStability,ParamSet.DynamicStability);

                CHK_POTI_MM(FCParam.J16Timing,ParamSet.J16Timing,1,255);

                CHK_POTI_MM(FCParam.J17Timing,ParamSet.J17Timing,1,255);

                CHK_POTI(FCParam.NaviGpsModeControl,ParamSet.NaviGpsModeControl);

                CHK_POTI(FCParam.NaviGpsGain,ParamSet.NaviGpsGain);

                CHK_POTI(FCParam.NaviGpsP,ParamSet.NaviGpsP);

                CHK_POTI(FCParam.NaviGpsI,ParamSet.NaviGpsI);

                CHK_POTI(FCParam.NaviGpsD,ParamSet.NaviGpsD);

                CHK_POTI(FCParam.NaviGpsACC,ParamSet.NaviGpsACC);

                CHK_POTI(FCParam.ExternalControl,ParamSet.ExternalControl);

                Ki = (float) FCParam.I_Factor * FACTOR_I;

        }

}

void SetCompassCalState(void)

{

        static uint8_t stick = 1;

    // if nick is centered or top set stick to zero

        if(PPM_in[ParamSet.ChannelAssignment[CH_NICK]] > -20) stick = 0;

        // if nick is down trigger to next cal state

        if((PPM_in[ParamSet.ChannelAssignment[CH_NICK]] < -70) && !stick)

        {

                stick = 1;

                CompassCalState++;

                if(CompassCalState < 5) Beep(CompassCalState);

                else BeepTime = 1000;

        }

}

/************************************************************************/

/*  MotorControl                                                        */

/************************************************************************/

void MotorControl(void)

{

        int16_t MotorValue, pd_result, h, tmp_int;

        int16_t YawMixFraction, GasMixFraction;

        static int32_t SumNick = 0, SumRoll = 0;

        static int32_t SetPointYaw = 0;

        static int32_t IntegralErrorNick = 0;

        static int32_t IntegralErrorRoll = 0;

        static uint16_t RcLostTimer;

        static uint8_t delay_neutral = 0, delay_startmotors = 0, delay_stopmotors = 0;

        static uint8_t HeightControlActive = 0;

        static int16_t HeightControlGas = 0;

        static int8_t TimerDebugOut = 0;

        static uint16_t UpdateCompassCourse = 0;

        static int32_t CorrectionNick, CorrectionRoll;

        Mean();

        GRN_ON;

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

// determine gas value

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

        GasMixFraction = StickGas;

    if(GasMixFraction < ParamSet.Gas_Min + 10) GasMixFraction = ParamSet.Gas_Min + 10;

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

// RC-signal is bad

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

        if(RC_Quality < 120)  // the rc-frame signal is not reveived or noisy

        {

                if(!PcAccess) // if also no PC-Access via UART

                {

                        if(BeepModulation == 0xFFFF)

                        {

                         BeepTime = 15000; // 1.5 seconds

                         BeepModulation = 0x0C00;

                        }

                }

                if(RcLostTimer) RcLostTimer--; // decremtent timer after rc sigal lost

                else // rc lost countdown finished

                {

                  MKFlags &= ~(MKFLAG_MOTOR_RUN|MKFLAG_EMERGENCY_LANDING); // clear motor run flag that stop the motors in SendMotorData()

                }

                RED_ON; // set red led

                if(Model_Is_Flying > 1000)  // wahrscheinlich in der Luft --> langsam absenken

                {

                        GasMixFraction = ParamSet.EmergencyGas; // set emergency gas

                        MKFlags |= (MKFLAG_EMERGENCY_LANDING); // ser flag fpr emergency landing

                        // set neutral rc inputs

                        PPM_diff[ParamSet.ChannelAssignment[CH_NICK]] = 0;

                        PPM_diff[ParamSet.ChannelAssignment[CH_ROLL]] = 0;

                        PPM_diff[ParamSet.ChannelAssignment[CH_YAW]] = 0;

                        PPM_in[ParamSet.ChannelAssignment[CH_NICK]] = 0;

                        PPM_in[ParamSet.ChannelAssignment[CH_ROLL]] = 0;

                        PPM_in[ParamSet.ChannelAssignment[CH_YAW]] = 0;

                }

                else MKFlags &= ~(MKFLAG_MOTOR_RUN); // clear motor run flag that stop the motors in SendMotorData()

        } // eof RC_Quality < 120

        else

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

// RC-signal is good

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

        if(RC_Quality > 140)

        {

                MKFlags &= ~(MKFLAG_EMERGENCY_LANDING); // clear flag for emergency landing

                // reset emergency timer

                RcLostTimer = ParamSet.EmergencyGasDuration * 50;

                if(GasMixFraction > 40 && (MKFlags & MKFLAG_MOTOR_RUN) )

                {

                        if(Model_Is_Flying < 0xFFFF) Model_Is_Flying++;

                }

                if(Model_Is_Flying < 256)

                {

                        SumNick = 0;

                        SumRoll = 0;

                        StickYaw = 0;

                        if(Model_Is_Flying == 250)

                        {

                                UpdateCompassCourse = 1;

                                Reading_IntegralGyroYaw = 0;

                                SetPointYaw = 0;

                        }

                }

                else MKFlags |= (MKFLAG_FLY); // set fly flag

                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 gas stick is in the upper position

                if((PPM_in[ParamSet.ChannelAssignment[CH_GAS]] > 80) && !(MKFlags & MKFLAG_MOTOR_RUN) )

                {

                        // 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

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

                        {

                                // gas/yaw joystick is top left

                                //  _________

                                // |x        |

                                // |         |

                                // |         |

                                // |         |

                                // |         |

                                //  ¯¯¯¯¯¯¯¯¯

                                if(++delay_neutral > 200)  // not immediately (wait 200 loops = 200 * 2ms = 0.4 s)

                                {

                                        delay_neutral = 0;

                                        GRN_OFF;

                                        Model_Is_Flying = 0;

                                        // check roll/nick stick position

                                        // if nick stick is top or roll stick is left or right --> change parameter setting

                                        // according to roll/nick stick position

                                        if(PPM_in[ParamSet.ChannelAssignment[CH_NICK]] > 70 || abs(PPM_in[ParamSet.ChannelAssignment[CH_ROLL]]) > 70)

                                        {

                                                 uint8_t setting = 1; // default

                                                 // nick/roll joystick

                                                 //  _________

                                                 // |2   3   4|

                                                 // |         |

                                                 // |1       5|

                                                 // |         |

                                                 // |         |

                                                 //  ¯¯¯¯¯¯¯¯¯

                                                 // roll stick leftmost and nick stick centered --> setting 1

                                                 if(PPM_in[ParamSet.ChannelAssignment[CH_ROLL]] > 70 && PPM_in[ParamSet.ChannelAssignment[CH_NICK]] < 70) setting = 1;

                                                 // roll stick leftmost and nick stick topmost --> setting 2

                                                 if(PPM_in[ParamSet.ChannelAssignment[CH_ROLL]] > 70 && PPM_in[ParamSet.ChannelAssignment[CH_NICK]] > 70) setting = 2;

                                                 // roll stick centered an nick stick topmost --> setting 3

                                                 if(PPM_in[ParamSet.ChannelAssignment[CH_ROLL]] < 70 && PPM_in[ParamSet.ChannelAssignment[CH_NICK]] > 70) setting = 3;

                                                 // roll stick rightmost and nick stick topmost --> setting 4

                                                 if(PPM_in[ParamSet.ChannelAssignment[CH_ROLL]] <-70 && PPM_in[ParamSet.ChannelAssignment[CH_NICK]] > 70) setting = 4;

                                                 // roll stick rightmost and nick stick centered --> setting 5

                                                 if(PPM_in[ParamSet.ChannelAssignment[CH_ROLL]] <-70 && PPM_in[ParamSet.ChannelAssignment[CH_NICK]] < 70) setting = 5;

                                                 // update active parameter set in eeprom

                                                 SetActiveParamSet(setting);

                                                 ParamSet_ReadFromEEProm(GetActiveParamSet());

                                                 SetNeutral();

                                                 Beep(GetActiveParamSet());

                                        }

                                        else

                                        {

                                                if((ParamSet.GlobalConfig & CFG_COMPASS_ACTIVE))

                                                {

                                                        // if roll stick is centered and nick stick is down

                                                        if (abs(PPM_in[ParamSet.ChannelAssignment[CH_ROLL]]) < 20 && PPM_in[ParamSet.ChannelAssignment[CH_NICK]] < -70)

                                                        {

                                                                // nick/roll joystick

                                                                //  _________

                                                                // |         |

                                                                // |         |

                                                                // |         |

                                                                // |         |

                                                                // |    x    |

                                                                //  ¯¯¯¯¯¯¯¯¯

                                                                // enable calibration state of compass

                                                                CompassCalState = 1;

                                                                BeepTime = 1000;

                                                        }

                                                        else // nick and roll are centered

                                                        {

                                                                ParamSet_ReadFromEEProm(GetActiveParamSet());

                                                                SetNeutral();

                                                                Beep(GetActiveParamSet());

                                                        }

                                                }

                                                else // nick and roll are centered

                                                {

                                                        ParamSet_ReadFromEEProm(GetActiveParamSet());

                                                        SetNeutral();

                                                        Beep(GetActiveParamSet());

                                                }

                                        }

                                }

                        }

                        // and if the yaw stick is in the rightmost position

                        // save the ACC neutral setting to eeprom

                        else if(PPM_in[ParamSet.ChannelAssignment[CH_YAW]] < -75)

                        {

                                if(++delay_neutral > 200)  // not immediately (wait 200 loops = 200 * 2ms = 0.4 s)

                                {

                                        delay_neutral = 0;

                                        GRN_OFF;

                                        SetParamWord(PID_ACC_NICK, 0xFFFF); // make value invalid

                                        Model_Is_Flying = 0;

                                        SetNeutral();

                                        // Save ACC neutral settings to eeprom

                                        SetParamWord(PID_ACC_NICK, (uint16_t)NeutralAccX);

                                        SetParamWord(PID_ACC_ROLL,  (uint16_t)NeutralAccY);

                                        SetParamWord(PID_ACC_Z,     (uint16_t)NeutralAccZ);

                                        Beep(GetActiveParamSet());

                                }

                        }

                        else delay_neutral = 0;

                }

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

// gas stick is down

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

                if(PPM_in[ParamSet.ChannelAssignment[CH_GAS]] < -85)

                {

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

// and yaw stick is rightmost --> start motors

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

                        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;

                                        MKFlags |= (MKFLAG_MOTOR_RUN|MKFLAG_START); // set flag RUN and START

                                        SetPointYaw = 0;

                                        Reading_IntegralGyroYaw = 0;

                                        Reading_IntegralGyroNick = 0;

                                        Reading_IntegralGyroRoll = 0;

                                        Reading_IntegralGyroNick2 = IntegralNick;

                                        Reading_IntegralGyroRoll2 = IntegralRoll;

                                        SumNick = 0;

                                        SumRoll = 0;

                                }