WebSVN - FlightCtrl - Path Comparison - / Rev 1050 and / Rev 1051

Ignore whitespace Rev 1050 → Rev 1051

 /trunk/fc.c
 ,14 → 6,14
 // + 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.
+// + 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,
+// + 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
 ,21 → 24,21
 // + 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
+// + 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,
+// + 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
+// +   * 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
+// +     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
+// +   * 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
 ,7 → 49,7
 // +  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.
+// +  POSSIBILITY OF SUCH DAMAGE.
 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 #include "main.h"
 ,7 → 58,7
 unsigned char h,m,s;
 volatile unsigned int I2CTimeout = 100;
 volatile int MesswertNick,MesswertRoll,MesswertGier,MesswertGierBias;
-int AdNeutralGierBias;
+int AdNeutralGierBias;
 int AdNeutralNick = 0,AdNeutralRoll = 0,AdNeutralGier = 0,StartNeutralRoll = 0,StartNeutralNick = 0;
 int Mittelwert_AccNick, Mittelwert_AccRoll,Mittelwert_AccHoch, NeutralAccX=0, NeutralAccY=0;
 int NaviAccNick, NaviAccRoll,NaviCntAcc = 0;
 ,7 → 88,7
 float GyroFaktor;
 float IntegralFaktor;
 volatile int  DiffNick,DiffRoll;
-int  Poti1 = 0, Poti2 = 0, Poti3 = 0, Poti4 = 0;
+int  Poti1 = 0, Poti2 = 0, Poti3 = 0, Poti4 = 0;
 volatile unsigned char Motor_Vorne,Motor_Hinten,Motor_Rechts,Motor_Links, Count;
 volatile unsigned char SenderOkay = 0;
 int StickNick = 0,StickRoll = 0,StickGier = 0,StickGas = 0;
 ,11 → 127,11
 unsigned char Parameter_J17Bitmask;             // for the J17 Output
 unsigned char Parameter_J17Timing;              // for the J17 Output
 unsigned char Parameter_NaviGpsModeControl;     // Parameters for the Naviboard
-unsigned char Parameter_NaviGpsGain;
-unsigned char Parameter_NaviGpsP;
-unsigned char Parameter_NaviGpsI;
-unsigned char Parameter_NaviGpsD;
-unsigned char Parameter_NaviGpsACC;
+unsigned char Parameter_NaviGpsGain;
+unsigned char Parameter_NaviGpsP;
+unsigned char Parameter_NaviGpsI;
+unsigned char Parameter_NaviGpsD;
+unsigned char Parameter_NaviGpsACC;
 unsigned char Parameter_NaviOperatingRadius;
 unsigned char Parameter_NaviWindCorrection;
 unsigned char Parameter_NaviSpeedCompensation;
 ,48 → 157,48
 void SetNeutral(void)
 //############################################################################
 {
-        NeutralAccX = 0;
+        NeutralAccX = 0;
         NeutralAccY = 0;
         NeutralAccZ = 0;
-    AdNeutralNick = 0;
-        AdNeutralRoll = 0;
+    AdNeutralNick = 0;
+        AdNeutralRoll = 0;
         AdNeutralGier = 0;
     AdNeutralGierBias = 0;
     Parameter_AchsKopplung1 = 0;
     Parameter_AchsGegenKopplung1 = 0;
     ExpandBaro = 0;
-    CalibrierMittelwert();
+    CalibrierMittelwert();
     Delay_ms_Mess(100);
         CalibrierMittelwert();
     if((EE_Parameter.GlobalConfig & CFG_HOEHENREGELUNG))  // Höhenregelung aktiviert?
-     {
+     {
       if((MessLuftdruck > 950) || (MessLuftdruck < 750)) SucheLuftruckOffset();
      }
-     AdNeutralNick= AdWertNick;
-         AdNeutralRoll= AdWertRoll;
+     AdNeutralNick= AdWertNick;
+         AdNeutralRoll= AdWertRoll;
          AdNeutralGier= AdWertGier;
      AdNeutralGierBias = AdWertGier;
      StartNeutralRoll = AdNeutralRoll;
      StartNeutralNick = AdNeutralNick;
-    if(eeprom_read_byte(&EEPromArray[EEPROM_ADR_ACC_NICK]) > 4)
+    if(eeprom_read_byte(&EEPromArray[EEPROM_ADR_ACC_NICK]) > 4)
     {
       NeutralAccY = abs(Mittelwert_AccRoll) / ACC_AMPLIFY;
           NeutralAccX = abs(Mittelwert_AccNick) / ACC_AMPLIFY;
           NeutralAccZ = Aktuell_az;
     }
-    else
+    else
     {
       NeutralAccX = (int)eeprom_read_byte(&EEPromArray[EEPROM_ADR_ACC_NICK]) * 256 + (int)eeprom_read_byte(&EEPromArray[EEPROM_ADR_ACC_NICK+1]);
           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]);
     }
-        Mess_IntegralNick = 0;
+        Mess_IntegralNick = 0;
     Mess_IntegralNick2 = 0;
-    Mess_IntegralRoll = 0;
+    Mess_IntegralRoll = 0;
     Mess_IntegralRoll2 = 0;
-    Mess_Integral_Gier = 0;
+    Mess_Integral_Gier = 0;
     MesswertNick = 0;
     MesswertRoll = 0;
     MesswertGier = 0;
 ,7 → 208,7
     Mess_Integral_Hoch = 0;
     KompassStartwert = KompassValue;
     GPS_Neutral();
-    beeptime = 50;
+    beeptime = 50;
         Umschlag180Nick = ((long) EE_Parameter.WinkelUmschlagNick * 2500L) + 15000L;
         Umschlag180Roll = ((long) EE_Parameter.WinkelUmschlagRoll * 2500L) + 15000L;
     ExternHoehenValue = 0;
 ,8 → 226,8
 // Bearbeitet die Messwerte
 void Mittelwert(void)
 //############################################################################
-{
-    static signed long tmpl,tmpl2;
+{
+    static signed long tmpl,tmpl2;
     MesswertGier = (signed int) AdNeutralGier - AdWertGier;
     MesswertGierBias = (signed int) AdNeutralGierBias - AdWertGier;
     MesswertRoll = (signed int) AdWertRoll - AdNeutralRoll;
 ,7 → 261,7
             tmpl2 = (MesswertGierBias * Mess_IntegralRoll) / 2048L;
             tmpl2 *= Parameter_AchsKopplung1;
             tmpl2 /= 4096L;
-            if(labs(tmpl) > 128 || labs(tmpl2) > 128) TrichterFlug = 1;
+            if(labs(tmpl) > 128 || labs(tmpl2) > 128) TrichterFlug = 1;
          }
       else  tmpl = tmpl2 = 0;
 // Roll  ++++++++++++++++++++++++++++++++++++++++++++++++
 ,16 → 269,16
             MesswertRoll += (tmpl2*Parameter_AchsGegenKopplung1)/512L; //109
             Mess_IntegralRoll2 += MesswertRoll;
             Mess_IntegralRoll +=  MesswertRoll - LageKorrekturRoll;
-            if(Mess_IntegralRoll > Umschlag180Roll)
+            if(Mess_IntegralRoll > Umschlag180Roll)
             {
              Mess_IntegralRoll  = -(Umschlag180Roll - 25000L);
              Mess_IntegralRoll2 = Mess_IntegralRoll;
-            }
+            }
             if(Mess_IntegralRoll <-Umschlag180Roll)
             {
              Mess_IntegralRoll =  (Umschlag180Roll - 25000L);
              Mess_IntegralRoll2 = Mess_IntegralRoll;
-            }
+            }
             if(AdWertRoll < 15)   MesswertRoll = -1000;
             if(AdWertRoll <  7)   MesswertRoll = -2000;
             if(PlatinenVersion == 10)
 ,7 → 286,7
               if(AdWertRoll > 1010) MesswertRoll = +1000;
               if(AdWertRoll > 1017) MesswertRoll = +2000;
                          }
-                         else
+                         else
                          {
               if(AdWertRoll > 2020) MesswertRoll = +1000;
               if(AdWertRoll > 2034) MesswertRoll = +2000;
 ,16 → 297,16
             Mess_IntegralNick2 += MesswertNick;
             Mess_IntegralNick  += MesswertNick - LageKorrekturNick;
-            if(Mess_IntegralNick > Umschlag180Nick)
+            if(Mess_IntegralNick > Umschlag180Nick)
              {
               Mess_IntegralNick = -(Umschlag180Nick - 25000L);
               Mess_IntegralNick2 = Mess_IntegralNick;
-             }
-            if(Mess_IntegralNick <-Umschlag180Nick)
+             }
+            if(Mess_IntegralNick <-Umschlag180Nick)
             {
              Mess_IntegralNick =  (Umschlag180Nick - 25000L);
              Mess_IntegralNick2 = Mess_IntegralNick;
-            }
+            }
             if(AdWertNick < 15)   MesswertNick = -1000;
             if(AdWertNick <  7)   MesswertNick = -2000;
             if(PlatinenVersion == 10)
 ,7 → 314,7
               if(AdWertNick > 1010) MesswertNick = +1000;
               if(AdWertNick > 1017) MesswertNick = +2000;
                          }
-                         else
+                         else
                          {
               if(AdWertNick > 2020) MesswertNick = +1000;
               if(AdWertNick > 2034) MesswertNick = +2000;
 ,21 → 321,21
                          }
 //++++++++++++++++++++++++++++++++++++++++++++++++
 // ADC einschalten
-    ANALOG_ON;
+    ANALOG_ON;
 //++++++++++++++++++++++++++++++++++++++++++++++++
     Integral_Gier  = Mess_Integral_Gier;
     IntegralNick = Mess_IntegralNick;
     IntegralRoll = Mess_IntegralRoll;
-    IntegralNick2 = Mess_IntegralNick2;
+    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);
+    else if(MesswertNick < -200) MesswertNick += 4 * (MesswertNick + 200);
     if(MesswertRoll > 200)       MesswertRoll += 4 * (MesswertRoll - 200);
-    else 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--;
 ,7 → 351,7
 // Messwerte beim Ermitteln der Nullage
 void CalibrierMittelwert(void)
 //############################################################################
-{
+{
     if(PlatinenVersion == 13) SucheGyroOffset();
     // ADC auschalten, damit die Werte sich nicht während der Berechnung ändern
         ANALOG_OFF;
 ,7 → 362,7
         Mittelwert_AccRoll = ACC_AMPLIFY * (long)AdWertAccRoll;
         Mittelwert_AccHoch = (long)AdWertAccHoch;
    // ADC einschalten
-    ANALOG_ON;
+    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--;
 ,7 → 380,7
 // Senden der Motorwerte per I2C-Bus
 void SendMotorData(void)
 //############################################################################
-{
+{
     if(!MotorenEin)
         {
         Motor_Hinten = 0;
 ,12 → 397,12
     DebugOut.Analog[12] = Motor_Vorne;
     DebugOut.Analog[13] = Motor_Hinten;
     DebugOut.Analog[14] = Motor_Links;
-    DebugOut.Analog[15] = Motor_Rechts;
+    DebugOut.Analog[15] = Motor_Rechts;
     //Start I2C Interrupt Mode
     twi_state = 0;
     motor = 0;
-    i2c_start();
+    i2c_start();
 }
 ,7 → 409,7
 //############################################################################
 // Trägt ggf. das Poti als Parameter ein
-void ParameterZuordnung(void)
+void ParameterZuordnung(void)
 //############################################################################
 {
  #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;}
 ,15 → 421,15
  CHK_POTI(Parameter_KompassWirkung,EE_Parameter.KompassWirkung,0,255);
  CHK_POTI_MM(Parameter_Gyro_P,EE_Parameter.Gyro_P,10,255);
  CHK_POTI(Parameter_Gyro_I,EE_Parameter.Gyro_I,0,255);
- CHK_POTI(Parameter_I_Faktor,EE_Parameter.I_Faktor,0,255);
- CHK_POTI(Parameter_UserParam1,EE_Parameter.UserParam1,0,255);
- CHK_POTI(Parameter_UserParam2,EE_Parameter.UserParam2,0,255);
- CHK_POTI(Parameter_UserParam3,EE_Parameter.UserParam3,0,255);
- CHK_POTI(Parameter_UserParam4,EE_Parameter.UserParam4,0,255);
- CHK_POTI(Parameter_UserParam5,EE_Parameter.UserParam5,0,255);
- CHK_POTI(Parameter_UserParam6,EE_Parameter.UserParam6,0,255);
- CHK_POTI(Parameter_UserParam7,EE_Parameter.UserParam7,0,255);
- CHK_POTI(Parameter_UserParam8,EE_Parameter.UserParam8,0,255);
+ CHK_POTI(Parameter_I_Faktor,EE_Parameter.I_Faktor,0,255);
+ CHK_POTI(Parameter_UserParam1,EE_Parameter.UserParam1,0,255);
+ CHK_POTI(Parameter_UserParam2,EE_Parameter.UserParam2,0,255);
+ CHK_POTI(Parameter_UserParam3,EE_Parameter.UserParam3,0,255);
+ CHK_POTI(Parameter_UserParam4,EE_Parameter.UserParam4,0,255);
+ CHK_POTI(Parameter_UserParam5,EE_Parameter.UserParam5,0,255);
+ CHK_POTI(Parameter_UserParam6,EE_Parameter.UserParam6,0,255);
+ CHK_POTI(Parameter_UserParam7,EE_Parameter.UserParam7,0,255);
+ CHK_POTI(Parameter_UserParam8,EE_Parameter.UserParam8,0,255);
  CHK_POTI(Parameter_ServoNickControl,EE_Parameter.ServoNickControl,0,255);
  CHK_POTI(Parameter_LoopGasLimit,EE_Parameter.LoopGasLimit,0,255);
  CHK_POTI(Parameter_AchsKopplung1,    EE_Parameter.AchsKopplung1,0,255);
 ,34 → 475,34
      static char TimerWerteausgabe = 0;
      static char NeueKompassRichtungMerken = 0;
      static long ausgleichNick, ausgleichRoll;
-        Mittelwert();
+        Mittelwert();
     GRN_ON;
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // Gaswert ermitteln
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-        GasMischanteil = StickGas;
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+        GasMischanteil = StickGas;
     if(GasMischanteil < MIN_GAS + 10) GasMischanteil = MIN_GAS + 10;
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // Empfang schlecht
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    if(SenderOkay < 100)
         {
-        if(!PcZugriff)
+        if(!PcZugriff)
          {
-           if(BeepMuster == 0xffff)
-            {
+           if(BeepMuster == 0xffff)
+            {
              beeptime = 15000;
              BeepMuster = 0x0c00;
-            }
+            }
          }
-        if(RcLostTimer) RcLostTimer--;
-        else
+        if(RcLostTimer) RcLostTimer--;
+        else
          {
           MotorenEin = 0;
           Notlandung = 0;
-         }
+         }
         ROT_ON;
         if(modell_fliegt > 1000)  // wahrscheinlich in der Luft --> langsam absenken
             {
 ,7 → 509,7
             GasMischanteil = EE_Parameter.NotGas;
             Notlandung = 1;
             PPM_diff[EE_Parameter.Kanalbelegung[K_NICK]] = 0;
-            PPM_diff[EE_Parameter.Kanalbelegung[K_ROLL]] = 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_in[EE_Parameter.Kanalbelegung[K_GIER]] = 0;
 ,10 → 516,10
             }
          else MotorenEin = 0;
         }
-        else
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+        else
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // Emfang gut
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
         if(SenderOkay > 140)
             {
             Notlandung = 0;
 ,20 → 532,20
                 {
                 SummeNick = 0;
                 SummeRoll = 0;
-                if(modell_fliegt == 250)
+                if(modell_fliegt == 250)
                  {
-                  NeueKompassRichtungMerken = 1;
+                  NeueKompassRichtungMerken = 1;
                   sollGier = 0;
-                  Mess_Integral_Gier = 0;
+                  Mess_Integral_Gier = 0;
 //                  Mess_Integral_Gier2 = 0;
-                 }
+                 }
                 } else MikroKopterFlags |= FLAG_FLY;
             if((PPM_in[EE_Parameter.Kanalbelegung[K_GAS]] > 80) && MotorenEin == 0)
                 {
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // auf Nullwerte kalibrieren
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
                 if(PPM_in[EE_Parameter.Kanalbelegung[K_GIER]] > 75)  // Neutralwerte
                     {
                     if(++delay_neutral > 200)  // nicht sofort
 ,8 → 565,8
                          eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACTIVE_SET], setting);  // aktiven Datensatz merken
                         }
 //                        else
-                         if(abs(PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]]) < 30 && PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] < -70)
-                          {
+                         if(abs(PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]]) < 30 && PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] < -70)
+                          {
                            WinkelOut.CalcState = 1;
                            beeptime = 1000;
                           }
 ,13 → 576,13
                            if((EE_Parameter.GlobalConfig & CFG_HOEHENREGELUNG))  // Höhenregelung aktiviert?
                             {
                              if((MessLuftdruck > 950) || (MessLuftdruck < 750)) SucheLuftruckOffset();
-                            }
+                            }
                            SetNeutral();
                            Piep(GetActiveParamSetNumber());
                          }
