WebSVN - FlightCtrl - Path Comparison - /tags/V0.84a Rev 1880 and /branches/V0.84a_ACC-HH_HR

Ignore whitespace Rev 1880 → Rev 1888

 /branches/V0.84a_ACC-HH_HR_MartinR/analog.c
 ,7 → 24,7
 volatile unsigned int ZaehlMessungen = 0;
 unsigned char AnalogOffsetNick = 115,AnalogOffsetRoll = 115,AnalogOffsetGier = 115;
 volatile unsigned char AdReady = 1;
-float NeutralAccZ_float;
+//float NeutralAccZ_float; // MartinR : wozu ?
 //#######################################################################################
 //
 void ADC_Init(void)
 ,7 → 142,7
 //#######################################################################################
 {
     static unsigned char kanal=0,state = 0;
-        static signed char subcount = 0;
+        //static signed char subcount = 0; // MartinR: wird nicht mehr benötigt, da deaktiviert
     static signed int gier1, roll1, nick1, nick_filter, roll_filter;
         static signed int accy, accx;
         static long tmpLuftdruck = 0;
 ,6 → 189,9
             break;
        case 8:
             AdWertAccHoch =  (signed int) ADC - NeutralAccZ;
+                        /*  // MartinR: deaktivieren Anfang
             if(AdWertAccHoch > 1)
              {
               if(NeutralAccZ < 750)
 ,6 → 210,9
                  if(subcount < -100) { NeutralAccZ--; subcount += 100;}
                 }
              }
+                         */ // MartinR: deaktivieren Ende
             messanzahl_AccHoch = 1;
             Aktuell_az = ADC;
             Mess_Integral_Hoch += AdWertAccHoch;      // Integrieren
 ,7 → 250,9
             if(PlatinenVersion == 10) nick1 *= 2; else nick1 *= 4;
             AdWertNick = nick1 / 8;
             nick_filter = (nick_filter + nick1) / 2;
-            HiResNick = nick_filter - AdNeutralNick;
+                        //HiResNick = nick_filter - AdNeutralNick; // MartinR: so war es
+                        HiResNick = (nick_filter - AdNeutralNick + 4 ) / 8 ; // MartinR: + 4um Rundungsfehler zu verbessern
+                        // MartinR: /8 von fc.c nach hier verschoben um Code zu sparen
             AdWertNickFilter = (AdWertNickFilter + HiResNick) / 2;
             kanal = AD_ROLL;
             break;
 ,7 → 261,9
             if(PlatinenVersion == 10) roll1 *= 2; else roll1 *= 4;
             AdWertRoll = roll1 / 8;
             roll_filter = (roll_filter + roll1) / 2;
-            HiResRoll = roll_filter - AdNeutralRoll;
+            //HiResRoll = roll_filter - AdNeutralRoll; // MartinR: so war es
+                        HiResRoll = (roll_filter - AdNeutralRoll + 4 ) / 8; // MartinR: + 4um Rundungsfehler zu verbessern
+                        // MartinR: /8 von fc.c nach hier verschoben um Code zu sparen
             AdWertRollFilter = (AdWertRollFilter + HiResRoll) / 2;
                 kanal = AD_DRUCK;
             break;
 ,7 → 273,9
             ZaehlMessungen++;
             // "break" fehlt hier absichtlich
         case 9:
-                MessLuftdruck = ADC;
+                //MessLuftdruck = ADC; // MartinR: so war es
+                        MessLuftdruck = ADC + ((Parameter_UserParam4 * AdWertAccHoch) / 256) ; // MartinR:
+                        // mit Korrektur der Beschleunigungsempfindlichkeit des Luftdrucksensors
             tmpLuftdruck += MessLuftdruck;
             if(++messanzahl_Druck >= 18)
             {

 /branches/V0.84a_ACC-HH_HR_MartinR/fc.c
 ,7 → 73,8
 long Integral_Gier = 0;
 long Mess_IntegralNick = 0,Mess_IntegralNick2 = 0;
 long Mess_IntegralRoll = 0,Mess_IntegralRoll2 = 0;
-long Mess_Integral_Gier = 0,Mess_Integral_Gier2 = 0;
+//long Mess_Integral_Gier = 0,Mess_Integral_Gier2 = 0; //MartinR so war es
+long Mess_Integral_Gier = 0; //MartinR: Mess_Integral_Gier2 unbenutzt
 long MittelIntegralNick,MittelIntegralRoll,MittelIntegralNick2,MittelIntegralRoll2;
 long SummeNick=0,SummeRoll=0;
 volatile long Mess_Integral_Hoch = 0;
 ,6 → 109,8
 int LageKorrekturRoll = 0,LageKorrekturNick = 0, HoverGas = 0;
 //float Ki =  FAKTOR_I;
 int Ki = 10300 / 33;
+int KiHH = 10300 / 33; // MartinR : für Ki bei HH über Schalter
 unsigned char Looping_Nick = 0,Looping_Roll = 0;
 unsigned char Looping_Links = 0, Looping_Rechts = 0, Looping_Unten = 0, Looping_Oben = 0;
 ,7 → 162,9
 const signed char sintab[31] = { 0, 2, 4, 6, 7, 8, 8, 8, 7, 6, 4, 2, 0, -2, -4, -6, -7, -8, -8, -8, -7, -6, -4, -2, 0, 2, 4, 6, 7, 8, 8}; // 15° steps
 signed int ExternStickNick = 0,ExternStickRoll = 0,ExternStickGier = 0, ExternHoehenValue = -20;
-int MaxStickNick = 0,MaxStickRoll = 0;
+//int MaxStickNick = 0,MaxStickRoll = 0; MartinR: so war es
+int MaxStickNick = 0,MaxStickRoll = 0,stick_nick_neutral = 0,stick_roll_neutral = 0;  // MartinR: stick_.._neutral hinzugefügt
 unsigned int  modell_fliegt = 0;
 volatile unsigned char FC_StatusFlags = 0, FC_StatusFlags2 = 0;
 long GIER_GRAD_FAKTOR = 1291;
 ,6 → 197,10
     DebugOut.Analog[13] = Motor[1].SetPoint;
     DebugOut.Analog[14] = Motor[2].SetPoint;
     DebugOut.Analog[15] = Motor[3].SetPoint;
+        //DebugOut.Analog[16] = DiffNick;  // MartinR: test
+        //DebugOut.Analog[17] = DiffRoll;  // MartinR: test
+        //DebugOut.Analog[18] = MesswertNick;  // MartinR: test
+        //DebugOut.Analog[19] = MesswertRoll;  // MartinR: test
     DebugOut.Analog[20] = ServoNickValue;
     DebugOut.Analog[22] = Capacity.ActualCurrent;
     DebugOut.Analog[23] = Capacity.UsedCapacity;
 ,8 → 214,6
     if(VersionInfo.HardwareError[0] || VersionInfo.HardwareError[1]) DebugOut.Status[1] |= 1; else DebugOut.Status[1] &= 0xfe;
 }
 void Piep(unsigned char Anzahl, unsigned int dauer)
 {
  if(MotorenEin) return; //auf keinen Fall im Flug!
 ,9 → 383,12
     static signed long tmpl,tmpl2,tmpl3,tmpl4;
         static signed int oldNick, oldRoll, d2Roll, d2Nick;
         signed long winkel_nick, winkel_roll;
+    //unsigned char i; // MartinR: wird bei V0.81d nicht mehr benötigt, da Poti-Auswertung verschoben
         MesswertGier = (signed int) AdNeutralGier - AdWertGier;
-    MesswertNick = (signed int) AdWertNickFilter / 8;
-    MesswertRoll = (signed int) AdWertRollFilter / 8;
+    //MesswertNick = (signed int) AdWertNickFilter / 8; // MartinR: so war es
+    //MesswertRoll = (signed int) AdWertRollFilter / 8; // MartinR: so war es
+        MesswertNick = (signed int) AdWertNickFilter  ; // MartinR die Division /8 erfolgt bereits in der analog.c
+    MesswertRoll = (signed int) AdWertRollFilter ; // MartinR die Division /8 erfolgt bereits in der analog.c
     RohMesswertNick = MesswertNick;
     RohMesswertRoll = MesswertRoll;
 ,7 → 420,8
    Mess_Integral_Gier += MesswertGier;
    ErsatzKompass += MesswertGier;
 // Kopplungsanteil  +++++++++++++++++++++++++++++++++++++
-      if(!Looping_Nick && !Looping_Roll && (EE_Parameter.GlobalConfig & CFG_ACHSENKOPPLUNG_AKTIV))
+      //if(!Looping_Nick && !Looping_Roll && (EE_Parameter.GlobalConfig & CFG_ACHSENKOPPLUNG_AKTIV)) // MartinR: so war es
+          if((EE_Parameter.GlobalConfig & CFG_ACHSENKOPPLUNG_AKTIV)) // MartinR geändert
          {
             tmpl3 = (MesswertRoll * winkel_nick) / 2048L;
             tmpl3 *= Parameter_AchsKopplung2; //65
 ,11 → 483,18
     IntegralNick2 = Mess_IntegralNick2;
     IntegralRoll2 = Mess_IntegralRoll2;
-#define D_LIMIT 128
+//#define D_LIMIT 128 // MartinR: so war es
+#define D_LIMIT 16
+// MartinR: Änderung war notwendig, da die Division /8 bereits in der analog.c erfolgt
-   MesswertNick = HiResNick / 8;
-   MesswertRoll = HiResRoll / 8;
+   //MesswertNick = HiResNick / 8; // MartinR : so war es
+  // MesswertRoll = HiResRoll / 8; // MartinR : so war es
+   MesswertNick = HiResNick ; // MartinR die Division /8 erfolgt bereits in der analog.c
+   MesswertRoll = HiResRoll ; // MartinR die Division /8 erfolgt bereits in der analog.c
+        // MartinR : so war es Anfang
+        /*
    if(AdWertNick < 15)   MesswertNick = -1000;  if(AdWertNick <  7)   MesswertNick = -2000;
    if(PlatinenVersion == 10)  { if(AdWertNick > 1010) MesswertNick = +1000;  if(AdWertNick > 1017) MesswertNick = +2000; }
    else  {  if(AdWertNick > 2000) MesswertNick = +1000;  if(AdWertNick > 2015) MesswertNick = +2000; }
 ,23 → 501,55
    if(AdWertRoll < 15)   MesswertRoll = -1000;  if(AdWertRoll <  7)   MesswertRoll = -2000;
    if(PlatinenVersion == 10) { if(AdWertRoll > 1010) MesswertRoll = +1000;  if(AdWertRoll > 1017) MesswertRoll = +2000; }
    else { if(AdWertRoll > 2000) MesswertRoll = +1000;  if(AdWertRoll > 2015) MesswertRoll = +2000;  }
+   // MartinR : FC 1.0: Sprung von 500 auf 2000 !! FC-ME: Sprung von 1000 auf 2000
+        */
+        // MartinR : so war es Ende
+         // MartinR : Neu Anfang
+        if(PlatinenVersion == 10)
+        {
+        if(AdWertNick > 1010) MesswertNick = +600;
+        if(AdWertNick > 1017) MesswertNick = +800;
+        if(AdWertNick < 15)   MesswertNick = -600;
+        if(AdWertNick <  7)   MesswertNick = -800;
+        if(AdWertRoll > 1010) MesswertRoll = +600;
+        if(AdWertRoll > 1017) MesswertRoll = +800;
+        if(AdWertRoll < 15)   MesswertRoll = -600;
+        if(AdWertRoll <  7)   MesswertRoll = -800;
+        }
+        else
+        {
+        if(AdWertNick > 2000) MesswertNick = +1200;
+        if(AdWertNick > 2015) MesswertNick = +1600;
+        if(AdWertNick < 15)   MesswertNick = -1200;
+        if(AdWertNick <  7)   MesswertNick = -1600;
+        if(AdWertRoll > 2000) MesswertRoll = +1200;
+        if(AdWertRoll > 2015) MesswertRoll = +1600;
+        if(AdWertRoll < 15)   MesswertRoll = -1200;
+        if(AdWertRoll <  7)   MesswertRoll = -1600;
+        }
+ // MartinR : Neu Ende
   if(Parameter_Gyro_D)
+  // MartinR: hier sind Änderungen erforderlich, da u.a. MesswertNick = HiResNick / 8 von der fc.c in die analog.c verschoben wurde
+  // Hintergrund: Code einsparen
   {
    d2Nick = HiResNick - oldNick;
    oldNick = (oldNick + HiResNick)/2;
    if(d2Nick > D_LIMIT) d2Nick = D_LIMIT;
    else if(d2Nick < -D_LIMIT) d2Nick = -D_LIMIT;
    d2Roll = HiResRoll - oldRoll;
    oldRoll = (oldRoll + HiResRoll)/2;
    if(d2Roll > D_LIMIT) d2Roll = D_LIMIT;
    else if(d2Roll < -D_LIMIT) d2Roll = -D_LIMIT;
-   MesswertNick += (d2Nick * (signed int) Parameter_Gyro_D) / 16;
-   MesswertRoll += (d2Roll * (signed int) Parameter_Gyro_D) / 16;
-   HiResNick += (d2Nick * (signed int) Parameter_Gyro_D);
-   HiResRoll += (d2Roll * (signed int) Parameter_Gyro_D);
+   //MesswertNick += (d2Nick * (signed int) Parameter_Gyro_D) / 16; // MartinR : so war es
+   MesswertNick += (d2Nick * (signed int) Parameter_Gyro_D) / 2; // MartinR : geändert
+   //MesswertRoll += (d2Roll * (signed int) Parameter_Gyro_D) / 16; // MartinR : so war es
+   MesswertRoll += (d2Roll * (signed int) Parameter_Gyro_D) / 2; // MartinR : geändert
+   HiResNick += (d2Nick * (signed int) Parameter_Gyro_D * 8); // martinR: *8 hinzugefügt
+   HiResRoll += (d2Roll * (signed int) Parameter_Gyro_D * 8); // martinR: *8 hinzugefügt
   }
  if(RohMesswertRoll > 0) TrimRoll  += ((long) abs(KopplungsteilNickRoll) * Parameter_CouplingYawCorrection) / 64L;
 ,7 → 557,8
  if(RohMesswertNick > 0) TrimNick += ((long) abs(KopplungsteilRollNick) * Parameter_CouplingYawCorrection) / 64L;
  else                    TrimNick -= ((long) abs(KopplungsteilRollNick) * Parameter_CouplingYawCorrection) / 64L;
-  if(EE_Parameter.GlobalConfig & CFG_DREHRATEN_BEGRENZER && !Looping_Nick && !Looping_Roll)
+  //if(EE_Parameter.GlobalConfig & CFG_DREHRATEN_BEGRENZER && !Looping_Nick && !Looping_Roll) // MartinR: so war es
+  if(EE_Parameter.GlobalConfig & CFG_DREHRATEN_BEGRENZER) // MartinR: geändert
   {
     if(RohMesswertNick > 256)       MesswertNick += 1 * (RohMesswertNick - 256);
     else if(RohMesswertNick < -256) MesswertNick += 1 * (RohMesswertNick + 256);
 ,7 → 632,7
  CHK_POTI(Parameter_Servo4,EE_Parameter.Servo4);
  CHK_POTI(Parameter_Servo5,EE_Parameter.Servo5);
  CHK_POTI(Parameter_MaxHoehe,EE_Parameter.MaxHoehe);
- CHK_POTI(Parameter_MaxHoehe,EE_Parameter.MaxHoehe);
+ //CHK_POTI(Parameter_MaxHoehe,EE_Parameter.MaxHoehe); // MartinR: Zeile war doppelt
  CHK_POTI(Parameter_Hoehe_ACC_Wirkung,EE_Parameter.Hoehe_ACC_Wirkung);
  CHK_POTI(Parameter_Hoehe_GPS_Z,EE_Parameter.Hoehe_GPS_Z);
  CHK_POTI(Parameter_KompassWirkung,EE_Parameter.KompassWirkung);
 ,6 → 659,14
  CHK_POTI(Parameter_DynamicStability,EE_Parameter.DynamicStability);
  CHK_POTI(Parameter_ExternalControl,EE_Parameter.ExternalControl);
  Ki = 10300 / (Parameter_I_Faktor + 1);
+ if(Parameter_UserParam1 > 50) KiHH = 10300 / (Parameter_UserParam2 + 1); else  KiHH = Ki; // MartinR : für HH über Schalter
+ Parameter_NaviGpsModeControl = EE_Parameter.NaviGpsModeControl; //MartinR: Standard: EE_Parameter.NaviGpsModeControl wird übertragen
+ if(!IntegralFaktor) Parameter_NaviGpsModeControl= 0; // MartinR: wenn HH dann GPS auf free- Mode
+  // 0 = free; 100 = AID; 200 = coming home //neu
  MAX_GAS = EE_Parameter.Gas_Max;
  MIN_GAS = EE_Parameter.Gas_Min;
 ,7 → 674,7
  if(tmp > 50)
    {
 #ifdef SWITCH_LEARNS_CAREFREE
-    if(!CareFree)  ControlHeading = (((int) EE_Parameter.OrientationAngle * 15 + KompassValue) % 360) / 2;
+        if(!CareFree)  ControlHeading = (((int) EE_Parameter.OrientationAngle * 15 + KompassValue) % 360) / 2;
 #endif
         CareFree = 1;
     if(tmp >= 248 && Poti[255 - tmp] < 50) CareFree = 0;
 ,6 → 711,9
 {
          int pd_ergebnis_nick,pd_ergebnis_roll,tmp_int, tmp_int2;
          int GierMischanteil,GasMischanteil;
+         static long SummeNickHH=0,SummeRollHH=0; // MartinR: hinzugefügt
      static long sollGier = 0,tmp_long,tmp_long2;
      static long IntegralFehlerNick = 0;
      static long IntegralFehlerRoll = 0;
 ,6 → 820,8
                                                    ServoActive = 1;
                                                    DDRD  |=0x80; // enable J7 -> Servo signal
                            Piep(GetActiveParamSet(),120);
+                                                        PPM_in[13] = Parameter_UserParam5 -110; // MartinR: Initialisierungswerte für die seriellen Potis für Jeti+
+                                                        PPM_in[14] = Parameter_UserParam6 -110; // MartinR: Initialisierungswerte für die seriellen Potis für Jeti+
                          }
                         }
                     }
 ,7 → 864,7
                                                                         MotorenEin = 1;
                                                                         sollGier = 0;
                                                                         Mess_Integral_Gier = 0;
-                                                                        Mess_Integral_Gier2 = 0;
+                                                                        //Mess_Integral_Gier2 = 0; //MartinR: Mess_Integral_Gier2 unbenutzt
                                                                         Mess_IntegralNick = EE_Parameter.GyroAccFaktor * (long)Mittelwert_AccNick;
                                                                         Mess_IntegralRoll = EE_Parameter.GyroAccFaktor * (long)Mittelwert_AccRoll;
                                                                         Mess_IntegralNick2 = IntegralNick;
 ,10 → 909,50
   {
         static int stick_nick,stick_roll;
     ParameterZuordnung();
+                // MartinR: original:
+        /*
     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;
     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;
+                        */
+// MartinR: geändert Anfang
+        if(Parameter_UserParam1 > 50)   // MartinR: zweiter Stick_P Wert nur, wenn HH über Schalter aktiv ist
+                {
+                stick_nick = (stick_nick * 3 + PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] * Parameter_UserParam3 - stick_nick_neutral) / 4;
+                stick_roll = (stick_roll * 3 + PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] * Parameter_UserParam3 - stick_roll_neutral) / 4 ;
+                //stick_nick = (PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] * Parameter_UserParam3 - stick_nick_neutral);
+                //stick_roll = (PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] * Parameter_UserParam3 - stick_roll_neutral);
+                }
+         else
+                {
+                stick_nick = (stick_nick * 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_nick_neutral = stick_nick; //  beim Umschalten auf HH wird derletzte Stickwert als Neutralposition verwendet, MartinR
+                stick_roll_neutral = stick_roll; //  beim Umschalten auf HH wird derletzte Stickwert als Neutralposition verwendet, MartinR
+                }
+         if(IntegralFaktor)
+                {
+                //stick_nick_neutral = stick_nick; //  beim Umschalten auf HH wird derletzte Stickwert als Neutralposition verwendet, MartinR
+                //stick_roll_neutral = stick_roll; //  beim Umschalten auf HH wird derletzte Stickwert als Neutralposition verwendet, MartinR
+                stick_nick += PPM_diff[EE_Parameter.Kanalbelegung[K_NICK]] * EE_Parameter.Stick_D;
+                stick_roll += PPM_diff[EE_Parameter.Kanalbelegung[K_ROLL]] * EE_Parameter.Stick_D;
+                //StickNick = stick_nick - (GPS_Nick + GPS_Nick2); // MartinR: GPS nur im ACC-Mode wirksam
+                //StickRoll = stick_roll - (GPS_Roll + GPS_Roll2); // MartinR: GPS nur im ACC-Mode wirksam
+                }
+        /*else          // wenn HH , MartinR
+                {
+                //stick_nick += PPM_diff[EE_Parameter.Kanalbelegung[K_NICK]] * EE_Parameter.Stick_D; // MartinR: eventuell vor if verschieben
+                //stick_roll += PPM_diff[EE_Parameter.Kanalbelegung[K_ROLL]] * EE_Parameter.Stick_D; // MartinR: eventuell vor if verschieben
+                //StickNick = stick_nick; // MartinR: GPS nur im ACC-Mode wirksam
+                //StickRoll = stick_roll; // MartinR: GPS nur im ACC-Mode wirksam
+                }
+        */
+// MartinR: geändert Ende
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // CareFree und freie Wahl der vorderen Richtung
 ,13 → 982,14
         StickGas  = PPM_in[EE_Parameter.Kanalbelegung[K_GAS]] + 120;
     GyroFaktor     = (Parameter_Gyro_P + 10.0);
-    IntegralFaktor = Parameter_Gyro_I;
+    // IntegralFaktor = Parameter_Gyro_I; // MartinR: verschoben um Code zu sparen
     GyroFaktorGier     = (Parameter_Gyro_Gier_P + 10.0);
     IntegralFaktorGier = Parameter_Gyro_Gier_I;
 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 //+ Analoge Steuerung per Seriell
 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// MartinR: ToDo: eventuell die Kombination HH und Steuerung per Seriell nicht zulassen??
+/* // MartinR: deaktiviert um Code zu sparen
    if(ExternControl.Config & 0x01 && Parameter_ExternalControl > 128)
     {
          StickNick += (int) ExternControl.Nick * (int) EE_Parameter.Stick_P;
 ,7 → 1000,7
     }
     if(StickGas < 0) StickGas = 0;
-    if(EE_Parameter.GlobalConfig & CFG_HEADING_HOLD) IntegralFaktor =  0;
+        //if(EE_Parameter.GlobalConfig & CFG_HEADING_HOLD) IntegralFaktor =  0; // MartinR: so war es, verschoben um code zu sparen
     if(abs(StickNick/STICK_GAIN) > MaxStickNick)
      {
 ,10 → 1015,11
      }
      else MaxStickRoll--;
     if(FC_StatusFlags & FC_STATUS_EMERGENCY_LANDING)  {MaxStickNick = 0; MaxStickRoll = 0;}
+*/
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // Looping?
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+/* // MartinR: deaktiviert um Code zu sparen
   if((PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] > EE_Parameter.LoopThreshold) && EE_Parameter.BitConfig & CFG_LOOP_LINKS)  Looping_Links = 1;
   else
    {
 ,15 → 1055,15
    if(Looping_Links || Looping_Rechts)   Looping_Roll = 1; else Looping_Roll = 0;
    if(Looping_Oben  || Looping_Unten) {  Looping_Nick = 1; Looping_Roll = 0; Looping_Links = 0; Looping_Rechts = 0;} else Looping_Nick = 0;
+   */
   } // Ende neue Funken-Werte
+/* // MartinR Deaktiviert um Code zu sparen
   if(Looping_Roll || Looping_Nick)
    {
     if(GasMischanteil > EE_Parameter.LoopGasLimit) GasMischanteil = EE_Parameter.LoopGasLimit;
         TrichterFlug = 1;
    }
+*/
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // Bei Empfangsausfall im Flug
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 ,7 → 1091,9
  MittelIntegralNick2 += IntegralNick2;
  MittelIntegralRoll2 += IntegralRoll2;
- if(Looping_Nick || Looping_Roll)
+// if(Looping_Nick || Looping_Roll)  // MartinR: so war es
+   //if(Looping_Nick || Looping_Roll || (!IntegralFaktor & (Parameter_UserParam1 < 50) & !(EE_Parameter.GlobalConfig & CFG_HEADING_HOLD))) // MartinR: erweitert
+   if((!IntegralFaktor & (Parameter_UserParam1 < 50) & !(EE_Parameter.GlobalConfig & CFG_HEADING_HOLD))) // MartinR: Looping deaktiviert
   {
     IntegralAccNick = 0;
     IntegralAccRoll = 0;
 ,9 → 1107,30
     LageKorrekturNick = 0;
     LageKorrekturRoll = 0;
   }
+  if((!IntegralFaktor & (Parameter_UserParam1 < 50) & !(EE_Parameter.GlobalConfig & CFG_HEADING_HOLD))    ) // MartinR:
+          // nur im Moment des Umschaltens von HH auf ACC erfolgt ein Reset der Integrale, nicht aber bei normalem HH
+          // um einen im HH-Mode eventuell schwindelig geflogenen ACC_Mode zu resetten!
+          // bis zur Umschaltung werden die Integrale für den Kameraausgleich verwendet
+        {
+        IntegralNick = 0; // MartinR: im HH-Modus alle unbenutzten Integratoren = 0
+    IntegralRoll = 0; // MartinR: im HH-Modus alle unbenutzten Integratoren = 0
+    Mess_IntegralNick = 0; // MartinR: im HH-Modus alle unbenutzten Integratoren = 0
+    Mess_IntegralRoll = 0; // MartinR: im HH-Modus alle unbenutzten Integratoren = 0
+    //Mess_Integral_Gier = 0;   // MartinR: im HH-Modus alle unbenutzten Integratoren = 0
+        //Integral_Gier = 0; // MartinR: im HH-Modus alle unbenutzten Integratoren = 0
+    //Mess_Integral_Gier2 = 0; // MartinR: im HH-Modus alle unbenutzten Integratoren = 0
+        }
+        if((EE_Parameter.GlobalConfig & CFG_HEADING_HOLD) || (Parameter_UserParam1 > 50)) IntegralFaktor = 0; // MartinR geändert und verschoben
+          else IntegralFaktor = Parameter_Gyro_I; // MartinR: verschoben um Code zu sparen
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-  if(!Looping_Nick && !Looping_Roll && (Aktuell_az > 512 || MotorenEin))
+    //if(!Looping_Nick && !Looping_Roll && (Aktuell_az > 512 || MotorenEin)) // MartinR: so war es, wegen Kameraausgleich wieder aktiviert
+        if((Aktuell_az > 512 || MotorenEin)) // MartinR: Looping deaktiviert
+  //if(!Looping_Nick && !Looping_Roll && (Aktuell_az > 512 || MotorenEin) && IntegralFaktor) // MartinR: "&& IntegralFaktor" hinzugefügt
   {
    long tmp_long, tmp_long2;
    if(FromNaviCtrl_Value.Kalman_K > 0 /*&& !TrichterFlug*/)
 ,7 → 1188,10
   static int cnt = 0;
   static char last_n_p,last_n_n,last_r_p,last_r_n;
   static long MittelIntegralNick_Alt,MittelIntegralRoll_Alt;
-  if(!Looping_Nick && !Looping_Roll && !TrichterFlug && EE_Parameter.Driftkomp)
+  //if(!Looping_Nick && !Looping_Roll && !TrichterFlug && EE_Parameter.Driftkomp) // MartinR: so war es
+  //if(!Looping_Nick && !Looping_Roll && !TrichterFlug && EE_Parameter.Driftkomp && IntegralFaktor) // MartinR: "&& IntegralFaktor" hinzugefügt
+  if(!TrichterFlug && EE_Parameter.Driftkomp && IntegralFaktor) // MartinR: "&& IntegralFaktor" hinzugefügt
   {
     MittelIntegralNick  /= ABGLEICH_ANZAHL;
     MittelIntegralRoll  /= ABGLEICH_ANZAHL;
 ,7 → 1344,7
 //      KompassSignalSchlecht = 1000;
       if(!(EE_Parameter.GlobalConfig & CFG_KOMPASS_FIX))
        {
-         NeueKompassRichtungMerken = 50; // eine Sekunde zum Einloggen
+                 NeueKompassRichtungMerken = 50; // eine Sekunde zum Einloggen
         };
      }
     tmp_int  = (long) EE_Parameter.Gier_P * ((long)StickGier * abs(StickGier)) / 512L; // expo  y = ax + bx²
 ,7 → 1398,7
            v = r * (Parameter_KompassWirkung/2);  // nach Kompass ausrichten
                    CompassGierSetpoint = v / 16;
        }
-      else CompassGierSetpoint = 0;
+      else CompassGierSetpoint = 0;
       } // CalculateCompassTimer
      }
          else CompassGierSetpoint = 0;
 ,15 → 1407,33
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
   if(TrichterFlug)  { SummeRoll = 0; SummeNick = 0;};
-  if(!Looping_Nick) IntegralNickMalFaktor = (IntegralNick * IntegralFaktor) /  (44000 / STICK_GAIN); else IntegralNickMalFaktor = 0;
-  if(!Looping_Roll) IntegralRollMalFaktor = (IntegralRoll * IntegralFaktor) /  (44000 / STICK_GAIN); else IntegralRollMalFaktor = 0;
+  //if(!Looping_Nick) IntegralNickMalFaktor = (IntegralNick * IntegralFaktor) /  (44000 / STICK_GAIN); else IntegralNickMalFaktor = 0; //MartinR: so war es
+  //if(!Looping_Roll) IntegralRollMalFaktor = (IntegralRoll * IntegralFaktor) /  (44000 / STICK_GAIN); else IntegralRollMalFaktor = 0; //MartinR: so war es
+  IntegralNickMalFaktor = (IntegralNick * IntegralFaktor) /  (44000 / STICK_GAIN);//MartinR: Looping deaktiviert
+  IntegralRollMalFaktor = (IntegralRoll * IntegralFaktor) /  (44000 / STICK_GAIN); //MartinR: Looping deaktiviert
 #define TRIM_MAX 200
  if(TrimNick > TRIM_MAX) TrimNick = TRIM_MAX; else  if(TrimNick <-TRIM_MAX) TrimNick =-TRIM_MAX;
  if(TrimRoll > TRIM_MAX) TrimRoll = TRIM_MAX; else  if(TrimRoll <-TRIM_MAX) TrimRoll =-TRIM_MAX;