-                        }
+                        }
                     }
-                 else
+                 else
                 if(PPM_in[EE_Parameter.Kanalbelegung[K_GIER]] < -75)  // ACC Neutralwerte speichern
                     {
                     if(++delay_neutral > 200)  // nicht sofort
 ,21 → 600,21
                         eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACC_Z],(int)NeutralAccZ / 256);
                         eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACC_Z+1],(int)NeutralAccZ % 256);
                         Piep(GetActiveParamSetNumber());
-                        }
+                        }
                     }
                  else delay_neutral = 0;
                 }
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // Gas ist unten
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
             if(PPM_in[EE_Parameter.Kanalbelegung[K_GAS]] < 35-120)
                 {
                 // Starten
                 if(PPM_in[EE_Parameter.Kanalbelegung[K_GIER]] < -75)
                     {
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // Einschalten
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
                     if(++delay_einschalten > 200)
                         {
                         delay_einschalten = 200;
 ,7 → 621,7
                         modell_fliegt = 1;
                         MotorenEin = 1;
                         sollGier = 0;
-                        Mess_Integral_Gier = 0;
+                        Mess_Integral_Gier = 0;
                         Mess_Integral_Gier2 = 0;
                         Mess_IntegralNick = 0;
                         Mess_IntegralRoll = 0;
 ,13 → 630,13
                         SummeNick = 0;
                         SummeRoll = 0;
                         MikroKopterFlags |= FLAG_START;
-                        }
-                    }
+                        }
+                    }
                     else delay_einschalten = 0;
                 //Auf Neutralwerte setzen
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // Auschalten
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
                 if(PPM_in[EE_Parameter.Kanalbelegung[K_GIER]] > 75)
                     {
                     if(++delay_ausschalten > 200)  // nicht sofort
 ,24 → 644,24
                         MotorenEin = 0;
                         delay_ausschalten = 200;
                         modell_fliegt = 0;
-                        }
+                        }
                     }
                 else delay_ausschalten = 0;
                 }
             }
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // neue Werte von der Funke
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- if(!NewPpmData-- || Notlandung)
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ if(!NewPpmData-- || Notlandung)
   {
     int tmp_int;
         static int stick_nick,stick_roll;
     ParameterZuordnung();
-    stick_nick = (stick_nick * 3 + PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] * EE_Parameter.Stick_P) / 4;
+    stick_nick = (stick_nick * 3 + PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] * EE_Parameter.Stick_P) / 4;
     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;
+//    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;
     stick_roll += PPM_diff[EE_Parameter.Kanalbelegung[K_ROLL]] * EE_Parameter.Stick_D;
 ,9 → 672,9
     StickGier = -PPM_in[EE_Parameter.Kanalbelegung[K_GIER]];
         StickGas  = PPM_in[EE_Parameter.Kanalbelegung[K_GAS]] + 120;
-/*   if(abs(PPM_in[EE_Parameter.Kanalbelegung[K_NICK]]) > MaxStickNick)
+/*   if(abs(PPM_in[EE_Parameter.Kanalbelegung[K_NICK]]) > MaxStickNick)
      MaxStickNick = abs(PPM_in[EE_Parameter.Kanalbelegung[K_NICK]]); else MaxStickNick--;
-   if(abs(PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]]) > MaxStickRoll)
+   if(abs(PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]]) > MaxStickRoll)
      MaxStickRoll = abs(PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]]); else MaxStickRoll--;
 */
     GyroFaktor     = ((float)Parameter_Gyro_P + 10.0) / (256.0/STICK_GAIN);
 ,26 → 681,6
     IntegralFaktor = ((float) Parameter_Gyro_I) / (44000 / STICK_GAIN);
 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-//+ Digitale Steuerung per DubWise
-//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-#define KEY_VALUE (Parameter_ExternalControl * 4)  //(Poti3 * 8)
-if(DubWiseKeys[1]) beeptime = 10;
-    if(DubWiseKeys[1] & DUB_KEY_UP)    tmp_int = KEY_VALUE;   else
-    if(DubWiseKeys[1] & DUB_KEY_DOWN)  tmp_int = -KEY_VALUE;  else   tmp_int = 0;
-    ExternStickNick = (ExternStickNick * 7 + tmp_int) / 8;
-    if(DubWiseKeys[1] & DUB_KEY_LEFT)  tmp_int = KEY_VALUE; else
-    if(DubWiseKeys[1] & DUB_KEY_RIGHT) tmp_int = -KEY_VALUE; else tmp_int = 0;
-    ExternStickRoll = (ExternStickRoll * 7 + tmp_int) / 8;
-    if(DubWiseKeys[0] & 8)  ExternStickGier = 50;else
-    if(DubWiseKeys[0] & 4)  ExternStickGier =-50;else ExternStickGier = 0;
-    if(DubWiseKeys[0] & 2)  ExternHoehenValue++;
-    if(DubWiseKeys[0] & 16) ExternHoehenValue--;
-    StickNick += (STICK_GAIN * ExternStickNick) / 8;
-    StickRoll += (STICK_GAIN * ExternStickRoll) / 8;
-    StickGier += STICK_GAIN * ExternStickGier;
-//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 //+ Analoge Steuerung per Seriell
 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    if(ExternControl.Config & 0x01 && Parameter_ExternalControl > 128)
 ,55 → 697,55
     if(GyroFaktor < 0) GyroFaktor = 0;
     if(IntegralFaktor < 0) IntegralFaktor = 0;
-    if(abs(StickNick/STICK_GAIN) > MaxStickNick)
+    if(abs(StickNick/STICK_GAIN) > MaxStickNick)
      {
-      MaxStickNick = abs(StickNick)/STICK_GAIN;
+      MaxStickNick = abs(StickNick)/STICK_GAIN;
       if(MaxStickNick > 100) MaxStickNick = 100;
-     }
+     }
      else MaxStickNick--;
-    if(abs(StickRoll/STICK_GAIN) > MaxStickRoll)
+    if(abs(StickRoll/STICK_GAIN) > MaxStickRoll)
      {
-      MaxStickRoll = abs(StickRoll)/STICK_GAIN;
+      MaxStickRoll = abs(StickRoll)/STICK_GAIN;
       if(MaxStickRoll > 100) MaxStickRoll = 100;
-     }
+     }
      else MaxStickRoll--;
     if(Notlandung)  {MaxStickNick = 0; MaxStickRoll = 0;}
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // Looping?
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
   if((PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] > EE_Parameter.LoopThreshold) && EE_Parameter.BitConfig & CFG_LOOP_LINKS)  Looping_Links = 1;
-  else
-   {
+  else
+   {
      {
-      if((PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] < (EE_Parameter.LoopThreshold - EE_Parameter.LoopHysterese))) Looping_Links = 0;
-     }
-   }
+      if((PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] < (EE_Parameter.LoopThreshold - EE_Parameter.LoopHysterese))) Looping_Links = 0;
+     }
+   }
   if((PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] < -EE_Parameter.LoopThreshold) && EE_Parameter.BitConfig & CFG_LOOP_RECHTS) Looping_Rechts = 1;
-   else
+   else
    {
    if(Looping_Rechts) // Hysterese
      {
       if(PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] > -(EE_Parameter.LoopThreshold - EE_Parameter.LoopHysterese)) Looping_Rechts = 0;
      }
-   }
+   }
   if((PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] > EE_Parameter.LoopThreshold) && EE_Parameter.BitConfig & CFG_LOOP_OBEN) Looping_Oben = 1;
-  else
-   {
+  else
+   {
     if(Looping_Oben)  // Hysterese
      {
-      if((PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] < (EE_Parameter.LoopThreshold - EE_Parameter.LoopHysterese))) Looping_Oben = 0;
-     }
-   }
+      if((PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] < (EE_Parameter.LoopThreshold - EE_Parameter.LoopHysterese))) Looping_Oben = 0;
+     }
+   }
   if((PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] < -EE_Parameter.LoopThreshold) && EE_Parameter.BitConfig & CFG_LOOP_UNTEN) Looping_Unten = 1;
-   else
+   else
    {
     if(Looping_Unten) // Hysterese
      {
       if(PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] > -(EE_Parameter.LoopThreshold - EE_Parameter.LoopHysterese)) Looping_Unten = 0;
      }