+        //MesswertNick = IntegralNickMalFaktor + (long)((long)MesswertNick * GyroFaktor + (long)TrimNick * 128L) / (256L / STICK_GAIN);// MartinR so war es
+    //MesswertRoll = IntegralRollMalFaktor + (long)((long)MesswertRoll * GyroFaktor + (long)TrimRoll * 128L) / (256L / STICK_GAIN);// MartinR so war es
+        if(!IntegralFaktor) // MartinR : HH-Mode hinzugefügt
+        {
+        MesswertNick = (long) ((long)MesswertNick * GyroFaktor) / (256L / STICK_GAIN)  ; // MartinR : hinzugefügt
+        MesswertRoll = (long) ((long)MesswertRoll * GyroFaktor) / (256L / STICK_GAIN) ;  // MartinR : hinzugefügt
+        //MesswertGier = (long)(MesswertGier * 2 * (long)GyroFaktorGier) / (256L / STICK_GAIN);
+        //Mess_Integral_Gier = 0;       // MartinR: im HH-Modus alle unbenutzten Integratoren = 0       //neu: nur Kompass wird bei HH deaktiviert
+        //Integral_Gier = 0; // MartinR: im HH-Modus alle unbenutzten Integratoren = 0
+        }
+        else // MartinR: ACC-Mode  so war es
+        {
     MesswertNick = IntegralNickMalFaktor + (long)((long)MesswertNick * GyroFaktor + (long)TrimNick * 128L) / (256L / STICK_GAIN);
     MesswertRoll = IntegralRollMalFaktor + (long)((long)MesswertRoll * GyroFaktor + (long)TrimRoll * 128L) / (256L / STICK_GAIN);
+        //MesswertGier = (long)(MesswertGier * 2 * (long)GyroFaktorGier) / (256L / STICK_GAIN) + (long)(Integral_Gier * IntegralFaktorGier) / (2 * (44000 / STICK_GAIN));
+        }
     MesswertGier = (long)(MesswertGier * 2 * (long)GyroFaktorGier) / (256L / STICK_GAIN) + (long)(Integral_Gier * IntegralFaktorGier) / (2 * (44000 / STICK_GAIN));
     // Maximalwerte abfangen
 ,7 → 1453,8
   if(UBat > BattLowVoltageWarning) GasMischanteil = ((unsigned int)GasMischanteil * BattLowVoltageWarning) / UBat; // Gas auf das aktuelle Spannungvieveau beziehen
   GasMischanteil *= STICK_GAIN;
         // if height control is activated