-   }
+   }
    if(Looping_Links || Looping_Rechts)   Looping_Roll = 1; else Looping_Roll = 0;
    if(Looping_Oben  || Looping_Unten) {Looping_Nick = 1; Looping_Roll = 0; Looping_Links = 0; Looping_Rechts = 0;} else Looping_Nick = 0;
 ,11 → 755,11
    {
     if(GasMischanteil > EE_Parameter.LoopGasLimit) GasMischanteil = EE_Parameter.LoopGasLimit;
    }
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-// Bei Empfangsausfall im Flug
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// Bei Empfangsausfall im Flug
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    if(Notlandung)
     {
      StickGier = 0;
 ,12 → 769,12
      IntegralFaktor = (float) 120 / (44000 / STICK_GAIN);
      Looping_Roll = 0;
      Looping_Nick = 0;
-    }
+    }
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // Integrale auf ACC-Signal abgleichen
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 #define ABGLEICH_ANZAHL 256L
  MittelIntegralNick  += IntegralNick;    // Für die Mittelwertbildung aufsummieren
 ,7 → 797,7
     LageKorrekturRoll = 0;
   }
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
   if(!Looping_Nick && !Looping_Roll)
   {
    long tmp_long, tmp_long2;
 ,9 → 804,9
    if(FromNaviCtrl_Value.Kalman_K != -1)
      {
       tmp_long = (long)(IntegralNick / EE_Parameter.GyroAccFaktor - (long)Mittelwert_AccNick);
-      tmp_long2 = (long)(IntegralRoll / EE_Parameter.GyroAccFaktor - (long)Mittelwert_AccRoll);
-      tmp_long  = (tmp_long  * FromNaviCtrl_Value.Kalman_K) / (32 * 16);
-      tmp_long2 = (tmp_long2 * FromNaviCtrl_Value.Kalman_K) / (32 * 16);
+      tmp_long2 = (long)(IntegralRoll / EE_Parameter.GyroAccFaktor - (long)Mittelwert_AccRoll);
+      tmp_long  = (tmp_long  * FromNaviCtrl_Value.Kalman_K) / (32 * 16);
+      tmp_long2 = (tmp_long2 * FromNaviCtrl_Value.Kalman_K) / (32 * 16);
      if((MaxStickNick > 64) || (MaxStickRoll > 64))
       {
       tmp_long  /= 2;
 ,10 → 822,10
       if(tmp_long2 > (long) FromNaviCtrl_Value.Kalman_MaxFusion)  tmp_long2 = (long) FromNaviCtrl_Value.Kalman_MaxFusion;
       if(tmp_long2 < (long)-FromNaviCtrl_Value.Kalman_MaxFusion)  tmp_long2 = (long)-FromNaviCtrl_Value.Kalman_MaxFusion;
      }
-     else
+     else
      {
       tmp_long = (long)(IntegralNick / EE_Parameter.GyroAccFaktor - (long)Mittelwert_AccNick);
-      tmp_long2 = (long)(IntegralRoll / EE_Parameter.GyroAccFaktor - (long)Mittelwert_AccRoll);
+      tmp_long2 = (long)(IntegralRoll / EE_Parameter.GyroAccFaktor - (long)Mittelwert_AccRoll);
       tmp_long /= 16;
       tmp_long2 /= 16;
      if((MaxStickNick > 64) || (MaxStickRoll > 64))
 ,11 → 844,11
       if(tmp_long2 > AUSGLEICH)  tmp_long2 = AUSGLEICH;
       if(tmp_long2 <-AUSGLEICH)  tmp_long2 =-AUSGLEICH;
      }
     Mess_IntegralNick -= tmp_long;
     Mess_IntegralRoll -= tmp_long2;
   }
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  if(ZaehlMessungen >= ABGLEICH_ANZAHL)
  {
   static int cnt = 0;
 ,8 → 865,8
 // Nick ++++++++++++++++++++++++++++++++++++++++++++++++
     IntegralFehlerNick = (long)(MittelIntegralNick - (long)IntegralAccNick);
     ausgleichNick = IntegralFehlerNick / EE_Parameter.GyroAccAbgleich;
-// Roll ++++++++++++++++++++++++++++++++++++++++++++++++
-    IntegralFehlerRoll = (long)(MittelIntegralRoll - (long)IntegralAccRoll);
+// Roll ++++++++++++++++++++++++++++++++++++++++++++++++
+    IntegralFehlerRoll = (long)(MittelIntegralRoll - (long)IntegralAccRoll);
     ausgleichRoll = IntegralFehlerRoll / EE_Parameter.GyroAccAbgleich;
     LageKorrekturNick = ausgleichNick / ABGLEICH_ANZAHL;
 ,13 → 878,13
      LageKorrekturRoll /= 2;
     }
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // Gyro-Drift ermitteln
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
     MittelIntegralNick2 /= ABGLEICH_ANZAHL;
     MittelIntegralRoll2 /= ABGLEICH_ANZAHL;
-    tmp_long  = IntegralNick2 - IntegralNick;
-    tmp_long2 = IntegralRoll2 - IntegralRoll;
+    tmp_long  = IntegralNick2 - IntegralNick;
+    tmp_long2 = IntegralRoll2 - IntegralRoll;
     //DebugOut.Analog[25] = MittelIntegralRoll2 / 26;
     IntegralFehlerNick = tmp_long;
 ,34 → 922,34
         cnt = 1;// + labs(IntegralFehlerNick) / 4096;
         if(labs(MittelIntegralNick_Alt - MittelIntegralNick) < BEWEGUNGS_LIMIT || (FromNaviCtrl_Value.Kalman_MaxDrift > 3*16))
         {
-        if(IntegralFehlerNick >  FEHLER_LIMIT2)
+        if(IntegralFehlerNick >  FEHLER_LIMIT2)
          {
-           if(last_n_p)
+           if(last_n_p)
            {
-            cnt += labs(IntegralFehlerNick) / FEHLER_LIMIT2;
+            cnt += labs(IntegralFehlerNick) / FEHLER_LIMIT2;
             ausgleichNick = IntegralFehlerNick / 8;
             if(ausgleichNick > 5000) ausgleichNick = 5000;
             LageKorrekturNick += ausgleichNick / ABGLEICH_ANZAHL;
-           }
+           }
            else last_n_p = 1;
          } else  last_n_p = 0;
-        if(IntegralFehlerNick < -FEHLER_LIMIT2)
+        if(IntegralFehlerNick < -FEHLER_LIMIT2)
          {
            if(last_n_n)
-            {
-             cnt += labs(IntegralFehlerNick) / FEHLER_LIMIT2;
+            {
+             cnt += labs(IntegralFehlerNick) / FEHLER_LIMIT2;
              ausgleichNick = IntegralFehlerNick / 8;
              if(ausgleichNick < -5000) ausgleichNick = -5000;
              LageKorrekturNick += ausgleichNick / ABGLEICH_ANZAHL;
-            }
+            }
            else last_n_n = 1;
          } else  last_n_n = 0;
-        }
-        else
+        }
+        else
         {
          cnt = 0;
          KompassSignalSchlecht = 1000;
-        }
+        }
         if(cnt > EE_Parameter.Driftkomp) cnt = EE_Parameter.Driftkomp;
         if(cnt * 16 > FromNaviCtrl_Value.Kalman_MaxDrift) cnt = FromNaviCtrl_Value.Kalman_MaxDrift/16;
         if(IntegralFehlerNick >  FEHLER_LIMIT)   AdNeutralNick += cnt;
 ,22 → 961,22
         ausgleichRoll = 0;
         if(labs(MittelIntegralRoll_Alt - MittelIntegralRoll) < BEWEGUNGS_LIMIT || (FromNaviCtrl_Value.Kalman_MaxDrift > 3*16))
         {
-        if(IntegralFehlerRoll >  FEHLER_LIMIT2)
+        if(IntegralFehlerRoll >  FEHLER_LIMIT2)
          {
-           if(last_r_p)
+           if(last_r_p)
            {
-            cnt += labs(IntegralFehlerRoll) / FEHLER_LIMIT2;
+            cnt += labs(IntegralFehlerRoll) / FEHLER_LIMIT2;
             ausgleichRoll = IntegralFehlerRoll / 8;
             if(ausgleichRoll > 5000) ausgleichRoll = 5000;
             LageKorrekturRoll += ausgleichRoll / ABGLEICH_ANZAHL;
-           }
+           }
            else last_r_p = 1;
          } else  last_r_p = 0;
-        if(IntegralFehlerRoll < -FEHLER_LIMIT2)
+        if(IntegralFehlerRoll < -FEHLER_LIMIT2)
          {
-           if(last_r_n)
+           if(last_r_n)
            {
-            cnt += labs(IntegralFehlerRoll) / FEHLER_LIMIT2;
+            cnt += labs(IntegralFehlerRoll) / FEHLER_LIMIT2;
             ausgleichRoll = IntegralFehlerRoll / 8;
             if(ausgleichRoll < -5000) ausgleichRoll = -5000;
             LageKorrekturRoll += ausgleichRoll / ABGLEICH_ANZAHL;
 ,28 → 983,28
            }
            else last_r_n = 1;
          } else  last_r_n = 0;
-        } else
+        } else
         {
          cnt = 0;
          KompassSignalSchlecht = 1000;
-        }
+        }
         if(cnt > EE_Parameter.Driftkomp) cnt = EE_Parameter.Driftkomp;
         if(cnt * 16 > FromNaviCtrl_Value.Kalman_MaxDrift) cnt = FromNaviCtrl_Value.Kalman_MaxDrift/16;
         if(IntegralFehlerRoll >  FEHLER_LIMIT)   AdNeutralRoll += cnt;
         if(IntegralFehlerRoll < -FEHLER_LIMIT)   AdNeutralRoll -= cnt;
   }
-  else
+  else
   {
    LageKorrekturRoll = 0;
    LageKorrekturNick = 0;
    TrichterFlug = 0;
   }
   if(!IntegralFaktor) { LageKorrekturRoll = 0; LageKorrekturNick = 0;} // z.B. bei HH
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++
-   MittelIntegralNick_Alt = MittelIntegralNick;
-   MittelIntegralRoll_Alt = MittelIntegralRoll;
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++
+   MittelIntegralNick_Alt = MittelIntegralNick;
+   MittelIntegralRoll_Alt = MittelIntegralRoll;
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++
     IntegralAccNick = 0;
     IntegralAccRoll = 0;
     IntegralAccZ = 0;
 ,31 → 1016,31
  }
 //DebugOut.Analog[31] = StickRoll / (26*IntegralFaktor);
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 //  Gieren
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 //    if(GasMischanteil < 35) { if(StickGier > 10) StickGier = 10; else if(StickGier < -10) StickGier = -10;};
-    if(abs(StickGier) > 15) // war 35
+    if(abs(StickGier) > 15) // war 35
      {
       KompassSignalSchlecht = 1000;
-      if(!(EE_Parameter.GlobalConfig & CFG_KOMPASS_FIX))
-       {
-         NeueKompassRichtungMerken = 1;
+      if(!(EE_Parameter.GlobalConfig & CFG_KOMPASS_FIX))
+       {
+         NeueKompassRichtungMerken = 1;
         };
      }
     tmp_int  = (long) EE_Parameter.Gier_P * ((long)StickGier * abs(StickGier)) / 512L; // expo  y = ax + bx²
-    tmp_int += (EE_Parameter.Gier_P * StickGier) / 4;
+    tmp_int += (EE_Parameter.Gier_P * StickGier) / 4;
     sollGier = tmp_int;
-    Mess_Integral_Gier -= tmp_int;
+    Mess_Integral_Gier -= tmp_int;
     if(Mess_Integral_Gier > 50000) Mess_Integral_Gier = 50000;  // begrenzen
     if(Mess_Integral_Gier <-50000) Mess_Integral_Gier =-50000;
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 //  Kompass
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 //DebugOut.Analog[29] = (MaxStickNick + MaxStickRoll);
-    if(KompassValue && (EE_Parameter.GlobalConfig & CFG_KOMPASS_AKTIV))
+    if(KompassValue && (EE_Parameter.GlobalConfig & CFG_KOMPASS_AKTIV))
      {
        int w,v,r,fehler,korrektur;
        w = abs(IntegralNick /512); // mit zunehmender Neigung den Einfluss drosseln
 ,16 → 1048,16
        if(v > w) w = v; // grösste Neigung ermitteln
        korrektur = w / 8 + 1;
        fehler = ((540 + KompassValue - (ErsatzKompass/GIER_GRAD_FAKTOR)) % 360) - 180;
-           if(NeueKompassRichtungMerken)
+           if(NeueKompassRichtungMerken)
             {
                  fehler = 0;
                  ErsatzKompass = KompassValue * GIER_GRAD_FAKTOR;
-                }
+                }
        if(!KompassSignalSchlecht && w < 25)
         {
         GierGyroFehler += fehler;
-        if(NeueKompassRichtungMerken)
-         {
+        if(NeueKompassRichtungMerken)
+         {
           beeptime = 200;
 //         KompassStartwert = KompassValue;
           KompassStartwert = (ErsatzKompass/GIER_GRAD_FAKTOR);
 ,27 → 1069,27
        w = Parameter_KompassWirkung - w;                  // Wirkung ggf drosseln
        if(w >= 0)
         {
-          if(!KompassSignalSchlecht)
+          if(!KompassSignalSchlecht)
           {
-           v = 64 + ((MaxStickNick + MaxStickRoll)) / 8;
+           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
+           else
            if(v < -w) v = -w;
            Mess_Integral_Gier += v;
-          }
+          }
           if(KompassSignalSchlecht) KompassSignalSchlecht--;
-        }
+        }
         else KompassSignalSchlecht = 500; // so lange das Signal taub stellen --> ca. 1 sek
-     }
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+     }
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 //  Debugwerte zuordnen
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
   if(!TimerWerteausgabe--)
    {
     TimerWerteausgabe = 24;
 ,7 → 1103,7
     DebugOut.Analog[6] = (Mess_Integral_Hoch / 512);
     DebugOut.Analog[8] = KompassValue;
     DebugOut.Analog[9] = UBat;
-    DebugOut.Analog[11] = ErsatzKompass / GIER_GRAD_FAKTOR;
+    DebugOut.Analog[11] = ErsatzKompass / GIER_GRAD_FAKTOR;
     DebugOut.Analog[10] = SenderOkay;
     //DebugOut.Analog[16] = Mittelwert_AccHoch;
     DebugOut.Analog[17] = FromNaviCtrl_Value.Distance;
 ,17 → 1135,17
 //    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] = 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
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
     if(Looping_Nick) MesswertNick = MesswertNick * GyroFaktor;
     else             MesswertNick = IntegralNick * IntegralFaktor + MesswertNick * GyroFaktor;
 ,10 → 1165,10
     if(MesswertGier >  MAX_SENSOR) MesswertGier =  MAX_SENSOR;
     if(MesswertGier < -MAX_SENSOR) MesswertGier = -MAX_SENSOR;
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // Höhenregelung
 // Die Höhenregelung schwächt lediglich das Gas ab, erhöht es allerdings nicht
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 //OCR0B = 180 - (Poti1 + 120) / 4;
 //DruckOffsetSetting = OCR0B;
   GasMischanteil *= STICK_GAIN;
 ,36 → 1190,36
       {
        if(!delay--)
             {
-         if(MessLuftdruck > 1000)
+         if(MessLuftdruck > 1000)
                   {
                    ExpandBaro -= 10;
-                   OCR0A = DruckOffsetSetting - ExpandBaro;
+                   OCR0A = DruckOffsetSetting - ExpandBaro;
                    beeptime = 300;
            delay = 250;
                   }
                   else
-         if(MessLuftdruck < 100)
+         if(MessLuftdruck < 100)
                   {
                    ExpandBaro += 10;
-                   OCR0A = DruckOffsetSetting - ExpandBaro;
+                   OCR0A = DruckOffsetSetting - ExpandBaro;
                    beeptime = 300;
            delay = 250;
                   }
           else
-          {
+          {
                SollHoehe = HoehenWert - 20;  // Parameter_MaxHoehe ist der PPM-Wert des Schalters
            HoehenReglerAktiv = 0;
                    delay = 1;
                   }
-                }
+                }
       }
-      else
-        {
+      else
+        {
          HoehenReglerAktiv = 1;
                  delay = 200;
-                }
+                }
     }
-    else
+    else
     {
      SollHoehe = ((int) ExternHoehenValue + (int) Parameter_MaxHoehe) * (int)EE_Parameter.Hoehe_Verstaerkung - 20;
      HoehenReglerAktiv = 1;
 ,7 → 1228,7
     if(Notlandung) SollHoehe = 0;
     h = HoehenWert;
     if((h > SollHoehe) && HoehenReglerAktiv)      // zu hoch --> drosseln
-     {
+     {
       h = ((h - SollHoehe) * (int) Parameter_Hoehe_P) / (16 / STICK_GAIN); // Differenz bestimmen --> P-Anteil
       h = GasMischanteil - h;         // vom Gas abziehen
 //      h -= (HoeheD * Parameter_Luftdruck_D)/(8/STICK_GAIN);    // D-Anteil
 ,24 → 1237,24
       if(tmp_int > 70*STICK_GAIN) tmp_int = 70*STICK_GAIN;
       else if(tmp_int < -(70*STICK_GAIN)) tmp_int = -(70*STICK_GAIN);
       h -= tmp_int;
-      hoehenregler = (hoehenregler*15 + h) / 16;
+      hoehenregler = (hoehenregler*15 + h) / 16;
       if(hoehenregler < EE_Parameter.Hoehe_MinGas * STICK_GAIN) // nicht unter MIN
        {
          if(GasMischanteil >= EE_Parameter.Hoehe_MinGas * STICK_GAIN) hoehenregler = EE_Parameter.Hoehe_MinGas * STICK_GAIN;
          if(GasMischanteil < EE_Parameter.Hoehe_MinGas * STICK_GAIN) hoehenregler = GasMischanteil;
-       }
+       }
       if(hoehenregler > GasMischanteil) hoehenregler = GasMischanteil; // nicht mehr als Gas
       GasMischanteil = hoehenregler;
-     }
+     }
   }
   if(GasMischanteil > (MAX_GAS - 20) * STICK_GAIN) GasMischanteil = (MAX_GAS - 20) * STICK_GAIN;
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // + Mischer und PI-Regler
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
   DebugOut.Analog[7] = GasMischanteil;
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // Gier-Anteil
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 #define MUL_G  1.0
     GierMischanteil = MesswertGier - sollGier * STICK_GAIN;     // Regler für Gier
 // GierMischanteil = 0;
 ,38 → 1261,38
 #define MIN_GIERGAS  (40*STICK_GAIN)  // unter diesem Gaswert trotzdem Gieren
    if(GasMischanteil > MIN_GIERGAS)
     {
-     if(GierMischanteil > (GasMischanteil / 2)) GierMischanteil = GasMischanteil / 2;
-     if(GierMischanteil < -(GasMischanteil / 2)) GierMischanteil = -(GasMischanteil / 2);
+     if(GierMischanteil > (GasMischanteil / 2)) GierMischanteil = GasMischanteil / 2;
+     if(GierMischanteil < -(GasMischanteil / 2)) GierMischanteil = -(GasMischanteil / 2);
     }
-    else
+    else
     {
-     if(GierMischanteil > (MIN_GIERGAS / 2))  GierMischanteil = MIN_GIERGAS / 2;
-     if(GierMischanteil < -(MIN_GIERGAS / 2)) GierMischanteil = -(MIN_GIERGAS / 2);
+     if(GierMischanteil > (MIN_GIERGAS / 2))  GierMischanteil = MIN_GIERGAS / 2;
+     if(GierMischanteil < -(MIN_GIERGAS / 2)) GierMischanteil = -(MIN_GIERGAS / 2);
     }
     tmp_int = MAX_GAS*STICK_GAIN;
-    if(GierMischanteil > ((tmp_int - GasMischanteil))) GierMischanteil = ((tmp_int - GasMischanteil));
+    if(GierMischanteil > ((tmp_int - GasMischanteil))) GierMischanteil = ((tmp_int - GasMischanteil));
     if(GierMischanteil < -((tmp_int - GasMischanteil))) GierMischanteil = -((tmp_int - GasMischanteil));
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // Nick-Achse
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
     DiffNick = MesswertNick - StickNick;        // Differenz bestimmen
     if(IntegralFaktor) SummeNick += IntegralNick * IntegralFaktor - StickNick; // I-Anteil bei Winkelregelung
-    else  SummeNick += DiffNick; // I-Anteil bei HH
+    else  SummeNick += DiffNick; // I-Anteil bei HH
     if(SummeNick >  (STICK_GAIN * 16000L)) SummeNick =  (STICK_GAIN * 16000L);
     if(SummeNick < -(16000L * STICK_GAIN)) SummeNick = -(16000L * STICK_GAIN);
-    pd_ergebnis = DiffNick + Ki * SummeNick; // PI-Regler für Nick
+    pd_ergebnis = DiffNick + Ki * SummeNick; // PI-Regler für Nick
     // Motor Vorn
     tmp_int = (long)((long)Parameter_DynamicStability * (long)(GasMischanteil + abs(GierMischanteil)/2)) / 64;
-    if(pd_ergebnis >  tmp_int) pd_ergebnis =  tmp_int;
-    if(pd_ergebnis < -tmp_int) pd_ergebnis = -tmp_int;
+    if(pd_ergebnis >  tmp_int) pd_ergebnis =  tmp_int;
+    if(pd_ergebnis < -tmp_int) pd_ergebnis = -tmp_int;
     motorwert = GasMischanteil + pd_ergebnis + GierMischanteil;   // Mischer
     motorwert /= STICK_GAIN;
         if ((motorwert < 0)) motorwert = 0;
         else if(motorwert > MAX_GAS)        motorwert = MAX_GAS;
-        if (motorwert < MIN_GAS)            motorwert = MIN_GAS;
-        Motor_Vorne = motorwert;
+        if (motorwert < MIN_GAS)            motorwert = MIN_GAS;
+        Motor_Vorne = motorwert;
     // Motor Heck
         motorwert = GasMischanteil - pd_ergebnis + GierMischanteil;
     motorwert /= STICK_GAIN;
 ,10 → 1299,10
         if ((motorwert < 0)) motorwert = 0;
         else if(motorwert > MAX_GAS)        motorwert = MAX_GAS;
         if (motorwert < MIN_GAS)            motorwert = MIN_GAS;
-        Motor_Hinten = motorwert;
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+        Motor_Hinten = motorwert;
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // Roll-Achse
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
         DiffRoll = MesswertRoll - StickRoll;    // Differenz bestimmen
     if(IntegralFaktor) SummeRoll += IntegralRoll * IntegralFaktor - StickRoll;// I-Anteil bei Winkelregelung
     else                 SummeRoll += DiffRoll;  // I-Anteil bei HH
 ,8 → 1310,8
     if(SummeRoll < -(16000L * STICK_GAIN)) SummeRoll = -(16000L * STICK_GAIN);
     pd_ergebnis = DiffRoll + Ki * SummeRoll;    // PI-Regler für Roll
     tmp_int = (long)((long)Parameter_DynamicStability * (long)(GasMischanteil + abs(GierMischanteil)/2)) / 64;
-    if(pd_ergebnis >  tmp_int) pd_ergebnis =  tmp_int;
-    if(pd_ergebnis < -tmp_int) pd_ergebnis = -tmp_int;
+    if(pd_ergebnis >  tmp_int) pd_ergebnis =  tmp_int;
+    if(pd_ergebnis < -tmp_int) pd_ergebnis = -tmp_int;
     // Motor Links
     motorwert = GasMischanteil + pd_ergebnis - GierMischanteil;
     motorwert /= STICK_GAIN;
 ,14 → 1318,14
         if ((motorwert < 0)) motorwert = 0;
         else if(motorwert > MAX_GAS)            motorwert = MAX_GAS;
         if (motorwert < MIN_GAS)            motorwert = MIN_GAS;
-    Motor_Links = motorwert;
+    Motor_Links = motorwert;
     // Motor Rechts
         motorwert = GasMischanteil - pd_ergebnis - GierMischanteil;
     motorwert /= STICK_GAIN;
         if ((motorwert < 0)) motorwert = 0;
         else if(motorwert > MAX_GAS)            motorwert = MAX_GAS;
-        if (motorwert < MIN_GAS)            motorwert = MIN_GAS;
-    Motor_Rechts = motorwert;
+        if (motorwert < MIN_GAS)            motorwert = MIN_GAS;
+    Motor_Rechts = motorwert;
    // +++++++++++++++++++++++++++++++++++++++++++++++
 }

 /trunk/main.c
 ,14 → 3,14
 // + 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 und 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.
+// + Es gilt für das gesamte Projekt (Hardware, Software, Binärfiles, Sourcecode und Dokumentation),
+// + dass eine Nutzung (auch auszugsweise) nur für den privaten und 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,
+// + 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
 ,21 → 21,21
 // + 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
+// + 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,
+// + 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
+// +   * 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
+// +     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
+// +   * 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
 ,7 → 47,7
 // +  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.
+// +  POSSIBILITY OF SUCH DAMAGE.
 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 #include "main.h"
 ,7 → 55,7
 unsigned char PlatinenVersion = 10;
 unsigned char SendVersionToNavi = 1;
 // -- Parametersatz aus EEPROM lesen ---
-// number [1..5]
+// number [1..5]
 void ReadParameterSet(unsigned char number, unsigned char *buffer, unsigned char length)
 {
    if((number > 5)||(number < 1)) number = 3;
 ,10 → 65,10
 }
 // -- Parametersatz ins EEPROM schreiben ---
-// number [1..5]
+// number [1..5]
 void WriteParameterSet(unsigned char number, unsigned char *buffer, unsigned char length)
 {
-   if(number > 5) number = 5;
+   if(number > 5) number = 5;
    if(number < 1) return;
    number--;
    eeprom_write_block(buffer, &EEPromArray[EEPROM_ADR_PARAM_BEGIN + length * number], length);
 ,11 → 80,11
 {
  unsigned char set;
  set = eeprom_read_byte(&EEPromArray[EEPROM_ADR_ACTIVE_SET]);
- if(set > 5)
-  {
-   set = 2;
+ if(set > 5)
+  {
+   set = 2;
    eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACTIVE_SET], set);                                 // diesen Parametersatz als aktuell merken
-  }
+  }
  return(set);
 }
 ,11 → 97,11
   {
    stick = 1;
    WinkelOut.CalcState++;
-   if(WinkelOut.CalcState > 4)
-    {
+   if(WinkelOut.CalcState > 4)
+    {
 //     WinkelOut.CalcState = 0; // in Uart.c
      beeptime = 1000;
-    }
+    }
    else Piep(WinkelOut.CalcState);
   }
   DebugOut.Analog[19] = WinkelOut.CalcState;
 ,18 → 115,18
         unsigned int timer;
         //unsigned int timer2 = 0;
-    DDRB  = 0x00;
-    PORTB = 0x00;
+    DDRB  = 0x00;
+    PORTB = 0x00;
     for(timer = 0; timer < 1000; timer++); // verzögern
-    if(PINB & 0x01)
+    if(PINB & 0x01)
      {
-      if(PINB & 0x02) PlatinenVersion = 13;
-       else           PlatinenVersion = 11;
+      if(PINB & 0x02) PlatinenVersion = 13;
+       else           PlatinenVersion = 11;
      }
-    else
+    else
      {
-      if(PINB & 0x02) PlatinenVersion = 20;
-       else           PlatinenVersion = 10;
+      if(PINB & 0x02) PlatinenVersion = 20;
+       else           PlatinenVersion = 10;
      }
     DDRC  = 0x81; // SCL
 ,8 → 137,8
     DDRD  = 0x3E; // Speaker & TXD & J3 J4 J5
     DDRD  |=0x80; // J7 -> Servo signal
         PORTD = 0x77; // LED
     MCUSR &=~(1<<WDRF);
     WDTCSR |= (1<<WDCE)|(1<<WDE);
     WDTCSR = 0;
 ,7 → 148,7
         StickGier = 0; PPM_in[K_GAS] = 0;StickRoll = 0; StickNick = 0;
     ROT_OFF;
     Timer_Init();
         UART_Init();
     rc_sum_init();
 ,17 → 155,10
         ADC_Init();
         i2c_init();
         SPI_MasterInit();
         sei();
-    VersionInfo.Hauptversion = VERSION_HAUPTVERSION;
-    VersionInfo.Nebenversion = VERSION_NEBENVERSION;
-    VersionInfo.PCKompatibel = VERSION_KOMPATIBEL;
-    VersionInfo.NaviKompatibel = NAVI_KOMPATIBEL;
-    VersionInfo.Hardware = 1; // FlightCtrl
-        VersionInfo.Patch        = VERSION_INDEX;
-        printf("\n\rFlightControl\n\rHardware:%d.%d\n\rSoftware:V%d.%d%c ",PlatinenVersion/10,PlatinenVersion%10, VERSION_HAUPTVERSION, VERSION_NEBENVERSION,VERSION_INDEX + 'a');
+        printf("\n\rFlightControl\n\rHardware:%d.%d\n\rSoftware:V%d.%d%c ",PlatinenVersion/10,PlatinenVersion%10, VERSION_MAJOR, VERSION_MINOR,VERSION_PATCH + 'a');
         printf("\n\r==============================");
         GRN_ON;
 ,80 → 166,78
 #define EE_DATENREVISION 72 // wird angepasst, wenn sich die EEPROM-Daten geändert haben
         ReadParameterSet(0, (unsigned char *) &EE_Parameter.Kanalbelegung[0], 9); // read only the first bytes
     // valid Stick-Settings?