- if((EE_Parameter.GlobalConfig & CFG_HOEHENREGELUNG) && !(Looping_Roll || Looping_Nick))  // Höhenregelung
+ //if((EE_Parameter.GlobalConfig & CFG_HOEHENREGELUNG) && !(Looping_Roll || Looping_Nick))  // Höhenregelung  //MartinR: so war es
+ if((EE_Parameter.GlobalConfig & CFG_HOEHENREGELUNG))  // Höhenregelung  // MartinR Looping deaktiviert
         {
                 #define HOVER_GAS_AVERAGE 16384L                // 16384 * 2ms = 32s averaging
                 #define HC_GAS_AVERAGE 4                        // 4 * 2ms= 8ms averaging
 ,7 → 1527,8
                 // if height control is activated by an rc channel
         if(EE_Parameter.GlobalConfig & CFG_HOEHEN_SCHALTER)  // Regler wird über Schalter gesteuert
                 {       // check if parameter is less than activation threshold
-                        if(Parameter_MaxHoehe < 50) // for 3 or 2-state switch height control is disabled in lowest position
+                        // if(Parameter_MaxHoehe < 50) // for 3 or 2-state switch height control is disabled in lowest position  // MartinR :so war es
+                        if(Parameter_MaxHoehe < 50  || (Parameter_UserParam1 > 140) )   // MartinR: Schalter aus oder HH ohne Höhenregler über UsererParam1 an
                         {   //height control not active
                                 if(!delay--)
                                 {
 ,7 → 1546,17
                 else // no switchable height control
                 {
                         SollHoehe = ((int16_t) ExternHoehenValue + (int16_t) Parameter_MaxHoehe) * (int)EE_Parameter.Hoehe_Verstaerkung;
-                        HoehenReglerAktiv = 1;
+                        // HoehenReglerAktiv = 1; // MartinR : so war es
+                        // MartinR : geändert Anfang
+                                if(Parameter_UserParam1 > 140) // HH über Schalter: HH an + Höhenregler abgeschaltet, Nachführen von Parametern
+                                {
+                                        HoehenReglerAktiv = 0;
+                                }
+                                else  // Höhenregler mit Sollhöhe über Poti aktiv
+                                {
+                                        HoehenReglerAktiv = 1;
+                                }
+                        // MartinR : geändert Ende
                 }
                 // calculate cos of nick and roll angle used for projection of the vertical hoover gas
 ,6 → 1588,7
                 // PD-Control with respect to hoover point
                 // the thrust loss out of horizontal attitude is compensated
                 // the setpoint will be fine adjusted with the gas stick position
+                HeightDeviation = HoehenWert - SollHoehe; //MartinR: Test
                         if(FC_StatusFlags & FC_STATUS_FLY) // trim setpoint only when flying
                         {   // gas stick is above hoover point
                                 if(StickGas > (StickGasHover + HEIGHT_CONTROL_STICKTHRESHOLD) && !BaroAtUpperLimit)
 ,7 → 1596,8
                                         if(FC_StatusFlags & FC_STATUS_VARIO_TRIM_DOWN)
                                         {
                                                 FC_StatusFlags &= ~FC_STATUS_VARIO_TRIM_DOWN;
-                                                SollHoehe = HoehenWert; // update setpoint to current heigth
+                                                //SollHoehe = HoehenWert; // update setpoint to current heigth // MartinR: so war es
+                                                SollHoehe = HoehenWert - HeightDeviation / 2; // MartinR: um den Sollwertsprung zu verringern
                                         }
                                         FC_StatusFlags |= FC_STATUS_VARIO_TRIM_UP;
                                         HeightTrimming += abs(StickGas - (StickGasHover + HEIGHT_CONTROL_STICKTHRESHOLD));
 ,7 → 1609,8
                                         if(FC_StatusFlags & FC_STATUS_VARIO_TRIM_UP)
                                         {
                                                 FC_StatusFlags &= ~FC_STATUS_VARIO_TRIM_UP;
-                                                SollHoehe = HoehenWert; // update setpoint to current heigth
+                                                //SollHoehe = HoehenWert; // update setpoint to current heigth // MartinR: so war es
+                                                SollHoehe = HoehenWert - HeightDeviation / 2; // MartinR: um den Sollwertsprung zu verringern
                                         }
                                         FC_StatusFlags |= FC_STATUS_VARIO_TRIM_DOWN;
                                         HeightTrimming -= abs(StickGas - (StickGasHover - HEIGHT_CONTROL_STICKTHRESHOLD));
 ,7 → 1629,8
                                                 if(FC_StatusFlags & FC_STATUS_VARIO_TRIM_DOWN)  // changed from sinking to rising
                                                 {
                                                         FC_StatusFlags &= ~FC_STATUS_VARIO_TRIM_DOWN;
-                                                        SollHoehe = HoehenWert; // update setpoint to current heigth
+                                                        //SollHoehe = HoehenWert; // update setpoint to current heigth // MartinR: so war es
+                                                        SollHoehe = HoehenWert - HeightDeviation / 2; // MartinR: um den Sollwertsprung zu verringern
                                                 }
                                          }
                                          else
 ,16 → 1643,19
                                                 if(FC_StatusFlags & FC_STATUS_VARIO_TRIM_UP) // changed from rising to sinking
                                                 {
                                                         FC_StatusFlags &= ~FC_STATUS_VARIO_TRIM_UP;
-                                                        SollHoehe = HoehenWert; // update setpoint to current heigth
+                                                        //SollHoehe = HoehenWert; // update setpoint to current heigth // MartinR: so war es
+                                                        SollHoehe = HoehenWert - HeightDeviation / 2; // MartinR: um den Sollwertsprung zu verringern
                                                 }
                                          }
                                         else
                                         if(FC_StatusFlags & (FC_STATUS_VARIO_TRIM_UP|FC_STATUS_VARIO_TRIM_DOWN))
                                         {
-                                                if(!WaypointTrimming) SollHoehe = HoehenWert; // update setpoint to current height
+                                                //if(!WaypointTrimming) SollHoehe = HoehenWert; // update setpoint to current height // MartinR: so war es
+                                                if(!WaypointTrimming) SollHoehe = HoehenWert - HeightDeviation / 2; // MartinR: um den Sollwertsprung zu verringern
                                                 else WaypointTrimming = 0;
                                                 FC_StatusFlags &= ~(FC_STATUS_VARIO_TRIM_UP|FC_STATUS_VARIO_TRIM_DOWN);
                                                 HeightTrimming = 0;
+                                                //MartinR: Sollhöhe sollte sich hier nicht mehr ändern!
                                                 if(EE_Parameter.ExtraConfig & CFG2_VARIO_BEEP) beeptime = 500;
                                                 if(!StartTrigger && HoehenWert > 50)
                                                 {
 ,6 → 1664,7
                                         }
                                 }
                                 // Trim height set point
+                                //LIMIT_MIN_MAX(SollHoehe, (HoehenWert-1024), (HoehenWert+1024)); // MartinR: geändert / verschoben
                                 if(abs(HeightTrimming) > 512)
                                 {
                                         if(WaypointTrimming)
 ,11 → 1674,14
                                           }
                                         else
                                         SollHoehe += (HeightTrimming * EE_Parameter.Hoehe_Verstaerkung)/(5 * 512 / 2); // move setpoint
+                                        //SollHoehe += (HeightTrimming * EE_Parameter.Hoehe_Verstaerkung)/(5 * 512 / 2); // move setpoint // MartinR: geändert
                                         HeightTrimming = 0;
                     LIMIT_MIN_MAX(SollHoehe, (HoehenWert-1024), (HoehenWert+1024)); // max. 10m Unterschied
+                                        //LIMIT_MIN_MAX(SollHoehe, (HoehenWert-256), (HoehenWert+512)); // MartinR: geändert
+                                        // MartinR: limits eventuell verändern
                                         if(EE_Parameter.ExtraConfig & CFG2_VARIO_BEEP) beeptime = 100;
                                         //update hoover gas stick value when setpoint is shifted
-                       if(!EE_Parameter.Hoehe_StickNeutralPoint && FromNC_AltitudeSpeed == 0)
+                                           if(!EE_Parameter.Hoehe_StickNeutralPoint && FromNC_AltitudeSpeed == 0)
                        {
                            StickGasHover = HoverGas/STICK_GAIN; //rescale back to stick value
                            StickGasHover = (StickGasHover * UBat) / BattLowVoltageWarning;
 ,7 → 1690,7
                        }
                                 }
               if(BaroExpandActive) SollHoehe = HoehenWert; // update setpoint to current altitude if Expanding is active
-                        } //if FCFlags & MKFCFLAG_FLY
+                        } //if FC_StatusFlags & MKFCFLAG_FLY
                         else
                         {
                          SollHoehe = HoehenWert - 400;
 ,29 → 1714,75
                                 tmp_long = (HoehenWert - SollHoehe); // positive when too high
                                 LIMIT_MIN_MAX(tmp_long, -32767L, 32767L);       // avoid overflov when casting to int16_t
                                 HeightDeviation = (int)(tmp_long); // positive when too high
+                                //tmp_long = (tmp_long * (long)Parameter_Hoehe_P) / 32L; // p-part // MartinR: so war es
+                                // MartinR: geändert Anfang
+                                if ((SollHoehe > (HoehenWert+64)) || (SollHoehe < (HoehenWert-64)))
+                                {
+                                tmp_long = (tmp_long * (long)Parameter_Hoehe_P) / 24L; // p-part // MartinR P-Part erhoehen
+                                }
+                                else
+                                {
                                 tmp_long = (tmp_long * (long)Parameter_Hoehe_P) / 32L; // p-part
-                                LIMIT_MIN_MAX(tmp_long, -127 * STICK_GAIN, 256 * STICK_GAIN); // more than the full range makes no sense
+                                }
+                                // MartinR: geändert Ende
+                                //LIMIT_MIN_MAX(tmp_long, -127 * STICK_GAIN, 256 * STICK_GAIN); // more than the full range makes no sense // MartinR: so war es
+                                // MartinR: weshalb unsymmetrisch?
+                                LIMIT_MIN_MAX(tmp_long, -128 * STICK_GAIN, 128 * STICK_GAIN); // more than the full range makes no sense // MartinR: geändert
                                 GasReduction = tmp_long;
                                 // ------------------------- D-Part 1: Vario Meter ----------------------------
-                                tmp_int = VarioMeter / 8;
+                                //tmp_int = VarioMeter / 8; // MartinR: so war es
+                                // MartinR: geändert Anfang
+                                tmp_int = VarioMeter / 4; // MartinR: geändert // Variometer: steigen ist positiv
+                                //if(FC_StatusFlags & (FC_STATUS_VARIO_TRIM_UP|FC_STATUS_VARIO_TRIM_DOWN)) tmp_int = tmp_int + Parameter_Hoehe_ACC_Wirkung* HeightDeviation / 64; // reduce d-part while trimming setpoint // MartinR: geändert
+                                //if((FC_StatusFlags & (FC_STATUS_VARIO_TRIM_UP|FC_STATUS_VARIO_TRIM_DOWN)) && ((StickGas > (StickGasHover + 2*HEIGHT_CONTROL_STICKTHRESHOLD)) || (StickGas < (StickGasHover - 2*HEIGHT_CONTROL_STICKTHRESHOLD))))
+                                //  tmp_int = tmp_int + Parameter_Hoehe_ACC_Wirkung* HeightDeviation / 64; // reduce d-part while trimming setpoint // MartinR: geändert
+                                        //if (FC_StatusFlags & (FC_STATUS_VARIO_TRIM_UP|FC_STATUS_VARIO_TRIM_DOWN))
+                                        {
+                                                if ((SollHoehe > (HoehenWert+512)) || (SollHoehe < (HoehenWert-512)))
+                                                //if ((StickGas > (StickGasHover + 3*HEIGHT_CONTROL_STICKTHRESHOLD)) || (StickGas < (StickGasHover - 3*HEIGHT_CONTROL_STICKTHRESHOLD)))
+                                                {
+                                                tmp_int = tmp_int + HeightDeviation / 28;
+                                                //tmp_int = tmp_int + Parameter_Hoehe_ACC_Wirkung* HeightDeviation / 64; // reduce d-part while trimming setpoint // MartinR: geändert
+                                                }
+                                                else
+                                                {
+                                                tmp_int = tmp_int + HeightDeviation / 32;
+                                                //tmp_int = tmp_int + Parameter_Hoehe_ACC_Wirkung* HeightDeviation / 64;
+                                                }
+                                        }
+                                // MartinR: geändert Ende
                                 LIMIT_MIN_MAX(tmp_int, -127, 128);
                                 tmp_int = (tmp_int * (long)Parameter_Luftdruck_D) / 4L; // scale to d-gain parameter
                                 LIMIT_MIN_MAX(tmp_int,-64 * STICK_GAIN, 64 * STICK_GAIN);
+                                /* // MartinR: so war es Anfang
                                 if(FC_StatusFlags & (FC_STATUS_VARIO_TRIM_UP|FC_STATUS_VARIO_TRIM_DOWN)) tmp_int /= 4; // reduce d-part while trimming setpoint
                                 else
                                 if(EE_Parameter.ExtraConfig & CFG2_HEIGHT_LIMIT) tmp_int /= 8; // reduce d-part in "Deckel" mode
+                                */ // MartinR: so war es Ende
+                                tmp_int /= 4; // MartinR: geändert: keine veränderung des d-part im "Deckel" mode
+                                //if(FC_StatusFlags & (FC_STATUS_VARIO_TRIM_UP|FC_STATUS_VARIO_TRIM_DOWN)) tmp_int /= 4; // reduce d-part while trimming setpoint // MartinR: geändert
                                 GasReduction += tmp_int;
                         } // EOF no baro range expanding
                         // ------------------------ D-Part 2: ACC-Z Integral  ------------------------