-    if(eeprom_read_byte(&EEPromArray[EEPROM_ADR_VALID]) == 255 || eeprom_read_byte(&EEPromArray[EEPROM_ADR_VALID]) < 72 ||
+    if(eeprom_read_byte(&EEPromArray[EEPROM_ADR_VALID]) == 255 || eeprom_read_byte(&EEPromArray[EEPROM_ADR_VALID]) < 72 ||
         EE_Parameter.Kanalbelegung[0] > 9 || EE_Parameter.Kanalbelegung[1] > 9 || EE_Parameter.Kanalbelegung[2] > 9 || EE_Parameter.Kanalbelegung[3] > 9)
-           {
+           {
             printf("\n\rInit. EEPROM: Generating Default-Parameter and Stick-Settings...");
         DefaultStickMapping();
        }
     else if(eeprom_read_byte(&EEPromArray[EEPROM_ADR_VALID]) != EE_DATENREVISION) printf("\n\rInit. EEPROM: Generating Default-Parameter using old Stick Settings");
-    if(eeprom_read_byte(&EEPromArray[EEPROM_ADR_VALID]) != EE_DATENREVISION)
-        {
+    if(eeprom_read_byte(&EEPromArray[EEPROM_ADR_VALID]) != EE_DATENREVISION)
+        {
           DefaultKonstanten1();
-          for (unsigned char i=1;i<6;i++)
+          for (unsigned char i=1;i<6;i++)
       {
        if(i==2) DefaultKonstanten2(); // Kamera
        if(i==3) DefaultKonstanten3(); // Beginner
        if(i>3)  DefaultKonstanten2(); // Kamera
        WriteParameterSet(i, (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);
-      }
+      }
           eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACTIVE_SET], 3); // default-Setting
           eeprom_write_byte(&EEPromArray[EEPROM_ADR_VALID], EE_DATENREVISION);
         }
-    if(eeprom_read_byte(&EEPromArray[EEPROM_ADR_ACC_NICK]) > 4)
+    if(eeprom_read_byte(&EEPromArray[EEPROM_ADR_ACC_NICK]) > 4)
      {
        printf("\n\rACC nicht abgeglichen!");
      }
         ReadParameterSet(GetActiveParamSetNumber(), (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);
     printf("\n\rBenutze Parametersatz %d", GetActiveParamSetNumber());
         if(EE_Parameter.GlobalConfig & CFG_HOEHENREGELUNG)
-         {
+         {
            printf("\n\rAbgleich Luftdrucksensor..");
-           timer = SetDelay(1000);
+           timer = SetDelay(1000);
        SucheLuftruckOffset();
            while (!CheckDelay(timer));
        printf("OK\n\r");
         }
         SetNeutral();
         ROT_OFF;
     beeptime = 2000;
-    ExternControl.Digital[0] = 0x55;
+    ExternControl.Digital[0] = 0x55;
         printf("\n\rSteuerung: ");
         if (EE_Parameter.GlobalConfig & CFG_HEADING_HOLD) printf("HeadingHold");
         else printf("Neutral");
         printf("\n\n\r");
     LcdClear();
     I2CTimeout = 5000;
     WinkelOut.Orientation = 1;
         while (1)
         {
                 if(UpdateMotor)      // ReglerIntervall
-            {
-                    UpdateMotor=0;
+            {
+                    UpdateMotor=0;
 //PORTD |= 0x08;
             if(WinkelOut.CalcState) CalMk3Mag();
-            else MotorRegler();
+            else MotorRegler();
 //PORTD &= ~0x08;
             SendMotorData();
             ROT_OFF;
-            if(PcZugriff) PcZugriff--;
-             else
+            if(PcZugriff) PcZugriff--;
+             else
               {
-               DubWiseKeys[0] = 0;
-               DubWiseKeys[1] = 0;
                            ExternControl.Config = 0;
                ExternStickNick = 0;
                ExternStickRoll = 0;
 ,16 → 248,16
                 {
                  I2CTimeout = 5;
                  i2c_reset();
-                  if((BeepMuster == 0xffff) && MotorenEin)
-                   {
+                  if((BeepMuster == 0xffff) && MotorenEin)
+                   {
                     beeptime = 10000;
                     BeepMuster = 0x0080;
-                   }
+                   }
                 }
-            else
+            else
                 {
                  I2CTimeout--;
-                 ROT_OFF;
+                 ROT_OFF;
                 }
             if(SIO_DEBUG && (!UpdateMotor || !MotorenEin))
               {
 ,16 → 266,16
               }
               else BearbeiteRxDaten();
          if(CheckDelay(timer))
-            {
+            {
             if(UBat < EE_Parameter.UnterspannungsWarnung)
-                {
-                  if(BeepMuster == 0xffff)
-                   {
+                {
+                  if(BeepMuster == 0xffff)
+                   {
                     beeptime = 6000;
                     BeepMuster = 0x0300;
-                   }
+                   }
                 }
-/*           if(SendVersionToNavi)
+/*           if(SendVersionToNavi)
               {
                SPI_StartTransmitPacket(SPI_CMD_VERSION);//#
                SendVersionToNavi = 0;
 ,8 → 285,8
              SPI_StartTransmitPacket();//#
              SendSPI = 4;
-                         timer = SetDelay(20);
-            }
+                         timer = SetDelay(20);
+            }
            //if(UpdateMotor) DebugOut.Analog[26]++;
            LED_Update();
           }

 /trunk/makefile
 ,12 → 3,12
 MCU = atmega644
 F_CPU = 20000000
 #-------------------------------------------------------------------
-HAUPT_VERSION    =   0
-NEBEN_VERSION    =  71
-VERSION_INDEX    =   5
+VERSION_MAJOR    =   0
+VERSION_MINOR    =  71
+VERSION_PATCH    =   6
-VERSION_KOMPATIBEL = 9  # PC-Kompatibilität
-NAVI_KOMPATIBEL = 1     # Navi-Kompatibilität
+VERSION_SERIAL_COMPATIBLE = 10  # PC-Kompatibilität
+NC_SPI_COMPATIBLE = 2           # Navi-Kompatibilität
 #-------------------------------------------------------------------
 ifeq ($(MCU), atmega32)
 ,38 → 44,38
 # Target file name (without extension).
-ifeq ($(VERSION_INDEX), 0)
-TARGET = Flight-Ctrl_$(HEX_NAME)_V$(HAUPT_VERSION)_$(NEBEN_VERSION)a
+ifeq ($(VERSION_PATCH), 0)
+TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)a
 endif
-ifeq ($(VERSION_INDEX), 1)
-TARGET = Flight-Ctrl_$(HEX_NAME)_V$(HAUPT_VERSION)_$(NEBEN_VERSION)b
+ifeq ($(VERSION_PATCH), 1)
+TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)b
 endif
-ifeq ($(VERSION_INDEX), 2)
-TARGET = Flight-Ctrl_$(HEX_NAME)_V$(HAUPT_VERSION)_$(NEBEN_VERSION)c
+ifeq ($(VERSION_PATCH), 2)
+TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)c
 endif
-ifeq ($(VERSION_INDEX), 3)
-TARGET = Flight-Ctrl_$(HEX_NAME)_V$(HAUPT_VERSION)_$(NEBEN_VERSION)d
+ifeq ($(VERSION_PATCH), 3)
+TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)d
 endif
-ifeq ($(VERSION_INDEX), 4)
-TARGET = Flight-Ctrl_$(HEX_NAME)_V$(HAUPT_VERSION)_$(NEBEN_VERSION)e
+ifeq ($(VERSION_PATCH), 4)
+TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)e
 endif
-ifeq ($(VERSION_INDEX), 5)
-TARGET = Flight-Ctrl_$(HEX_NAME)_V$(HAUPT_VERSION)_$(NEBEN_VERSION)f
+ifeq ($(VERSION_PATCH), 5)
+TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)f
 endif
-ifeq ($(VERSION_INDEX), 6)
-TARGET = Flight-Ctrl_$(HEX_NAME)_V$(HAUPT_VERSION)_$(NEBEN_VERSION)g
+ifeq ($(VERSION_PATCH), 6)
+TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)g
 endif
-ifeq ($(VERSION_INDEX), 7)
-TARGET = Flight-Ctrl_$(HEX_NAME)_V$(HAUPT_VERSION)_$(NEBEN_VERSION)h
+ifeq ($(VERSION_PATCH), 7)
+TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)h
 endif
-ifeq ($(VERSION_INDEX), 8)
-TARGET = Flight-Ctrl_$(HEX_NAME)_V$(HAUPT_VERSION)_$(NEBEN_VERSION)i
+ifeq ($(VERSION_PATCH), 8)
+TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)i
 endif
-ifeq ($(VERSION_INDEX), 9)
-TARGET = Flight-Ctrl_$(HEX_NAME)_V$(HAUPT_VERSION)_$(NEBEN_VERSION)j
+ifeq ($(VERSION_PATCH), 9)
+TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)j
 endif
-ifeq ($(VERSION_INDEX), 10)
-TARGET = Flight-Ctrl_$(HEX_NAME)_V$(HAUPT_VERSION)_$(NEBEN_VERSION)k
+ifeq ($(VERSION_PATCH), 10)
+TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)k
 endif
 # Optimization level, can be [0, 1, 2, 3, s]. 0 turns off optimization.
 ,7 → 128,7
 #CFLAGS += -std=c99
 CFLAGS += -std=gnu99
-CFLAGS += -DVERSION_HAUPTVERSION=$(HAUPT_VERSION) -DVERSION_NEBENVERSION=$(NEBEN_VERSION) -DVERSION_KOMPATIBEL=$(VERSION_KOMPATIBEL) -DNAVI_KOMPATIBEL=$(NAVI_KOMPATIBEL) -DVERSION_INDEX=$(VERSION_INDEX)
+CFLAGS += -DVERSION_MAJOR=$(VERSION_MAJOR) -DVERSION_MINOR=$(VERSION_MINOR) -DVERSION_PATCH=$(VERSION_PATCH) -DVERSION_SERIAL_COMPATIBLE=$(VERSION_SERIAL_COMPATIBLE) -DNC_SPI_COMPATIBLE=$(NC_SPI_COMPATIBLE)
 # Optional assembler flags.

 /trunk/menu.c
 ,74 → 10,66
 #define ARRAYGROESSE 10
 unsigned char Array[ARRAYGROESSE] = {1,2,3,4,5,6,7,8,9,10};
 char DisplayBuff[80] = "Hallo Welt";
-unsigned char DispPtr = 0;
-unsigned char RemoteTasten = 0;
+unsigned char DispPtr = 0;
-#define KEY1    0x01
-#define KEY2    0x02
-#define KEY3    0x04
-#define KEY4    0x08
-#define KEY5    0x10
+unsigned char MaxMenue = 11;
+unsigned char MenuePunkt = 0;
 void LcdClear(void)
 {
- unsigned char i;
- for(i=0;i<80;i++) DisplayBuff[i] = ' ';
+ unsigned char i;
+ for(i=0;i<80;i++) DisplayBuff[i] = ' ';
 }
 void Menu(void)
  {
-  static unsigned char MaxMenue = 11,MenuePunkt=255;
-  if(MenuePunkt == 255) {if(eeprom_read_byte(&EEPromArray[EEPROM_ADR_ACC_NICK]) != 255) MenuePunkt = 0; else MenuePunkt = 5;}
-  if(RemoteTasten & KEY1) { if(MenuePunkt) MenuePunkt--; else MenuePunkt = MaxMenue; LcdClear(); RemotePollDisplayLine = -1; }
-  if(RemoteTasten & KEY2) { MenuePunkt++; LcdClear(); RemotePollDisplayLine = -1;}
-  if((RemoteTasten & KEY1) && (RemoteTasten & KEY2)) MenuePunkt = 0;
-  if(MenuePunkt < 10) {LCD_printfxy(17,0,"[%i]",MenuePunkt);} else {LCD_printfxy(16,0,"[%i]",MenuePunkt);};
+  if(MenuePunkt > MaxMenue) MenuePunkt = MaxMenue;
   switch(MenuePunkt)
    {
-    case 0:
+    case 0:
            LCD_printfxy(0,0,"+ MikroKopter +");
-           LCD_printfxy(0,1,"HW:V%d.%d SW:%d.%d%c",PlatinenVersion/10,PlatinenVersion%10,VERSION_HAUPTVERSION, VERSION_NEBENVERSION,VERSION_INDEX+'a');
+           LCD_printfxy(0,1,"HW:V%d.%d SW:%d.%d%c",PlatinenVersion/10,PlatinenVersion%10, VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH +'a');
            LCD_printfxy(0,2,"Setting: %d ",GetActiveParamSetNumber());
            LCD_printfxy(0,3,"(c) Holger Buss");
 //           if(RemoteTasten & KEY3) TestInt--;
 //           if(RemoteTasten & KEY4) TestInt++;
            break;
-    case 1:
+    case 1:
           if(EE_Parameter.GlobalConfig & CFG_HOEHENREGELUNG)
-           {
+           {
            LCD_printfxy(0,0,"Hoehe:     %5i",HoehenWert);
            LCD_printfxy(0,1,"SollHoehe: %5i",SollHoehe);
            LCD_printfxy(0,2,"Luftdruck: %5i",MessLuftdruck);
            LCD_printfxy(0,3,"Off      : %5i",DruckOffsetSetting);
            }
-           else
-           {
+           else
+           {
            LCD_printfxy(0,1,"Keine ");
            LCD_printfxy(0,2,"Höhenregelung");
            }
            break;
-    case 2:
+    case 2:
            LCD_printfxy(0,0,"akt. Lage");
            LCD_printfxy(0,1,"Nick:      %5i",IntegralNick/1024);
            LCD_printfxy(0,2,"Roll:      %5i",IntegralRoll/1024);
            LCD_printfxy(0,3,"Kompass:   %5i",KompassValue);
            break;
-    case 3:
+    case 3:
            LCD_printfxy(0,0,"K1:%4i  K2:%4i ",PPM_in[1],PPM_in[2]);
            LCD_printfxy(0,1,"K3:%4i  K4:%4i ",PPM_in[3],PPM_in[4]);
            LCD_printfxy(0,2,"K5:%4i  K6:%4i ",PPM_in[5],PPM_in[6]);
            LCD_printfxy(0,3,"K7:%4i  K8:%4i ",PPM_in[7],PPM_in[8]);
            break;
-    case 4:
+    case 4:
            LCD_printfxy(0,0,"Ni:%4i  Ro:%4i ",PPM_in[EE_Parameter.Kanalbelegung[K_NICK]],PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]]);
            LCD_printfxy(0,1,"Gs:%4i  Gi:%4i ",PPM_in[EE_Parameter.Kanalbelegung[K_GAS]],PPM_in[EE_Parameter.Kanalbelegung[K_GIER]]);
            LCD_printfxy(0,2,"P1:%4i  P2:%4i ",PPM_in[EE_Parameter.Kanalbelegung[K_POTI1]],PPM_in[EE_Parameter.Kanalbelegung[K_POTI2]]);
            LCD_printfxy(0,3,"P3:%4i  P4:%4i ",PPM_in[EE_Parameter.Kanalbelegung[K_POTI3]],PPM_in[EE_Parameter.Kanalbelegung[K_POTI4]]);
            break;
-    case 5:
+    case 5:
            LCD_printfxy(0,0,"Gyro - Sensor");
           if(PlatinenVersion == 10)
           {
 ,7 → 77,7
            LCD_printfxy(0,2,"Roll %4i (%3i)",AdWertRoll - AdNeutralRoll, AdNeutralRoll);
            LCD_printfxy(0,3,"Gier %4i (%3i)",AdNeutralGier - AdWertGier, AdNeutralGier);
           }
-          else
+          else
           if((PlatinenVersion == 11) || (PlatinenVersion == 20))
           {
            LCD_printfxy(0,1,"Nick %4i (%3i)",AdWertNick - AdNeutralNick, AdNeutralNick/2);
 ,35 → 93,35
           }
            break;
-    case 6:
+    case 6:
            LCD_printfxy(0,0,"ACC - Sensor");
            LCD_printfxy(0,1,"Nick %4i (%3i)",AdWertAccNick,NeutralAccX);
            LCD_printfxy(0,2,"Roll %4i (%3i)",AdWertAccRoll,NeutralAccY);
            LCD_printfxy(0,3,"Hoch %4i (%3i)",Mittelwert_AccHoch/*accumulate_AccHoch / messanzahl_AccHoch*/,(int)NeutralAccZ);
            break;
-    case 7:
+    case 7:
            LCD_printfxy(0,1,"Spannung:  %5i",UBat);
            LCD_printfxy(0,2,"Empf.Pegel:%5i",SenderOkay);
            break;
-    case 8:
+    case 8:
            LCD_printfxy(0,0,"Kompass       ");
            LCD_printfxy(0,1,"Richtung:  %5i",KompassRichtung);
            LCD_printfxy(0,2,"Messwert:  %5i",KompassValue);
            LCD_printfxy(0,3,"Start:     %5i",KompassStartwert);
            break;
-    case 9:
+    case 9:
            LCD_printfxy(0,0,"Poti1:  %3i",Poti1);
            LCD_printfxy(0,1,"Poti2:  %3i",Poti2);
            LCD_printfxy(0,2,"Poti3:  %3i",Poti3);
            LCD_printfxy(0,3,"Poti4:  %3i",Poti4);
            break;
-    case 10:
+    case 10:
            LCD_printfxy(0,0,"Servo  " );
            LCD_printfxy(0,1,"Setpoint  %3i",Parameter_ServoNickControl);
            LCD_printfxy(0,2,"Stellung: %3i",ServoValue);
            LCD_printfxy(0,3,"Range:%3i-%3i",EE_Parameter.ServoNickMin,EE_Parameter.ServoNickMax);
            break;
-    case 11:
+    case 11:
            LCD_printfxy(0,0,"ExternControl  " );
            LCD_printfxy(0,1,"Ni:%4i  Ro:%4i ",ExternControl.Nick,ExternControl.Roll);
            LCD_printfxy(0,2,"Gs:%4i  Gi:%4i ",ExternControl.Gas,ExternControl.Gier);
 ,8 → 128,7
            LCD_printfxy(0,3,"Hi:%4i  Cf:%4i ",ExternControl.Hight,ExternControl.Config);
            break;
     default: MaxMenue = MenuePunkt - 1;
-             MenuePunkt = 0;
+             MenuePunkt = 0;
            break;
     }
- RemoteTasten = 0;
 }

 /trunk/menu.h
 ,5 → 2,8
 extern void LcdClear(void);
 extern char DisplayBuff[80];
 extern unsigned char DispPtr;
-extern unsigned char RemoteTasten;
+extern unsigned char MaxMenue;
+extern unsigned char MenuePunkt;

 /trunk/spi.c
 ,6 → 7,7
 struct str_ToNaviCtrl   ToNaviCtrl;
 struct str_FromNaviCtrl   FromNaviCtrl;
 struct str_FromNaviCtrl_Value FromNaviCtrl_Value;
+struct str_SPI_VersionInfo SPI_VersionInfo;
 unsigned char              SPI_BufferIndex;
 unsigned char              SPI_RxBufferIndex;
 ,24 → 26,29
 //------------------------------------------------------
 void SPI_MasterInit(void)
 {
-  DDR_SPI |= (1<<DD_MOSI)|(1<<DD_SCK);    // Set MOSI and SCK output, all others input
+  DDR_SPI |= (1<<DD_MOSI)|(1<<DD_SCK);    // Set MOSI and SCK output, all others input
   SLAVE_SELECT_DDR_PORT |= (1 << SPI_SLAVE_SELECT);
-  SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR1)|(0<<SPR0)|(0<<SPIE);   // Enable SPI, Master, set clock rate fck/64
+  SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR1)|(0<<SPR0)|(0<<SPIE);   // Enable SPI, Master, set clock rate fck/64
   SPSR = 0;//(1<<SPI2X);
-  SLAVE_SELECT_PORT |=  (1 << SPI_SLAVE_SELECT);
+  SLAVE_SELECT_PORT |=  (1 << SPI_SLAVE_SELECT);
   SPITransferCompleted = 1;
   //SPDR = 0x00;  // dummy write
   ToNaviCtrl.Sync1 = 0xAA;
   ToNaviCtrl.Sync2 = 0x83;
   ToNaviCtrl.Command = SPI_CMD_USER;
   ToNaviCtrl.IntegralNick = 0;
   ToNaviCtrl.IntegralRoll = 0;
-  SPI_RxDataValid = 0;
+  SPI_RxDataValid = 0;
+  SPI_VersionInfo.Major = VERSION_MAJOR;
+  SPI_VersionInfo.Minor = VERSION_MINOR;
+  SPI_VersionInfo.Patch = VERSION_PATCH;
+  SPI_VersionInfo.Compatible = NC_SPI_COMPATIBLE;
 }
 //------------------------------------------------------
 ,19 → 56,19
 {
    //if ((SLAVE_SELECT_PORT & (1 << SPI_SLAVE_SELECT)) == 0) return;    // transfer of prev. packet not completed
    if (!SPITransferCompleted) return;
-//   _delay_us(30);
+//   _delay_us(30);
    SLAVE_SELECT_PORT &=  ~(1 << SPI_SLAVE_SELECT);  // SelectSlave
    SPI_TX_Buffer = (unsigned char *) &ToNaviCtrl;
    ToNaviCtrl.Command = SPI_CommandSequence[SPI_CommandCounter++];
    if (SPI_CommandCounter >= sizeof(SPI_CommandSequence)) SPI_CommandCounter = 0;
    SPITransferCompleted = 0;
    UpdateSPI_Buffer();                              // update buffer
    SPI_BufferIndex = 1;
-  //ebugOut.Analog[16]++;
+  //ebugOut.Analog[16]++;
    // -- Debug-Output ---
    //----
    asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");         asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");
 ,7 → 75,7
    asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");         asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");
    asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");         asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");
    ToNaviCtrl.Chksum = ToNaviCtrl.Sync1;
-   SPDR = ToNaviCtrl.Sync1;                  // Start transmission
+   SPDR = ToNaviCtrl.Sync1;                  // Start transmission
 //     SLAVE_SELECT_PORT |=  (1 << SPI_SLAVE_SELECT);   // DeselectSlave
 }
 ,71 → 85,71
 void SPI_TransmitByte(void)
 {
    static unsigned char SPI_RXState = 0;
-   unsigned char rxdata;
+   unsigned char rxdata;
    static unsigned char rxchksum;
    if (SPITransferCompleted) return;
    if (!(SPSR & (1 << SPIF))) return;
-  SendSPI = 4;
-//   _delay_us(30);
+  SendSPI = 4;
+//   _delay_us(30);
   SLAVE_SELECT_PORT |=  (1 << SPI_SLAVE_SELECT);   // DeselectSlave
   rxdata = SPDR;
   switch ( SPI_RXState)
   {
-  case 0:
-                        SPI_RxBufferIndex = 0;
+  case 0:
+                        SPI_RxBufferIndex = 0;
                         //DebugOut.Analog[17]++;
-                        rxchksum = rxdata;
-                        if (rxdata == 0x81 )  { SPI_RXState  = 1;  }   // 1. Syncbyte ok
+                        rxchksum = rxdata;
+                        if (rxdata == 0x81 )  { SPI_RXState  = 1;  }   // 1. Syncbyte ok
            break;
-   case 1:
-                    if (rxdata == 0x55) { rxchksum += rxdata; SPI_RXState  = 2;  }   // 2. Syncbyte ok
-                 else SPI_RXState  = 0;
+   case 1:
+                    if (rxdata == 0x55) { rxchksum += rxdata; SPI_RXState  = 2;  }   // 2. Syncbyte ok
+                 else SPI_RXState  = 0;
                         //DebugOut.Analog[18]++;
-           break;
+           break;
    case 2:
                    SPI_Buffer[SPI_RxBufferIndex++]= rxdata;             // get data
            //DebugOut.Analog[19]++;
-           if (SPI_RxBufferIndex >= sizeof(FromNaviCtrl))
-                   {
+           if (SPI_RxBufferIndex >= sizeof(FromNaviCtrl))
+                   {
                 if (rxdata == rxchksum)
                         {
                   unsigned char *ptr = (unsigned char *)&FromNaviCtrl;
                           memcpy(ptr, (unsigned char *) SPI_Buffer,  sizeof(SPI_Buffer));
-                          SPI_RxDataValid = 1;
-                        }
-                        else SPI_RxDataValid = 0;
-                        SPI_RXState  = 0;
+                          SPI_RxDataValid = 1;
+                        }
+                        else SPI_RxDataValid = 0;
+                        SPI_RXState  = 0;
                    }
-                  else rxchksum += rxdata;
-        break;
-  }
-   if (SPI_BufferIndex < sizeof(ToNaviCtrl))
-     {
+                  else rxchksum += rxdata;
+        break;
+  }
+   if (SPI_BufferIndex < sizeof(ToNaviCtrl))
+     {
            SLAVE_SELECT_PORT &=  ~(1 << SPI_SLAVE_SELECT);  // SelectSlave
            asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");         asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");
            asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");         asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");
            asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");         asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop");
            SPDR = SPI_TX_Buffer[SPI_BufferIndex];
            ToNaviCtrl.Chksum += SPI_TX_Buffer[SPI_BufferIndex];
         //   SLAVE_SELECT_PORT |=  (1 << SPI_SLAVE_SELECT);   // DeselectSlave
          }