+                        /*  // MartinR: deaktiviert Anfang, da statische Ablage bei Schräglage Probleme macht
             if(Parameter_Hoehe_ACC_Wirkung)
                          {
                           tmp_long = ((Mess_Integral_Hoch / 128L) * (int32_t) Parameter_Hoehe_ACC_Wirkung) / (128L / STICK_GAIN);
-                          LIMIT_MIN_MAX(tmp_long, -32 * STICK_GAIN, 64 * STICK_GAIN);
+                          //LIMIT_MIN_MAX(tmp_long, -32 * STICK_GAIN, 64 * STICK_GAIN); // MartinR: so war es
+                          // MartinR: weshalb unsymmetrisch?
+                          LIMIT_MIN_MAX(tmp_long, -32 * STICK_GAIN, 32 * STICK_GAIN); // MartinR: geändert
                           GasReduction += tmp_long;
                          }
+                         */  // MartinR: deaktiviert Ende
                         // ------------------------ D-Part 3: GpsZ  ----------------------------------
                         tmp_int = (Parameter_Hoehe_GPS_Z * (int)FromNaviCtrl_Value.GpsZ)/128L;
-            LIMIT_MIN_MAX(tmp_int, -32 * STICK_GAIN, 64 * STICK_GAIN);
+            //LIMIT_MIN_MAX(tmp_int, -32 * STICK_GAIN, 64 * STICK_GAIN); // MartinR: so war es
+                        // MartinR: weshalb unsymmetrisch?
+                        LIMIT_MIN_MAX(tmp_int, -32 * STICK_GAIN, 32 * STICK_GAIN); // MartinR: geändert
                         GasReduction += tmp_int;
             GasReduction = (long)((long)GasReduction * HoverGas) / 512; // scale to the gas value
                         // ------------------------                  ----------------------------------
 ,7 → 1828,8
                                 LIMIT_MAX(FilterHCGas, GasMischanteil); // nicht mehr als Gas
                                 GasMischanteil = FilterHCGas;
                         }
-                        else GasMischanteil = FilterHCGas + (GasMischanteil - HoverGas) / 4; // only in Vario-Mode
+                        //else GasMischanteil = FilterHCGas + (GasMischanteil - HoverGas) / 4; // only in Vario-Mode // MartinR: so war es
+                        else GasMischanteil = FilterHCGas ; // MartinR: geändert, um  Überschwinger bei Höhenänderung zu verringern
                   }
                 }// EOF height control active
                 else // HC not active
 ,20 → 1935,107
     tmp_int = MAX_GAS*STICK_GAIN;
     if(GierMischanteil > ((tmp_int - GasMischanteil))) GierMischanteil = ((tmp_int - GasMischanteil));
     if(GierMischanteil < -((tmp_int - GasMischanteil))) GierMischanteil = -((tmp_int - GasMischanteil));
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// Nick / Roll-Achse  // MartinR: um Code zu sparen wurde Nick und Roll zusammengefasst
+// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+    DiffNick = MesswertNick - StickNick;        // Differenz bestimmen
+        DiffRoll = MesswertRoll - StickRoll;    // Differenz bestimmen
+        // PI-Regler für Nick und Roll
+        if(EE_Parameter.Gyro_Stability <= 8)
+        {
+        pd_ergebnis_nick = (EE_Parameter.Gyro_Stability * DiffNick) / 8 ; // Zwischenergebnis um Code zu sparen
+        pd_ergebnis_roll = (EE_Parameter.Gyro_Stability * DiffRoll) / 8;
+        }
+        else
+        {
+        pd_ergebnis_nick = ((EE_Parameter.Gyro_Stability / 2) * DiffNick) / 4; // Überlauf verhindern
+        pd_ergebnis_roll = ((EE_Parameter.Gyro_Stability / 2) * DiffRoll) / 4;  // Überlauf verhindern
+        }
+        if(IntegralFaktor) // MartinR : ACC-Mode
+         {
+          SummeNick += IntegralNickMalFaktor - StickNick; // I-Anteil bei Winkelregelung
+          if(SummeNick >  (STICK_GAIN * 8000L)) SummeNick =  (STICK_GAIN * 8000L); // MartinR : von 16000 auf 8000, da überlauf
+      if(SummeNick < -(8000L * STICK_GAIN)) SummeNick = -(8000L * STICK_GAIN); // MartinR : von 16000 auf 8000, da überlauf
+          pd_ergebnis_nick += (SummeNick / Ki); // PI-Regler für Nick
+          SummeNickHH = 0 ;
+          SummeRoll += IntegralRollMalFaktor - StickRoll;
+          if(SummeRoll >  (STICK_GAIN * 8000L)) SummeRoll =  (STICK_GAIN * 8000L);// MartinR : von 16000 auf 8000, da überlauf
+      if(SummeRoll < -(8000L * STICK_GAIN)) SummeRoll = -(8000L * STICK_GAIN);// MartinR : von 16000 auf 8000, da überlauf
+          pd_ergebnis_roll += (SummeRoll / Ki); // PI-Regler für Roll
+          SummeRollHH = 0;
+         }
+    else // MartinR : HH-Mode
+         {
+          SummeNickHH += DiffNick; // I-Anteil bei HH
+      if(SummeNickHH >  (STICK_GAIN * 8000L)) SummeNickHH =  (STICK_GAIN * 8000L); // MartinR : von 16000 auf 8000, da überlauf
+      if(SummeNickHH < -(8000L * STICK_GAIN)) SummeNickHH = -(8000L * STICK_GAIN); // MartinR : von 16000 auf 8000, da überlauf
+          pd_ergebnis_nick += SummeNickHH / KiHH; // MartinR: PI-Regler für Nick bei HH
+          SummeNick = 0;
+          SummeRollHH += DiffRoll;  // I-Anteil bei HH
+      if(SummeRollHH >  (STICK_GAIN * 8000L)) SummeRollHH =  (STICK_GAIN * 8000L);// MartinR : von 16000 auf 8000, da überlauf
+      if(SummeRollHH < -(8000L * STICK_GAIN)) SummeRollHH = -(8000L * STICK_GAIN);// MartinR : von 16000 auf 8000, da überlauf
+          pd_ergebnis_roll += SummeRollHH / KiHH;       // MartinR: PI-Regler für Roll bei HH
+          SummeRoll = 0;
+     }
+        // MartinR : geändert Ende
+    tmp_int = (long)((long)Parameter_DynamicStability * (long)(GasMischanteil + abs(GierMischanteil)/2)) / 64;
+    if(pd_ergebnis_nick >  tmp_int) pd_ergebnis_nick =  tmp_int;
+    if(pd_ergebnis_nick < -tmp_int) pd_ergebnis_nick = -tmp_int;
+        //tmp_int = (long)((long)Parameter_DynamicStability * (long)(GasMischanteil + abs(GierMischanteil)/2)) / 64;
+    if(pd_ergebnis_roll >  tmp_int) pd_ergebnis_roll =  tmp_int;
+    if(pd_ergebnis_roll < -tmp_int) pd_ergebnis_roll = -tmp_int;
+// MartinR: alt
+/*
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // Nick-Achse
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
     DiffNick = MesswertNick - StickNick;        // Differenz bestimmen
+        // MartinR : so war es Anfang
+        /+
     if(IntegralFaktor) SummeNick += IntegralNickMalFaktor - StickNick; // I-Anteil bei Winkelregelung
     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);
-    if(EE_Parameter.Gyro_Stability <= 8)        pd_ergebnis_nick = (EE_Parameter.Gyro_Stability * DiffNick) / 8; // PI-Regler für Nick
-    else                                                                        pd_ergebnis_nick = ((EE_Parameter.Gyro_Stability / 2) * DiffNick) / 4; // Überlauf verhindern
-    pd_ergebnis_nick +=  SummeNick / Ki;
+        pd_ergebnis_nick = (EE_Parameter.Gyro_Stability * DiffNick) / 8 + SummeNick / Ki; // PI-Regler für Nick
+    // Motor Vorn
+        +/
+        // MartinR : so war es Ende
+        // MartinR : geändert Anfang
+        pd_ergebnis_nick = (EE_Parameter.Gyro_Stability * DiffNick) / 8 ; // Zwischenergebnis um Code zu sparen
+        if(IntegralFaktor) // MartinR : ACC-Mode
+         {
+          SummeNick += IntegralNickMalFaktor - StickNick; // I-Anteil bei Winkelregelung
+          if(SummeNick >  (STICK_GAIN * 8000L)) SummeNick =  (STICK_GAIN * 8000L); // MartinR : von 16000 auf 8000, da überlauf
+      if(SummeNick < -(8000L * STICK_GAIN)) SummeNick = -(8000L * STICK_GAIN); // MartinR : von 16000 auf 8000, da überlauf
+          //pd_ergebnis_nick = DiffNick + (SummeNick / Ki);
+          pd_ergebnis_nick += (SummeNick / Ki); // PI-Regler für Nick
+          SummeNickHH = 0 ;
+         }
+    else // MartinR : HH-Mode
+         {
+          SummeNickHH += DiffNick; // I-Anteil bei HH
+      if(SummeNickHH >  (STICK_GAIN * 8000L)) SummeNickHH =  (STICK_GAIN * 8000L); // MartinR : von 16000 auf 8000, da überlauf
+      if(SummeNickHH < -(8000L * STICK_GAIN)) SummeNickHH = -(8000L * STICK_GAIN); // MartinR : von 16000 auf 8000, da überlauf
+          pd_ergebnis_nick += SummeNickHH / KiHH; // MartinR: PI-Regler für Nick bei HH
+          SummeNick = 0;
+     }
+        // MartinR : geändert Ende
     tmp_int = (long)((long)Parameter_DynamicStability * (long)(GasMischanteil + abs(GierMischanteil)/2)) / 64;
     if(pd_ergebnis_nick >  tmp_int) pd_ergebnis_nick =  tmp_int;
     if(pd_ergebnis_nick < -tmp_int) pd_ergebnis_nick = -tmp_int;
 ,18 → 2044,45
 // Roll-Achse
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
         DiffRoll = MesswertRoll - StickRoll;    // Differenz bestimmen
+        // MartinR : so war es Anfang
+        /+
     if(IntegralFaktor) SummeRoll += IntegralRollMalFaktor - StickRoll;// I-Anteil bei Winkelregelung
     else                 SummeRoll += DiffRoll;  // I-Anteil bei HH
     if(SummeRoll >  (STICK_GAIN * 16000L)) SummeRoll =  (STICK_GAIN * 16000L);
     if(SummeRoll < -(16000L * STICK_GAIN)) SummeRoll = -(16000L * STICK_GAIN);
-    if(EE_Parameter.Gyro_Stability <= 8)        pd_ergebnis_roll = (EE_Parameter.Gyro_Stability * DiffRoll) / 8;        // PI-Regler für Roll
-        else                                                                    pd_ergebnis_roll = ((EE_Parameter.Gyro_Stability / 2) * DiffRoll) / 4;  // Überlauf verhindern
-    pd_ergebnis_roll += SummeRoll / Ki;
+    pd_ergebnis_roll = (EE_Parameter.Gyro_Stability * DiffRoll) / 8 + SummeRoll / Ki;   // PI-Regler für Roll
+        +/
+        // MartinR : so war es Ende
+        // MartinR : geändert Anfang
+        pd_ergebnis_roll = (EE_Parameter.Gyro_Stability * DiffRoll) / 8;
+        if(IntegralFaktor) // MartinR : ACC-Mode
+         {
+         SummeRoll += IntegralRollMalFaktor - StickRoll;
+         if(SummeRoll >  (STICK_GAIN * 8000L)) SummeRoll =  (STICK_GAIN * 8000L);// MartinR : von 16000 auf 8000, da überlauf
+     if(SummeRoll < -(8000L * STICK_GAIN)) SummeRoll = -(8000L * STICK_GAIN);// MartinR : von 16000 auf 8000, da überlauf
+         //tmp_int = SummeRoll / Ki;
+         //pd_ergebnis_roll = DiffRoll + tmp_int;       // MartinR: PI-Regler im ACC-Mode
+         pd_ergebnis_roll += SummeRoll / Ki;    // PI-Regler für Roll
+         //SummeRollHH = (IntegralRollMalFaktor + tmp_int - stick_roll_neutral + (TrimRoll * STICK_GAIN / 2)) * KiHH;// MartinR: Startwert von SummeRollHH bei Umschaltung auf HH
+         // MartinR: Hintergrund: pd_ergebnis_xx soll sich beim Umschalten nicht ändern!
+         SummeRollHH = 0;
+         }
+    else // MartinR : HH-Mode
+         {
+          SummeRollHH += DiffRoll;  // I-Anteil bei HH
+      if(SummeRollHH >  (STICK_GAIN * 8000L)) SummeRollHH =  (STICK_GAIN * 8000L);// MartinR : von 16000 auf 8000, da überlauf
+      if(SummeRollHH < -(8000L * STICK_GAIN)) SummeRollHH = -(8000L * STICK_GAIN);// MartinR : von 16000 auf 8000, da überlauf
+          pd_ergebnis_roll += SummeRollHH / KiHH;       // MartinR: PI-Regler für Roll bei HH
+          SummeRoll = 0;
+         }
+        // MartinR : geändert Ende
     tmp_int = (long)((long)Parameter_DynamicStability * (long)(GasMischanteil + abs(GierMischanteil)/2)) / 64;
     if(pd_ergebnis_roll >  tmp_int) pd_ergebnis_roll =  tmp_int;
     if(pd_ergebnis_roll < -tmp_int) pd_ergebnis_roll = -tmp_int;
+        */
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // Universal Mixer
 ,7 → 2108,8
                         else tmp_int += ((long)GierMischanteil * Mixer.Motor[i][3]) / 64L;
                         if(tmp_int > tmp_motorwert[i]) tmp_int = (tmp_motorwert[i] + tmp_int) / 2;      // MotorSmoothing