-         else SPITransferCompleted = 1;
+         else SPITransferCompleted = 1;
          SPI_BufferIndex++;
 }
 ,10 → 160,10
   static unsigned char i =0;
   signed int tmp;
   cli();
   ToNaviCtrl.IntegralNick = (int) (IntegralNick / 108);
   ToNaviCtrl.IntegralRoll = (int) (IntegralRoll / 108);
-  ToNaviCtrl.GyroCompass = ErsatzKompass / GIER_GRAD_FAKTOR;
+  ToNaviCtrl.GyroCompass = ErsatzKompass / GIER_GRAD_FAKTOR;
   ToNaviCtrl.AccNick = (int) ACC_AMPLIFY * (NaviAccNick / NaviCntAcc);
   ToNaviCtrl.AccRoll = (int) ACC_AMPLIFY * (NaviAccRoll / NaviCntAcc);
   NaviCntAcc = 0; NaviAccNick = 0; NaviAccRoll = 0;
 ,9 → 170,9
 //  ToNaviCtrl.User8 = Parameter_UserParam8;
 //  ToNaviCtrl.CalState = WinkelOut.CalcState;
-   switch(ToNaviCtrl.Command)  //
+   switch(ToNaviCtrl.Command)  //
    {
-         case SPI_CMD_USER:
+         case SPI_CMD_USER:
                                 ToNaviCtrl.Param.Byte[0] = Parameter_UserParam1;
                                 ToNaviCtrl.Param.Byte[1] = Parameter_UserParam2;
                                 ToNaviCtrl.Param.Byte[2] = Parameter_UserParam3;
 ,20 → 187,20
                     ToNaviCtrl.Param.Byte[10] =(unsigned char) EE_Parameter.UnterspannungsWarnung;
                     ToNaviCtrl.Param.Byte[11] =(unsigned char) eeprom_read_byte(&EEPromArray[EEPROM_ADR_ACTIVE_SET]);
         break;
-         case SPI_CMD_PARAMETER1:
+         case SPI_CMD_PARAMETER1:
                                 ToNaviCtrl.Param.Byte[0] = EE_Parameter.NaviGpsModeControl;     // Parameters for the Naviboard
-                                ToNaviCtrl.Param.Byte[1] = EE_Parameter.NaviGpsGain;
-                                ToNaviCtrl.Param.Byte[2] = EE_Parameter.NaviGpsP;
-                                ToNaviCtrl.Param.Byte[3] = EE_Parameter.NaviGpsI;
-                                ToNaviCtrl.Param.Byte[4] = EE_Parameter.NaviGpsD;
-                                ToNaviCtrl.Param.Byte[5] = EE_Parameter.NaviGpsACC;
-                                ToNaviCtrl.Param.Byte[6] = EE_Parameter.NaviGpsMinSat;
-                ToNaviCtrl.Param.Byte[7] = EE_Parameter.NaviStickThreshold;
+                                ToNaviCtrl.Param.Byte[1] = EE_Parameter.NaviGpsGain;
+                                ToNaviCtrl.Param.Byte[2] = EE_Parameter.NaviGpsP;
+                                ToNaviCtrl.Param.Byte[3] = EE_Parameter.NaviGpsI;
+                                ToNaviCtrl.Param.Byte[4] = EE_Parameter.NaviGpsD;
+                                ToNaviCtrl.Param.Byte[5] = EE_Parameter.NaviGpsACC;
+                                ToNaviCtrl.Param.Byte[6] = EE_Parameter.NaviGpsMinSat;
+                ToNaviCtrl.Param.Byte[7] = EE_Parameter.NaviStickThreshold;
                 ToNaviCtrl.Param.Byte[8] = EE_Parameter.NaviOperatingRadius;
                 ToNaviCtrl.Param.Byte[9] = EE_Parameter.NaviWindCorrection;
                 ToNaviCtrl.Param.Byte[10] = EE_Parameter.NaviSpeedCompensation;
             break;
-         case SPI_CMD_STICK:
+         case SPI_CMD_STICK:
                 tmp = PPM_in[EE_Parameter.Kanalbelegung[K_GAS]];  if(tmp > 127) tmp = 127; else if(tmp < -127) tmp = -127;
                                 ToNaviCtrl.Param.Byte[0] = (char) tmp;
                 tmp = PPM_in[EE_Parameter.Kanalbelegung[K_GIER]]; if(tmp > 127) tmp = 127; else if(tmp < -127) tmp = -127;
 ,28 → 216,27
                     ToNaviCtrl.Param.Byte[8] = (unsigned char) SenderOkay;
             break;
          case SPI_CMD_MISC:
-                if(WinkelOut.CalcState > 5)
+                if(WinkelOut.CalcState > 5)
                   {
-                    WinkelOut.CalcState = 0;
-                    ToNaviCtrl.Param.Byte[0] = 5;
-                  }
+                    WinkelOut.CalcState = 0;
+                    ToNaviCtrl.Param.Byte[0] = 5;
+                  }
                                 else ToNaviCtrl.Param.Byte[0] = WinkelOut.CalcState;
                                 ToNaviCtrl.Param.Int[1] = HoehenWert;
             break;
          case SPI_CMD_VERSION:
-                                ToNaviCtrl.Param.Byte[0] = VersionInfo.Hauptversion;
-                                ToNaviCtrl.Param.Byte[1] = VersionInfo.Nebenversion;
-                                ToNaviCtrl.Param.Byte[2] = VersionInfo.PCKompatibel;
-                                ToNaviCtrl.Param.Byte[3] = VersionInfo.Patch;
-                                ToNaviCtrl.Param.Byte[4] = VersionInfo.NaviKompatibel;
+                                ToNaviCtrl.Param.Byte[0] = SPI_VersionInfo.Major;
+                                ToNaviCtrl.Param.Byte[1] = SPI_VersionInfo.Minor;
+                                ToNaviCtrl.Param.Byte[2] = SPI_VersionInfo.Patch;
+                                ToNaviCtrl.Param.Byte[3] = SPI_VersionInfo.Compatible;
             break;
    }
   sei();
   if (SPI_RxDataValid)