-                        else tmp_int = 2 * tmp_int - tmp_motorwert[i];                                                              // MotorSmoothing
+                        //else tmp_int = 2 * tmp_int - tmp_motorwert[i];                // MotorSmoothing  // MartinR: so war es
+                        //else tmp_int = tmp_int;               // MartinR: Entsprechend Vorschlag von MartinW geändert
                         LIMIT_MIN_MAX(tmp_int,(int) MIN_GAS * 4,(int) MAX_GAS * 4);
                         Motor[i].SetPoint = tmp_int / 4;

 /branches/V0.84a_ACC-HH_HR_MartinR/fc.h
 ,6 → 112,9
 extern unsigned char Parameter_J16Timing;              // for the J16 Output
 extern unsigned char Parameter_J17Bitmask;             // for the J17 Output
 extern unsigned char Parameter_J17Timing;              // for the J17 Output
+extern unsigned char Parameter_NaviGpsModeControl;     // MartinR: wird wiederverwendet für GPS free bei HH
 extern signed char MixerTable[MAX_MOTORS][4];
 extern const signed char sintab[31];
 #endif //_FC_H

/branches/V0.84a_ACC-HH_HR_MartinR/flight.pnproj
1,0 → 0,0
<Project name="Flight-Ctrl"><File path="uart.h"></File><File path="jeti.h"></File><File path="main.c"></File><File path="main.h"></File><File path="makefile"></File><File path="uart.c"></File><File path="printf_P.h"></File><File path="timer0.c"></File><File path="timer0.h"></File><File path="old_macros.h"></File><File path="twimaster.c"></File><File path="version.txt"></File><File path="twimaster.h"></File><File path="rc.c"></File><File path="rc.h"></File><File path="fc.h"></File><File path="menu.h"></File><File path="menu.c"></File><File path="_Settings.h"></File><File path="analog.c"></File><File path="analog.h"></File><File path="GPS.c"></File><File path="gps.h"></File><File path="License.txt"></File><File path="spi.h"></File><File path="spi.c"></File><File path="led.h"></File><File path="led.c"></File><File path="fc.c"></File><File path="mymath.c"></File><File path="mymath.h"></File><File path="isqrt.S"></File><File path="Spektrum.c"></File><File path="Spektrum.h"></File><File path="eeprom.h"></File><File path="eeprom.c"></File><File path="libfc.h"></File><File path="debug.c"></File><File path="debug.h"></File></Project>
<Project name="Flight-Ctrl"><File path="uart.h"></File><File path="main.c"></File><File path="main.h"></File><File path="makefile"></File><File path="uart.c"></File><File path="printf_P.h"></File><File path="timer0.c"></File><File path="timer0.h"></File><File path="old_macros.h"></File><File path="twimaster.c"></File><File path="version.txt"></File><File path="twimaster.h"></File><File path="rc.c"></File><File path="rc.h"></File><File path="fc.h"></File><File path="menu.h"></File><File path="menu.c"></File><File path="_Settings.h"></File><File path="analog.c"></File><File path="analog.h"></File><File path="GPS.c"></File><File path="gps.h"></File><File path="License.txt"></File><File path="spi.h"></File><File path="spi.c"></File><File path="led.h"></File><File path="led.c"></File><File path="fc.c"></File><File path="mymath.c"></File><File path="mymath.h"></File><File path="isqrt.S"></File><File path="Spektrum.c"></File><File path="Spektrum.h"></File><File path="eeprom.h"></File><File path="eeprom.c"></File><File path="libfc.h"></File><File path="debug.c"></File><File path="debug.h"></File><File path="jetimenu.h"></File><File path="jetimenu.c"></File></Project>

 /branches/V0.84a_ACC-HH_HR_MartinR/jetimenu.c
 ,10 → 32,12
                 JetiBox_printfxy(6,0,"Status");
         }
         if(NC_ErrorCode) JetiBox_printfxy(6,0,"ERROR: %2d",NC_ErrorCode);
-        JetiBox_printfxy(0,1,"%4i %2i:%02i",Capacity.UsedCapacity,FlugSekunden/60,FlugSekunden%60);
+        //JetiBox_printfxy(0,1,"%4i %2i:%02i",Capacity.UsedCapacity,FlugSekunden/60,FlugSekunden%60); // MartinR: so war es
+        JetiBox_printfxy(0,1,"%4imAh%2i:%02i",Capacity.UsedCapacity,FlugSekunden/60,FlugSekunden%60); // MartinR: geändert
         if(EE_Parameter.GlobalConfig & CFG_HOEHENREGELUNG)
         {
-                JetiBox_printfxy(10,1,"%4im%c", (int16_t)(HoehenWert/100),VarioCharacter);
+                //JetiBox_printfxy(10,1,"%4im%c", (int16_t)(HoehenWert/100),VarioCharacter); // MartinR: so war es
+                JetiBox_printfxy(12,1,"%3im", (int16_t)(HoehenWert/100)); // MartinR: geändert
         }
 }
 ,11 → 58,13
 }
+/*  // MartinR für Tests Deaktiviert wegen Speicherplatz
 void Menu_Battery(uint8_t key)
 {                       //0123456789ABCDEF
         JetiBox_printfxy(0,0,"%2i.%1iV  %3i.%1iA", UBat/10, UBat%10, Capacity.ActualCurrent/10, Capacity.ActualCurrent%10);
         JetiBox_printfxy(0,1,"%4iW %6imAh",Capacity.ActualPower, Capacity.UsedCapacity);
 }
+*/    // MartinR:  Deaktiviert wegen Speicherplatz
 void Menu_PosInfo(uint8_t key)
 ,7 → 78,7
                                 JetiBox_printfxy(12,0,"  3D");
                                 break;
-                        case SATFIX_2D:
+                        //case SATFIX_2D: // MartinR: Deaktiviert wegen Speicherplatz
                         case SATFIX_NONE:
                         default:
                                 JetiBox_printfxy(12,0,"NoFx");
 ,6 → 97,27
 }
+// MartinR für Jeti+  Anfang
+void Menu_spoti1(uint8_t key)
+{                       //0123456789ABCDEF
+        JetiBox_printfxy(0,0,">%3i=Serialpot1",PPM_in[13]);
+        //JetiBox_printfxy(0,1," %3i=Serialpot2",PPM_in[14]);
+        if(key== JETIBOX_KEY_UP) PPM_in[13] = PPM_in[13]+25;
+        if(key== JETIBOX_KEY_DOWN) PPM_in[13] = PPM_in[13]-25;
+}
+void Menu_spoti2(uint8_t key)
+{                       //0123456789ABCDEF
+        //JetiBox_printfxy(0,0," %3i=Serialpot1",PPM_in[13]);
+        JetiBox_printfxy(0,1,">%3i=Serialpot2",PPM_in[14],key);
+        if(key== JETIBOX_KEY_UP) PPM_in[14] = PPM_in[14]+2;
+        if(key== JETIBOX_KEY_DOWN) PPM_in[14] = PPM_in[14]-2;
+}
+// MartinR für Jeti+  Ende
 // -----------------------------------------------------------
 // the menu topology
 // -----------------------------------------------------------
 ,10 → 141,17
 const MENU_ENTRY JetiBox_Menu[] PROGMEM=
 { // l  r  u  d  pHandler
-        {3, 1, 0, 0, &Menu_Status },    // 0
+        //{3, 1, 0, 0, &Menu_Status },  // 0 // MartinR: so war es
+        {4, 1, 0, 0, &Menu_Status },    // 0 // MartinR für Jeti+
         {0, 2, 1, 1, &Menu_Temperature },       // 1
-        {1, 3, 2, 2, &Menu_Battery },   // 2
-        {2, 0, 3, 3, &Menu_PosInfo },   // 3
+        //{1, 3, 2, 2, &Menu_Battery }, // 2  // MartinR: so war es
+        //{2, 0, 3, 3, &Menu_PosInfo }, // 3  // MartinR: so war es
+        {1, 3, 2, 2, &Menu_PosInfo },   // 3  // MartinR: geändert für Jeti+
+        {2, 4, 3, 3, &Menu_spoti1 },    // 4  // MartinR: für Jeti+
+        {3, 0, 4, 4, &Menu_spoti2 },    // 4  // MartinR: für Jeti+
 };
 // -----------------------------------------------------------

 /branches/V0.84a_ACC-HH_HR_MartinR/makefile
 ,7 → 42,8
 # Target file name (without extension).
 ifeq ($(VERSION_PATCH), 0)
-TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)a_SVN$(REV)
+TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)a_SVN$(REV)_ACC-HH_HR_MartinR
 endif
 ifeq ($(VERSION_PATCH), 1)
 TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)b_SVN$(REV)

 /branches/V0.84a_ACC-HH_HR_MartinR/spi.c
 ,7 → 197,9
         break;
          case SPI_FCCMD_PARAMETER1:
-                                ToNaviCtrl.Param.Byte[0] = EE_Parameter.NaviGpsModeControl;     // Parameters for the Naviboard
+                                //ToNaviCtrl.Param.Byte[0] = EE_Parameter.NaviGpsModeControl;     // Parameters for the Naviboard //MartinR: sowar es
+                                ToNaviCtrl.Param.Byte[0] = Parameter_NaviGpsModeControl;     // MartinR: wird wiederverwendet für GPS free bei HH
                                 ToNaviCtrl.Param.Byte[1] = EE_Parameter.NaviGpsGain;
                                 ToNaviCtrl.Param.Byte[2] = EE_Parameter.NaviGpsP;
                                 ToNaviCtrl.Param.Byte[3] = EE_Parameter.NaviGpsI;

 /branches/V0.84a_ACC-HH_HR_MartinR/timer0.c
 ,13 → 194,19
  signed char cosinus, sinus;
  signed long nick, roll;
+        nick = 0; // MartinR : StartWert bei abgeschalteten Nick/ Roll ausgleich
+        roll = 0; // MartinR : StartWert bei abgeschalteten Nick/ Roll ausgleich
         cosinus = sintab[EE_Parameter.CamOrientation + 6];
         sinus = sintab[EE_Parameter.CamOrientation];
   if(CalculateServoSignals == 1)
    {
+        if (Parameter_UserParam7 < 50)  // MartinR: um per UserParameter den Nickausgleich abzuschalten
+                {
                 nick = (cosinus * IntegralNick) / 128L - (sinus * IntegralRoll) / 128L;
         nick -= POI_KameraNick * 7;
+                }
                 nick = ((long)EE_Parameter.ServoNickComp * nick) / 512L;
                 ServoNickOffset += ((int16_t)Parameter_ServoNickControl * (MULTIPLYER*16) - ServoNickOffset) / EE_Parameter.ServoManualControlSpeed;
                 ServoNickValue = ServoNickOffset / 16; // offset (Range from 0 to 255 * 3 = 765)
 ,7 → 233,10
         }
         else
         {
+                if (Parameter_UserParam7 < 100)  // MartinR: um per UserParameter den Nickausgleich abzuschalten
+                {
         roll = (cosinus * IntegralRoll) / 128L + (sinus * IntegralNick) / 128L;
+                }
         roll = ((long)EE_Parameter.ServoRollComp * roll) / 512L;
                 ServoRollOffset += ((int16_t)Parameter_ServoRollControl * (MULTIPLYER*16) - ServoRollOffset) / EE_Parameter.ServoManualControlSpeed;
                 ServoRollValue = ServoRollOffset/16; // offset (Range from 0 to 255 * 3 = 765)

 /branches/V0.84a_ACC-HH_HR_MartinR/version.txt
 ,6 → 458,66
  - Kanaloffset für Potis von 110 auf 127 erhöht, damit es gleich ist mit allen anderen Kanälen
  - POI-Richtung (Soll-Himmelsrichtung) bezieht sich auf den Kamera-Winkel
+.84a_ACC-HH_HR_MartinR 13.04.2011:
+  Änderungen in: fc.c, fc.h, spi.c, analog.c, jetimenue.c, timer0.c, makefile:
+  Erweiterung um die Möglichkeit im Flug zwischen ACC und HH umschalten zu können:
+        - WICHTIG !!!!  über UserParameter1 >50 (per Schalter) kann im ACC- Modus auf HH umgeschaltet werden.
+                                        bei UserParameter1 >140, so wird zusätzlich der Höhenregler immer abgeschaltet
+        - WICHTIG !!!!  UserParameter2 ist dann der I-Faktor im HH-Mode. Hier unbedingt den für HH erforderlichen Wert eitragen! z.B.: 40..80
+        - WICHTIG !!!!  UserParameter3 ist dann Stick-P-Wert im HH-Mode. Hier unbedingt den für HH erforderlichen Wert eitragen! z.B.: 8..14
+        - UserParameter4: Beschleunigungskompensation des  Höhensensors:
+                Änderung des Höhenwertes in Normallage und Rückenlage beobachten, und UserParameter4 so einstellen, dass der Höhenwert sich dabei möglichst wenig ändert (Typ.Wert: 5..9)
+        - UserParameter5: Initialisierungswert des serialpot1 von der Jeti-Box
+        - UserParameter6: Initialisierungswert des serialpot2 von der Jeti-Box
+        - UserParameter7: Abschaltung des Kameraausgleichs: <50: mit Ausgleich, 50..100 nur Rollausgleich (kein Nickausgleich), >100: kein Ausgleich
+   - WICHTIG !!!! Beim Flug im HH-Mode unbedingt beachten:
+        - Wird der HH-Mode über UserParameter1 aktiviert, so ist die Stick-Position im Moment des Umschaltens die Neutralposition
+      für den HH-Mode. Hierdurch bleibt der ACC-Mode trimmbar.
+        - Der Nick- und Roll-Knüppel muß daher aber beim Umschalten von ACC auf HH in Mittelstellung stehen.
+        - Beim Zurückschalten von HH- auf ACC-Mode ist es egal wo der Knüppel steht
+        - Der Höhenregler kann beim HH-Mode über UserParameter1 deaktiviert werden, wenn UserParameter1 >140 ist.
+          UserParameter1 =50..140 : HH mit Höhenregler, UserParameter1 >140: HH ohne Höhenregler.
+          Beim normalen HH kann der Höhenregler verwendet werden.
+        - Die GPS-Funktionen sind im HH-Mode  automatisch deaktiv.
+      Dadurch kann aus dem HH-Mode heraus beim Zurückschalten in den ACC-Modus der MK in der Luft geparkt werden!
+   - HH-Mode wurde reduziert auf die Regler-Grundfunktionen!
+     keine Driftkompensation, keine GPS- Funktion.
+   - bei HH über UserParameter1 wird der Kompass abgeschaltet. Bei "normalem HH" kann der Kompass verwendet werden
+   - Zu beachten: die anwählbare Drehratenbegrenzung wird derzeit im HH-Modus nicht abgeschaltet
+   - Begrenzung von SummeNick SummeRoll reduziert, da Überlauf beobachtet wurde
+   - Die Progression von MesswetNick MesswertRoll, wenn der Gyro an die Grenzen kommt wurde Hardwareabhängig geändert (Sprung bei V1.0 war für HH zu groß)
+   - WICHTIG !!!! Damit die Version auch auf den 644er Prozessor passt:
+. die ACC-Loopingfunktion wurde deaktiviert und
+. die serielle Steuerung wurde deaktiviert
+   weitere Änderungen:
+   - in der analog.c wurde das Nachführen von "NeutralAccZ" deaktiviert
+   - MotorSmoothing entsprechend einem Vorschlag von MartinW geändert
+   - Rundungsfehler bei Nick und Roll in der analog.c wurden verringert (HH-Mode driftet weniger)
+   - Drift im HH-Mode bei hohen Stick- Trimmwerten wurde verringert
+   - einige Änderungen um Code einzusparen
+   - der Kameraausgleich funktioniert nun auch im HH-Mode
+   - Der Kameraausgleich kann über UserParameter7 deaktiviert werden (timer0.c): <50: mit Ausgleich, 50..100 nur Rollausgleich, >100: kein Ausgleich
+   - Jeti-Menü modifiziert und Teile der Jeti+ Erweiterung übernommen:
+                Menü Status modifiziert und dafür Menü Battery deaktiviert (wegen Speicherplatz)
+                es gibt nun zwei serielle Potis im Jeti-Menü: Serialpot1 und Serialpot2
+                Serialpot1 hat eine Schrittweite von 25, während Serialpot2 eine Schrittweite von 2 hat.
+                der Startwert kann über UserParameter5 bzw. Userparameter6   eingestellt werden.
+                Ein UserParameter von 0 ergibt damit einen seriellPoti (Start)Wert von -110, was einem Poti Wert von 0 entspricht.
+                Der Startwert wird immer beim Gyro-Kalibrieren übernommen.
+        - Luftdrucksensor mit Beschleunigungskompensation über UserParameter4:
+                Änderung des Höhenwertes in Normallage und Rückenlage beobachten, und UserParameter4 so einstellen, dass der Höhenwert sich dabei möglichst wenig ändert (Typ.Wert: 5..9)
+        - Höhenregler wurde modifiziert (SollHoehe, Limits symmetrisch, keine veränderung des d-part im "Deckel" mode, Reduzierung D-Part im Vario-Mode ..)
+        - Z-ACC Part bei der Höhenregelung funktioniert noch nicht richtig. Daher Z-ACC = 0 einstellen
+        - Ich fliege derzeit mit Höhe-P = 8 und Höhe-D = 35,  Z-ACC=0

Subversion Repositories FlightCtrl

Compare Revisions

Ignore whitespace Rev 1880 → Rev 1888