-  {
+  {
    if(abs(FromNaviCtrl.GPS_Nick) < 512 && abs(FromNaviCtrl.GPS_Roll) < 512 && (EE_Parameter.GlobalConfig & CFG_GPS_AKTIV))
    {
     GPS_Nick = FromNaviCtrl.GPS_Nick;
 ,9 → 244,9
    }
     if(FromNaviCtrl.CompassValue <= 360)   KompassValue = FromNaviCtrl.CompassValue;
     KompassRichtung = ((540 + KompassValue - KompassStartwert) % 360) - 180;
     if(FromNaviCtrl.BeepTime > beeptime && !WinkelOut.CalcState) beeptime = FromNaviCtrl.BeepTime;
           switch (FromNaviCtrl.Command)
           {
             case  SPI_KALMAN:
 ,7 → 254,7
                FromNaviCtrl_Value.Kalman_MaxFusion = FromNaviCtrl.Param.Byte[1];
                FromNaviCtrl_Value.Kalman_MaxDrift = FromNaviCtrl.Param.Byte[2];
                break;
             case  SPI_CMD_OSD_DATA:
                FromNaviCtrl_Value.OsdBar = FromNaviCtrl.Param.Byte[0];
                FromNaviCtrl_Value.Distance = FromNaviCtrl.Param.Int[1];
 ,7 → 278,7
   {
 //    KompassValue = 0;
 //    KompassRichtung = 0;
         GPS_Nick = 0;
     GPS_Roll = 0;
   }

 /trunk/spi.h
 ,7 → 4,7
 #include <util/delay.h>
-#define USE_SPI_COMMUNICATION
+#define USE_SPI_COMMUNICATION
 #define SPI_PROTOCOL_COMP   1
 ,36 → 13,36
 #define DD_SS   PB4
 #define DD_SCK  PB7
 #define DD_MOSI PB5
-#define DD_MISO PB6
+#define DD_MISO PB6
-// for compatibility reasons gcc3.x <-> gcc4.x
-#ifndef SPCR
+// for compatibility reasons gcc3.x <-> gcc4.x
+#ifndef SPCR
 #define SPCR   SPCR0
-#endif
-#ifndef SPE
+#endif
+#ifndef SPE
 #define SPE   SPE0
-#endif
-#ifndef MSTR
+#endif
+#ifndef MSTR
 #define MSTR   MSTR0
-#endif
-#ifndef SPR1
+#endif
+#ifndef SPR1
 #define SPR1   SPR01
-#endif
-#ifndef SPR0
+#endif
+#ifndef SPR0
 #define SPR0   SPR00
-#endif
-#ifndef SPIE
+#endif
+#ifndef SPIE
 #define SPIE   SPIE0
-#endif
-#ifndef SPDR
+#endif
+#ifndef SPDR
 #define SPDR   SPDR0
-#endif
-#ifndef SPIF
+#endif
+#ifndef SPIF
 #define SPIF   SPIF0
-#endif
-#ifndef SPSR
+#endif
+#ifndef SPSR
 #define SPSR   SPSR0
-#endif
+#endif
 // -------------------------
 #define SLAVE_SELECT_DDR_PORT   DDRC
 ,7 → 68,7
  signed int  GyroNick;
  signed int  GyroRoll;
  signed int  GyroGier;
- union
+ union
  { char Byte[12];
    int  Int[6];
    long Long[3];
 ,7 → 75,7
    float Float[3];
  } Param;
  unsigned char Chksum;
-};
+};
 #define SPI_CMD_OSD_DATA         100
 #define SPI_CMD_GPS_POS          101
 ,7 → 91,7
   signed int  CompassValue;
   signed int  Status;
   unsigned int BeepTime;
-  union
+  union
   { char Byte[12];
     int  Int[6];
     long Long[3];
 ,7 → 98,7
     float Float[3];
   } Param;
   unsigned char Chksum;
-};
+};
 struct str_FromNaviCtrl_Value
 {
 ,6 → 109,14
  signed char Kalman_MaxFusion;
 };
+struct str_SPI_VersionInfo
+{
+  unsigned char Major;
+  unsigned char Minor;
+  unsigned char Patch;
+  unsigned char Compatible;
+};
 #ifdef USE_SPI_COMMUNICATION
 extern struct str_FromNaviCtrl_Value FromNaviCtrl_Value;
 ,7 → 134,7
 // -------------------------------- Dummy -----------------------------------------
-#define  SPI_MasterInit() ;
+#define  SPI_MasterInit() ;
 #define  SPI_StartTransmitPacket() ;
 #define  UpdateSPI_Buffer() ;
 #define  SPI_TransmitByte() ;

 /trunk/uart.c
 ,11 → 4,12
 // + www.MikroKopter.com
 // + see the File "License.txt" for further Informations
 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#include <stdarg.h>
+#include <string.h>
 #include "main.h"
 #include "uart.h"
-unsigned char GetExternalControl = 0,DebugDisplayAnforderung = 0,DebugDataAnforderung = 0,GetVersionAnforderung = 0;
+unsigned char GetExternalControl = 0,DebugDisplayAnforderung = 0,DebugDataAnforderung = 0,GetVersionAnforderung = 0, GetPPMChannelAnforderung = 0;
 unsigned volatile char SioTmp = 0;
 unsigned volatile char SendeBuffer[MAX_SENDE_BUFF];
 unsigned volatile char RxdBuffer[MAX_EMPFANGS_BUFF];
 ,13 → 19,13
 unsigned volatile char UebertragungAbgeschlossen = 1;
 unsigned volatile char CntCrcError = 0;
 unsigned volatile char AnzahlEmpfangsBytes = 0;
+unsigned char *pRxData = 0;
+unsigned char RxDataLen = 0;
 unsigned volatile char PC_DebugTimeout = 0;
-unsigned char RemotePollDisplayLine = 0;
-unsigned char NurKanalAnforderung = 0;
 unsigned char DebugTextAnforderung = 255;
 unsigned char PcZugriff = 100;
 unsigned char MotorTest[4] = {0,0,0,0};
-unsigned char DubWiseKeys[4] = {0,0,0,0};
 unsigned char MeineSlaveAdresse = 1; // Flight-Ctrl
 unsigned char ConfirmFrame;
 struct str_DebugOut    DebugOut;
 ,13 → 34,14
 struct str_WinkelOut WinkelOut;
 int Debug_Timer,Kompass_Timer;
+unsigned int DebugDataIntervall = 200;
 const unsigned char ANALOG_TEXT[32][16] =
 {
-   //1234567890123456
+   //1234567890123456
     "IntegralNick    ", //0
     "IntegralRoll    ",
-    "AccNick         ",
+    "AccNick         ",
     "AccRoll         ",
     "GyroGier        ",
     "HoehenWert      ", //5
 ,17 → 82,17
 {
  static unsigned int ptr = 0;
  unsigned char tmp_tx;
- if(!UebertragungAbgeschlossen)
+ if(!UebertragungAbgeschlossen)
   {
    ptr++;                    // die [0] wurde schon gesendet
-   tmp_tx = SendeBuffer[ptr];
+   tmp_tx = SendeBuffer[ptr];
    if((tmp_tx == '\r') || (ptr == MAX_SENDE_BUFF))
     {
      ptr = 0;
      UebertragungAbgeschlossen = 1;
     }
-   UDR = tmp_tx;
-  }
+   UDR = tmp_tx;
+  }
   else ptr = 0;
 }
 ,9 → 106,9
  static unsigned char UartState = 0;
  unsigned char CrcOkay = 0;
- SioTmp = UDR;
+ SioTmp = UDR;
  if(buf_ptr >= MAX_EMPFANGS_BUFF)    UartState = 0;
- if(SioTmp == '\r' && UartState == 2)
+ if(SioTmp == '\r' && UartState == 2)
   {
    UartState = 0;
    crc -= RxdBuffer[buf_ptr-2];
 ,11 → 120,11
    if((crc1 == RxdBuffer[buf_ptr-2]) && (crc2 == RxdBuffer[buf_ptr-1])) CrcOkay = 1; else { CrcOkay = 0; CntCrcError++;};
    if(!NeuerDatensatzEmpfangen && CrcOkay) // Datensatz schon verarbeitet
     {
-     NeuerDatensatzEmpfangen = 1;
-         AnzahlEmpfangsBytes = buf_ptr;
+     NeuerDatensatzEmpfangen = 1;
+         AnzahlEmpfangsBytes = buf_ptr + 1;
      RxdBuffer[buf_ptr] = '\r';
          if(RxdBuffer[2] == 'R') wdt_enable(WDTO_250MS); // Reset-Commando
-        }
+        }
   }
   else
   switch(UartState)
 ,12 → 142,12
                   break;
    case 2: //  Eingangsdaten sammeln
                   RxdBuffer[buf_ptr] = SioTmp;
-                  if(buf_ptr < MAX_EMPFANGS_BUFF) buf_ptr++;
+                  if(buf_ptr < MAX_EMPFANGS_BUFF) buf_ptr++;
                   else UartState = 0;
                   crc += SioTmp;
                   break;
-   default:
-          UartState = 0;
+   default:
+          UartState = 0;
           break;
   }
 }
 ,7 → 156,7
 // --------------------------------------------------------------------------
 void AddCRC(unsigned int wieviele)
 {
- unsigned int tmpCRC = 0,i;
+ unsigned int tmpCRC = 0,i;
  for(i = 0; i < wieviele;i++)
   {
    tmpCRC += SendeBuffer[i];
 ,36 → 172,88
 // --------------------------------------------------------------------------
-void SendOutData(unsigned char cmd,unsigned char modul, unsigned char *snd, unsigned char len)
+void SendOutData(unsigned char cmd,unsigned char modul, unsigned char BufferAnzahl, ...) //unsigned char *snd, unsigned char len)
 {
+ va_list ap;
  unsigned int pt = 0;
  unsigned char a,b,c;
  unsigned char ptr = 0;
+ unsigned char *snd = 0;
+ int len = 0;
  SendeBuffer[pt++] = '#';               // Startzeichen
  SendeBuffer[pt++] = modul;             // Adresse (a=0; b=1,...)
  SendeBuffer[pt++] = cmd;                       // Commando
+ va_start(ap, BufferAnzahl);
+ if(BufferAnzahl)
+ {
+                snd = va_arg(ap, unsigned char*);
+                len = va_arg(ap, int);
+                ptr = 0;
+                BufferAnzahl--;
+ }
  while(len)
   {
-   if(len) { a = snd[ptr++]; len--;} else a = 0;
-   if(len) { b = snd[ptr++]; len--;} else b = 0;
-   if(len) { c = snd[ptr++]; len--;} else c = 0;
+        if(len)
+        {
+           a = snd[ptr++];
+           len--;
+           if((!len) && BufferAnzahl)
+                {
+                        snd = va_arg(ap, unsigned char*);
+                        len = va_arg(ap, int);
+                        ptr = 0;
+                        BufferAnzahl--;
+                }
+        }
+        else a = 0;
+        if(len)
+        {
+                b = snd[ptr++];
+                len--;
+                if((!len) && BufferAnzahl)
+                {
+                        snd = va_arg(ap, unsigned char*);
+                        len = va_arg(ap, int);
+                        ptr = 0;
+                        BufferAnzahl--;
+                }
+        }
+        else b = 0;
+        if(len)
+        {
+                c = snd[ptr++];
+                len--;
+                if((!len) && BufferAnzahl)
+                {
+                        snd = va_arg(ap, unsigned char*);
+                        len = va_arg(ap, int);
+                        ptr = 0;
+                        BufferAnzahl--;
+                }
+        }
+        else c = 0;
    SendeBuffer[pt++] = '=' + (a >> 2);
    SendeBuffer[pt++] = '=' + (((a & 0x03) << 4) | ((b & 0xf0) >> 4));
    SendeBuffer[pt++] = '=' + (((b & 0x0f) << 2) | ((c & 0xc0) >> 6));
    SendeBuffer[pt++] = '=' + ( c & 0x3f);
   }
+ va_end(ap);
  AddCRC(pt);
 }
 // --------------------------------------------------------------------------
-void Decode64(unsigned char *ptrOut, unsigned char len, unsigned char ptrIn,unsigned char max)  // Wohin mit den Daten; Wie lang; Wo im RxdBuffer
+void Decode64(void)  // die daten werden im rx buffer dekodiert, das geht nur, weil aus 4 byte immer 3 gemacht werden.
 {
  unsigned char a,b,c,d;
- unsigned char ptr = 0;
  unsigned char x,y,z;
+ unsigned char ptrIn = 3; // start at begin of data block
+ unsigned char ptrOut = 3;
+ unsigned char len = AnzahlEmpfangsBytes - 6; // von der Gesamtbytezahl eines Frames gehen 3 Bytes des Headers  ('#',Addr, Cmd) und 3 Bytes des Footers (CRC1, CRC2, '\r') ab.
  while(len)
   {
    a = RxdBuffer[ptrIn++] - '=';
 ,16 → 260,17
    b = RxdBuffer[ptrIn++] - '=';
    c = RxdBuffer[ptrIn++] - '=';
    d = RxdBuffer[ptrIn++] - '=';
-   if(ptrIn > max - 2) break;     // nicht mehr Daten verarbeiten, als empfangen wurden
    x = (a << 2) | (b >> 4);
    y = ((b & 0x0f) << 4) | (c >> 2);
    z = ((c & 0x03) << 6) | d;
-   if(len--) ptrOut[ptr++] = x; else break;
-   if(len--) ptrOut[ptr++] = y; else break;
-   if(len--) ptrOut[ptr++] = z; else break;
+   if(len--) RxdBuffer[ptrOut++] = x; else break;
+   if(len--) RxdBuffer[ptrOut++] = y; else break;
+   if(len--) RxdBuffer[ptrOut++] = z;   else break;
   }
+        pRxData = (unsigned char*)&RxdBuffer[3]; // decodierte Daten beginnen beim 4. Byte
+        RxDataLen = ptrOut - 3;  // wie viele Bytes wurden dekodiert?
 }
 ,92 → 279,82
 {
  if(!NeuerDatensatzEmpfangen) return;
- unsigned int tmp_int_arr1[1];
-// unsigned int tmp_int_arr2[2];
-// unsigned int tmp_int_arr3[3];
- unsigned char tmp_char_arr2[2];
-// unsigned char tmp_char_arr3[3];
-// unsigned char tmp_char_arr4[4];
- //if(!MotorenEin)
+  Decode64(); // dekodiere datenblock im Empfangsbuffer
   switch(RxdBuffer[2])
   {
    case 'K':// Kompasswert
-            Decode64((unsigned char *) &tmp_int_arr1[0],sizeof(tmp_int_arr1),3,AnzahlEmpfangsBytes);
-            KompassValue = tmp_int_arr1[0];
+            memcpy((unsigned char *)&KompassValue , (unsigned char *)pRxData, sizeof(KompassValue));
             KompassRichtung = ((540 + KompassValue - KompassStartwert) % 360) - 180;
                         break;
    case 'a':// Texte der Analogwerte
-            Decode64((unsigned char *) &tmp_char_arr2[0],sizeof(tmp_char_arr2),3,AnzahlEmpfangsBytes);
-            DebugTextAnforderung = tmp_char_arr2[0];
-            PcZugriff = 255;
+            DebugTextAnforderung = pRxData[0];
+            if (DebugTextAnforderung > 31) DebugTextAnforderung = 31;
+            PcZugriff = 255;
                         break;
    case 'b':
-                        Decode64((unsigned char *) &ExternControl,sizeof(ExternControl),3,AnzahlEmpfangsBytes);
-                        RemoteTasten |= ExternControl.RemoteTasten;
+                        memcpy((unsigned char *)&ExternControl, (unsigned char *)pRxData, sizeof(ExternControl));
             ConfirmFrame = ExternControl.Frame;
-            PcZugriff = 255;
+            PcZugriff = 255;
             break;
-   case 'c':
-                        Decode64((unsigned char *) &ExternControl,sizeof(ExternControl),3,AnzahlEmpfangsBytes);
-                        RemoteTasten |= ExternControl.RemoteTasten;
-            ConfirmFrame = ExternControl.Frame;
-            DebugDataAnforderung = 1;
-            PcZugriff = 255;
+   case 'd': // Poll the debug data
+                        DebugDataIntervall = pRxData[0] * 10;
+            if (DebugDataIntervall) DebugDataAnforderung = 1;
             break;
-   case 'f': // Poll the debug data
-            DebugDataAnforderung = 1;
-            break;
-   case 'h':// x-1 Displayzeilen
-            Decode64((unsigned char *) &tmp_char_arr2[0],sizeof(tmp_char_arr2),3,AnzahlEmpfangsBytes);
-            RemoteTasten |= tmp_char_arr2[0];
-                        if(tmp_char_arr2[1] == 255) NurKanalAnforderung = 1; else NurKanalAnforderung = 0; // keine Displaydaten
+   case 'l':// x-1 Displayzeilen
+            MenuePunkt = pRxData[0];
                         DebugDisplayAnforderung = 1;
                         break;
-   case 't':// Motortest
-            Decode64((unsigned char *) &MotorTest[0],sizeof(MotorTest),3,AnzahlEmpfangsBytes);
-            PcZugriff = 255;
+   case 'm':// Motortest
+            memcpy(&MotorTest[0], (unsigned char *)pRxData, sizeof(MotorTest));
+            while(!UebertragungAbgeschlossen);
+            SendOutData('M', MeineSlaveAdresse, 0);
+            PcZugriff = 255;
                         break;
-   case 'k':// Keys von DubWise
-            Decode64((unsigned char *) &DubWiseKeys[0],sizeof(DubWiseKeys),3,AnzahlEmpfangsBytes);
-                        ConfirmFrame = DubWiseKeys[3];
-            PcZugriff = 255;
-                        break;
    case 'v': // Version-Anforderung     und Ausbaustufe
             GetVersionAnforderung = 1;
-            break;
-   case 'g'://
+            break;
+   case 'g'://
                         GetExternalControl = 1;
             break;
-   case 'q':// "Get"-Anforderung für Settings
+   case 'p': // get PPM Channels
+                        GetPPMChannelAnforderung = 1;
+                        break;
+   case 't':// "Get"-Anforderung für Settings
             // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen
-            Decode64((unsigned char *) &tmp_char_arr2[0],sizeof(tmp_char_arr2),3,AnzahlEmpfangsBytes);
+            if(pRxData[0] == 0xFF)
+                        {
+                                pRxData[0] = GetActiveParamSetNumber();
+                        }
+                        else // request active parameter set
+                        {
+                                if(pRxData[0] < 1) pRxData[0] = 1; // limit to 5
+                                else if(pRxData[0] > 5) pRxData[0] = 5; // limit to 5
+                                // load requested parameter set
+                                ReadParameterSet(pRxData[0], (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);
+                        }
             while(!UebertragungAbgeschlossen);
-            if(tmp_char_arr2[0] != 0xff)
-             {
-                          if(tmp_char_arr2[0] > 5) tmp_char_arr2[0] = 5;
-                  ReadParameterSet(tmp_char_arr2[0], (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);
-                  SendOutData('L' + tmp_char_arr2[0] -1,MeineSlaveAdresse,(unsigned char *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE);
-             }
-             else
-                  SendOutData('L' + GetActiveParamSetNumber()-1,MeineSlaveAdresse,(unsigned char *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE);
+            SendOutData('T', MeineSlaveAdresse, 2, &pRxData[0], sizeof(unsigned char), (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);
             break;
-   case 'l':
-   case 'm':
-   case 'n':
-   case 'o':
-   case 'p': // Parametersatz speichern
-            Decode64((unsigned char *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE,3,AnzahlEmpfangsBytes);
-                        WriteParameterSet(RxdBuffer[2] - 'l' + 1, (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);
-            eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACTIVE_SET], RxdBuffer[2] - 'l' + 1);  // aktiven Datensatz merken
-            Umschlag180Nick = (long) EE_Parameter.WinkelUmschlagNick * 2500L;
-            Umschlag180Roll = (long) EE_Parameter.WinkelUmschlagRoll * 2500L;
-            Piep(GetActiveParamSetNumber());
-         break;
+   case 's': // Parametersatz speichern
+                        if((1 <= pRxData[0]) && (pRxData[0] <= 5)) // check for setting to be in range
+                        {
+                                memcpy((unsigned char *) &EE_Parameter.Kanalbelegung[0], (unsigned char *)&pRxData[1], STRUCT_PARAM_LAENGE);
+                                WriteParameterSet(pRxData[0], (unsigned char *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);
+                                eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACTIVE_SET], RxdBuffer[2] - 'l' + 1);  // aktiven Datensatz merken
+                                Umschlag180Nick = (long) EE_Parameter.WinkelUmschlagNick * 2500L;
+                                Umschlag180Roll = (long) EE_Parameter.WinkelUmschlagRoll * 2500L;
+                                Piep(GetActiveParamSetNumber());
+                                while(!UebertragungAbgeschlossen);
+                SendOutData('S', MeineSlaveAdresse, 1, &pRxData[0], sizeof(unsigned char));
+                        }
+                        break;
   }
 // DebugOut.AnzahlZyklen =  Debug_Timer_Intervall;
- NeuerDatensatzEmpfangen = 0;
+        NeuerDatensatzEmpfangen = 0;
+        pRxData = 0;
+        RxDataLen = 0;
 }
 //############################################################################
 ,7 → 368,7
         loop_until_bit_is_set(USR, UDRE);
         //Ausgabe des Zeichens
         UDR = c;
         return (0);
 }
 ,80 → 389,84
         UCR=(1 << TXEN) | (1 << RXEN);
     // UART Double Speed (U2X)
-        USR   |= (1<<U2X);
+        USR   |= (1<<U2X);
         // RX-Interrupt Freigabe
-        UCSRB |= (1<<RXCIE);
+        UCSRB |= (1<<RXCIE);
         // TX-Interrupt Freigabe
-        UCSRB |= (1<<TXCIE);
+        UCSRB |= (1<<TXCIE);
-        //Teiler wird gesetzt
+        //Teiler wird gesetzt
         UBRR=(SYSCLK / (BAUD_RATE * 8L) - 1);
         //UBRR = 33;
         //öffnet einen Kanal für printf (STDOUT)
         //fdevopen (uart_putchar, 0);
         //sbi(PORTD,4);
-  Debug_Timer = SetDelay(200);
-  Kompass_Timer = SetDelay(220);
-  MeineSlaveAdresse = 1; // Flight-Ctrl
+        Debug_Timer = SetDelay(DebugDataIntervall);
+        Kompass_Timer = SetDelay(220);
+        MeineSlaveAdresse = 1; // Flight-Ctrl
+        VersionInfo.Major = VERSION_MAJOR;
+        VersionInfo.Minor = VERSION_MINOR;
+        VersionInfo.Patch = VERSION_PATCH;
+        VersionInfo.Compatible  = VERSION_SERIAL_COMPATIBLE;
+        pRxData = 0;
+        RxDataLen = 0;
 }
 //---------------------------------------------------------------------------------------------
-void DatenUebertragung(void)
+void DatenUebertragung(void)
 {
  if(!UebertragungAbgeschlossen) return;
    if(GetExternalControl && UebertragungAbgeschlossen)        // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen
-   {
-      SendOutData('G',MeineSlaveAdresse,(unsigned char *) &ExternControl,sizeof(ExternControl));
+   {
+      SendOutData('G',MeineSlaveAdresse, 1, (unsigned char *) &ExternControl, sizeof(ExternControl));
           GetExternalControl = 0;
    }
-    if((CheckDelay(Kompass_Timer)) && UebertragungAbgeschlossen)
+    if((CheckDelay(Kompass_Timer)) && UebertragungAbgeschlossen)
          {
                   WinkelOut.Winkel[0] = (int) (IntegralNick / 108);  // etwa in 0,1 Grad
                   WinkelOut.Winkel[1] = (int) (IntegralRoll / 108);  // etwa in 0,1 Grad
                   WinkelOut.UserParameter[0] = Parameter_UserParam1;
                   WinkelOut.UserParameter[1] = Parameter_UserParam2;
-          SendOutData('w',MeineSlaveAdresse,(unsigned char *) &WinkelOut,sizeof(WinkelOut));
+          SendOutData('k',MeineSlaveAdresse, 1, (unsigned char *) &WinkelOut,sizeof(WinkelOut));
           if(WinkelOut.CalcState > 4)  WinkelOut.CalcState = 6; // wird dann in SPI auf Null gesetzt
-          Kompass_Timer = SetDelay(99);
-         }
-    if((CheckDelay(Debug_Timer) || DebugDataAnforderung) && UebertragungAbgeschlossen)
+          Kompass_Timer = SetDelay(99);
+         }
+    if((( DebugDataIntervall && CheckDelay(Debug_Timer)) || DebugDataAnforderung) && UebertragungAbgeschlossen)
          {
-          SendOutData('D',MeineSlaveAdresse,(unsigned char *) &DebugOut,sizeof(DebugOut));
+          SendOutData('D',MeineSlaveAdresse, 1, (unsigned char *) &DebugOut,sizeof(DebugOut));
           DebugDataAnforderung = 0;
-          Debug_Timer = SetDelay(MIN_DEBUG_INTERVALL);
-         }
+          if(DebugDataIntervall) Debug_Timer = SetDelay(DebugDataIntervall);
+         }
     if(DebugTextAnforderung != 255) // Texte für die Analogdaten
      {
-      SendOutData('A',DebugTextAnforderung + '0',(unsigned char *) ANALOG_TEXT[DebugTextAnforderung],16);
+      SendOutData('A', MeineSlaveAdresse, 2, (unsigned char *)&DebugTextAnforderung, sizeof(DebugTextAnforderung),(unsigned char *) ANALOG_TEXT[DebugTextAnforderung], 16);
       DebugTextAnforderung = 255;
          }
-     if(ConfirmFrame && UebertragungAbgeschlossen)   // Datensatz ohne CRC bestätigen
+     if(ConfirmFrame && UebertragungAbgeschlossen)   // Datensatz bestätigen
          {
-      SendeBuffer[0] = '#';
-      SendeBuffer[1] = ConfirmFrame;
-      SendeBuffer[2] = '\r';
-      UebertragungAbgeschlossen = 0;
-      ConfirmFrame = 0;
-      UDR = SendeBuffer[0];
+                SendOutData('B', MeineSlaveAdresse, 1, (uint8_t*)&ConfirmFrame, sizeof(ConfirmFrame));
+        ConfirmFrame = 0;
      }
      if(DebugDisplayAnforderung && UebertragungAbgeschlossen)
          {
       Menu();
+      SendOutData('L',MeineSlaveAdresse, 3, &MenuePunkt, sizeof(MenuePunkt), &MaxMenue, sizeof(MaxMenue), DisplayBuff, sizeof(DisplayBuff));
           DebugDisplayAnforderung = 0;
-      if(++RemotePollDisplayLine == 4 || NurKanalAnforderung)
-      {
-       SendOutData('4',0,(unsigned char *)&PPM_in,sizeof(PPM_in));   // DisplayZeile übertragen
-       RemotePollDisplayLine = -1;
-      }
-      else  SendOutData('0' + RemotePollDisplayLine,0,(unsigned char *)&DisplayBuff[20 * RemotePollDisplayLine],20);   // DisplayZeile übertragen
-         }
-    if(GetVersionAnforderung && UebertragungAbgeschlossen)
-     {
-      SendOutData('V',MeineSlaveAdresse,(unsigned char *) &VersionInfo,sizeof(VersionInfo));
+         }
+    if(GetVersionAnforderung && UebertragungAbgeschlossen)
+     {
+      SendOutData('V',MeineSlaveAdresse, 1, (unsigned char *) &VersionInfo, sizeof(VersionInfo));
           GetVersionAnforderung = 0;
      }
+     if(GetPPMChannelAnforderung && UebertragungAbgeschlossen)
+     {
+                 SendOutData('P',MeineSlaveAdresse, 1, (unsigned char *) &PPM_in, sizeof(PPM_in));
+                 GetPPMChannelAnforderung = 0;
+         }
 }

 /trunk/uart.h
 ,11 → 3,6
 #define MAX_SENDE_BUFF     150
 #define MAX_EMPFANGS_BUFF  150
-#define DUB_KEY_UP     4
-#define DUB_KEY_DOWN   8
-#define DUB_KEY_RIGHT  32
-#define DUB_KEY_LEFT   16
-#define DUB_KEY_FIRE   64
 void BearbeiteRxDaten(void);
 ,7 → 23,6
 extern void DecodeNMEA(void);
 extern void BearbeiteRxDaten(void);
 extern unsigned char MotorTest[4];
-extern unsigned char DubWiseKeys[4];
 struct str_DebugOut
 {
  unsigned char Digital[2];
 ,7 → 35,7
 {
    signed int  Winkel[2];
  unsigned char UserParameter[2];
- unsigned char CalcState;
+ unsigned char CalcState;
  unsigned char Orientation;
 };
 extern struct str_WinkelOut  WinkelOut;
 ,27 → 52,25
  unsigned char free;
  unsigned char Frame;
  unsigned char Config;
-};
+};
 extern struct str_ExternControl   ExternControl;
 struct str_VersionInfo
 {
-  unsigned char Hauptversion;
-  unsigned char Nebenversion;
-  unsigned char PCKompatibel;
-  unsigned char Hardware;
+  unsigned char Major;
+  unsigned char Minor;
   unsigned char Patch;
-  unsigned char NaviKompatibel;
-  unsigned char Reserved[4];
-};
+  unsigned char Compatible;
+  unsigned char Reserved[6];
+};
 extern struct str_VersionInfo VersionInfo;
 //Die Baud_Rate der Seriellen Schnittstelle ist 9600 Baud
-//#define BAUD_RATE 9600                //Baud Rate für die Serielle Schnittstelle
-//#define BAUD_RATE 14400               //Baud Rate für die Serielle Schnittstelle
-//#define BAUD_RATE 28800               //Baud Rate für die Serielle Schnittstelle
-//#define BAUD_RATE 38400               //Baud Rate für die Serielle Schnittstelle
-#define BAUD_RATE 57600         //Baud Rate für die Serielle Schnittstelle
+//#define BAUD_RATE 9600                //Baud Rate für die Serielle Schnittstelle
+//#define BAUD_RATE 14400               //Baud Rate für die Serielle Schnittstelle
+//#define BAUD_RATE 28800               //Baud Rate für die Serielle Schnittstelle
+//#define BAUD_RATE 38400               //Baud Rate für die Serielle Schnittstelle
+#define BAUD_RATE 57600         //Baud Rate für die Serielle Schnittstelle
 //Anpassen der seriellen Schnittstellen Register wenn ein ATMega128 benutzt wird
 #if defined (__AVR_ATmega128__)

Subversion Repositories FlightCtrl

Compare Revisions

Ignore whitespace Rev 1050 → Rev 1051