WebSVN - FlightCtrl - Path Comparison - / Rev 2495 and / Rev 2496

Ignore whitespace Rev 2495 → Rev 2496

 /trunk/fc.c
 ,7 → 169,6
 unsigned char CareFree = 0;
 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;
 unsigned int  modell_fliegt = 0;
 volatile unsigned char FC_StatusFlags = 0, FC_StatusFlags2 = 0;
 ,7 → 400,6
         KompassSignalSchlecht = 100;
         Umschlag180Nick = ((long) EE_Parameter.WinkelUmschlagNick * 2500L) + 15000L;
         Umschlag180Roll = ((long) EE_Parameter.WinkelUmschlagRoll * 2500L) + 15000L;
-    ExternHoehenValue = 0;
     ErsatzKompass = KompassValue * GIER_GRAD_FAKTOR;
     GierGyroFehler = 0;
     LED_Init();
 ,6 → 820,7
    if(GasIsZeroCnt == 30000)  // in that case we have RC-Lost, but the MK is probably landed
     {
          StickGas = 0; // Hold Gas down in that case
+         ExternalControl.Gas = 0;
          HooverGasEmergencyPercent = MIN_GAS;
         }
         GasMischanteil = StickGas;
 ,12 → 965,12
 #endif
                }
                           }  // end of: modell_fliegt > 256
-            if((PPM_in[EE_Parameter.Kanalbelegung[K_GAS]] > 80) && MotorenEin == 0 && !(NC_To_FC_Flags & NC_TO_FC_SIMULATION_ACTIVE))
+            if((ChannelGas > 80) && MotorenEin == 0 && !(NC_To_FC_Flags & NC_TO_FC_SIMULATION_ACTIVE))
                 {
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // auf Nullwerte kalibrieren
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-                if(abs(PPM_in[EE_Parameter.Kanalbelegung[K_GIER]]) > 75)  // Neutralwerte
+                if(abs(ChannelYaw) > 75)  // Neutralwerte
                     {
                     if(++delay_neutral > 200)  // nicht sofort
                         {
 ,16 → 977,16
                         unsigned char setting = 0;
                         delay_neutral = 0;
                         modell_fliegt = 0;
-                        if(PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] > 70 || abs(PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]]) > 70)
+                        if(ChannelNick > 70 || abs(ChannelRoll) > 70)
                         {
-                         if(PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] > 70 && PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] < 70 && PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] > -70) setting = 1;
-                         if(PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] > 70 && PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] > 70) setting = 2;
-                         if(PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] < 70 && PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] > 70) setting = 3;
-                         if(PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] <-70 && PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] > 70) setting = 4;
-                         if(PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] <-70 && PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] < 70  && PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] > -70) setting = 5;
+                         if(ChannelRoll > 70 && ChannelNick < 70 && ChannelNick > -70) setting = 1;
+                         if(ChannelRoll > 70 && ChannelNick > 70) setting = 2;
+                         if(ChannelRoll < 70 && ChannelNick > 70) setting = 3;
+                         if(ChannelRoll <-70 && ChannelNick > 70) setting = 4;
+                         if(ChannelRoll <-70 && ChannelNick < 70  && ChannelNick > -70) setting = 5;
                          if(setting) SetActiveParamSet(setting);  // aktiven Datensatz merken
                         }
-                         if(abs(PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]]) < 30 && PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] < -70)
+                         if(abs(ChannelRoll) < 30 && ChannelNick < -70)
                           {
                            WinkelOut.CalcState = 1;
                                                    CalibrationDone = 0;
 ,9 → 1001,9
                             {
                              if((MessLuftdruck > 950) || (MessLuftdruck < 750)) SucheLuftruckOffset();
                             }
-                           if(!setting && PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] < -70 && PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] < 70) CalibrationDone = SetNeutral(3);
+                           if(!setting && ChannelRoll < -70 && ChannelNick < 70) CalibrationDone = SetNeutral(3);
                                                    else
-                                                   if(!setting && PPM_in[EE_Parameter.Kanalbelegung[K_GIER]] < -75 && abs(PPM_in[EE_Parameter.Kanalbelegung[K_NICK]]) < 70)  CalibrationDone = SetNeutral(2); // store ACC values into EEPROM
+                                                   if(!setting && ChannelYaw < -75 && abs(ChannelNick) < 70)  CalibrationDone = SetNeutral(2); // store ACC values into EEPROM
                                                    else    CalibrationDone = SetNeutral(1);
                                                    ServoActive = 1;
                                                    DDRD  |=0x80; // enable J7 -> Servo signal
 ,32 → 1018,12
                          }
                         }
                     }
-/*
-                 else
-                if(PPM_in[EE_Parameter.Kanalbelegung[K_GIER]] < -75)  // ACC Neutralwerte speichern
-                    {
-                    if(++delay_neutral > 200)  // nicht sofort
-                        {
-                        MotorenEin = 0;
-                        delay_neutral = 0;
-                        modell_fliegt = 0;
-                        CalibrationDone = SetNeutral(2); // store ACC values into EEPROM
-#if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__))
-                                                   if(VersionInfo.HardwareError[0]) SpeakHoTT = SPEAK_ERR_SENSOR;
-                                                   else
-                                                   if(!CalibrationDone) SpeakHoTT = SPEAK_ERR_CALIBARTION;
-                                                   else SpeakHoTT = SPEAK_CALIBRATE;
-#endif
-                        Piep(ActiveParamSet,120);
-                        }
-                    }
-*/
                  else delay_neutral = 0;
                 }
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // Gas ist unten
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-            if(PPM_in[EE_Parameter.Kanalbelegung[K_GAS]] < -100)
+            if(ChannelGas < -100)
                 {
                                         if(PPM_diff[EE_Parameter.MotorSafetySwitch & 127] > 5) move_safety_switch = 100;
                                         else
 ,7 → 1031,7
                                         // Motoren Starten
                                         if(!MotorenEin)
                         {
-                                                if(((((PPM_in[EE_Parameter.Kanalbelegung[K_GIER]] < -100) && ((!(EE_Parameter.GlobalConfig3 & CFG3_MOTOR_SWITCH_MODE) && PPM_in[EE_Parameter.MotorSafetySwitch] < -75) || EE_Parameter.MotorSafetySwitch == 0)))
+                                                if(((((ChannelYaw < -100) && ((!(EE_Parameter.GlobalConfig3 & CFG3_MOTOR_SWITCH_MODE) && PPM_in[EE_Parameter.MotorSafetySwitch] < -75) || EE_Parameter.MotorSafetySwitch == 0)))
                                                 || (((EE_Parameter.GlobalConfig3 & CFG3_MOTOR_SWITCH_MODE) && PPM_in[EE_Parameter.MotorSafetySwitch] > -10 && move_safety_switch == 100)))
                                                 && !(NC_To_FC_Flags & NC_TO_FC_SIMULATION_ACTIVE))
                                                 {
 ,7 → 1048,7
                                                         HoehenWertF_Mess = 0;
 #endif
                                                         SummenHoehe = 0;
-                                                        if((PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] > -100 || abs(PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]]) < 100) && EE_Parameter.MotorSafetySwitch == 0) delay_einschalten = 0;
+                                                        if((ChannelNick > -100 || abs(ChannelRoll) < 100) && EE_Parameter.MotorSafetySwitch == 0) delay_einschalten = 0;
                                                         if(++delay_einschalten > 253)
                                                         {
 if(FC_StatusFlags3 & FC_STATUS3_BOAT) { if((abs(MesswertGier) > 32*2 || abs(MesswertNick) > 20*3) || abs(MesswertRoll) > 20*3)  CalibrationDone = 0; } // dann ist der Gyro defekt, schlecht kalibriert oder der MK dreht sich
 ,10 → 1089,10
                                         else // only if motors are running
                                         {
 //                                              if((PPM_in[EE_Parameter.Kanalbelegung[K_GIER]] > 75) && (PPM_in[EE_Parameter.MotorSafetySwitch] < -75 || EE_Parameter.MotorSafetySwitch == 0))
-                                                if((((PPM_in[EE_Parameter.Kanalbelegung[K_GIER]] > 100) && ((!(EE_Parameter.GlobalConfig3 & CFG3_MOTOR_SWITCH_MODE) && PPM_in[EE_Parameter.MotorSafetySwitch] < -75) || EE_Parameter.MotorSafetySwitch == 0)))
+                                                if((((ChannelYaw > 100) && ((!(EE_Parameter.GlobalConfig3 & CFG3_MOTOR_SWITCH_MODE) && PPM_in[EE_Parameter.MotorSafetySwitch] < -75) || EE_Parameter.MotorSafetySwitch == 0)))
                                                 || (((EE_Parameter.GlobalConfig3 & CFG3_MOTOR_SWITCH_MODE) && PPM_in[EE_Parameter.MotorSafetySwitch] < -50 && move_safety_switch == -100)))
                                                 {
-                                                        if((PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] > -100 || abs(PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]]) < 100) && EE_Parameter.MotorSafetySwitch == 0)
+                                                        if((ChannelNick > -100 || abs(ChannelRoll) < 100) && EE_Parameter.MotorSafetySwitch == 0)
                                                         {
                                                                 delay_ausschalten = 0;
                                                         }
 ,11 → 1150,39
         static int stick_nick,stick_roll;
         unsigned char stick_p;
     ParameterZuordnung();
         stick_p = EE_Parameter.Stick_P;
-    stick_nick = (stick_nick * 3 + PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] * stick_p) / 4;
+cli();
+        ChannelNick = PPM_in[EE_Parameter.Kanalbelegung[K_NICK]];
+        ChannelRoll = PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]];
+        ChannelYaw = PPM_in[EE_Parameter.Kanalbelegung[K_GIER]];
+        ChannelGas = PPM_in[EE_Parameter.Kanalbelegung[K_GAS]];
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+//+ Analoge Steuerung per Seriell
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+if((ExternalControl.Config & EC_VALID) && (Parameter_ExternalControl > 128))
+    {
+                ChannelNick += ExternalControl.Nick;
+                ChannelRoll += ExternalControl.Roll;
+                ChannelYaw += ExternalControl.Gier;
+        if(ExternalControl.Config & EC_GAS_ADD) ChannelGas += ExternalControl.Gas;
+                else
+                 {
+                  if(ExternalControl.Gas < ChannelGas) ChannelGas = ExternalControl.Gas; // the RC-Stick is the MAX value here
+             }
+        }
+sei();
+        if(ChannelNick > 127) ChannelNick = 127;        else if(ChannelNick < -127) ChannelNick = -127;
+        if(ChannelRoll > 127) ChannelRoll = 127;        else if(ChannelRoll < -127) ChannelRoll = -127;
+        if(ChannelYaw  > 127) ChannelYaw = 127;         else if(ChannelYaw < -127) ChannelYaw = -127;
+        if(ChannelGas  > 127) ChannelGas = 127;         else if(ChannelGas < -127) ChannelGas = -127;
+    stick_nick = (stick_nick * 3 + ChannelNick * stick_p) / 4;
+    stick_roll = (stick_roll * 3 + ChannelRoll * stick_p) / 4;
+cli();
     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]] * stick_p) / 4;
     stick_roll += PPM_diff[EE_Parameter.Kanalbelegung[K_ROLL]] * EE_Parameter.Stick_D;
+sei();
+        StickGas  = ChannelGas + 127;
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // CareFree und freie Wahl der vorderen Richtung
 ,7 → 1203,7
                 StickRoll = ((FromNC_Rotate_C * stick_roll) - (FromNC_Rotate_S * stick_nick)) / 8;
         }
-    StickGier = -PPM_in[EE_Parameter.Kanalbelegung[K_GIER]];
+    StickGier = -ChannelYaw;
         if(StickGier > 4) StickGier -= 4;       else
         if(StickGier < -4) StickGier += 4; else StickGier = 0;
 ,7 → 1222,6
          }
     StickNick -= GPS_Nick;
     StickRoll -= GPS_Roll;
-        StickGas  = PPM_in[EE_Parameter.Kanalbelegung[K_GAS]] + 127;
     GyroFaktor     = (Parameter_Gyro_P + 10.0);
     IntegralFaktor = Parameter_Gyro_I;
 ,18 → 1228,6
     GyroFaktorGier     = (Parameter_Gyro_Gier_P + 10.0);
     IntegralFaktorGier = Parameter_Gyro_Gier_I;
-//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-//+ Analoge Steuerung per Seriell
-//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-   if(ExternControl.Config & 0x01 && Parameter_ExternalControl > 128)
-    {
-         StickNick += (int) ExternControl.Nick * (int) EE_Parameter.Stick_P;
-         StickRoll += (int) ExternControl.Roll * (int) EE_Parameter.Stick_P;
-         StickGier += ExternControl.Gier;
-     ExternHoehenValue =  (int) ExternControl.Hight * (int)EE_Parameter.Hoehe_Verstaerkung;
-     if(ExternControl.Gas < StickGas) StickGas = ExternControl.Gas;
-    }
-    if(StickGas < 0) StickGas = 0;
     if(Parameter_GlobalConfig & CFG_HEADING_HOLD) IntegralFaktor =  0;
 ,7 → 1367,7
                 tmp_long  /= 3;
                 tmp_long2 /= 3;
                 }
-                if(abs(PPM_in[EE_Parameter.Kanalbelegung[K_GIER]]) > 25)
+                if(abs(ChannelYaw) > 25)
                 {
                 tmp_long  /= 3;
                 tmp_long2 /= 3;
 ,7 → 1400,7
    DriftNick -= DriftNick / (64 * (unsigned int) EE_Parameter.Driftkomp);
    DriftRoll -= DriftRoll / (64 * (unsigned int) EE_Parameter.Driftkomp);
    GierGyroFehler -= GierGyroFehler / (64 * (unsigned int) EE_Parameter.Driftkomp);
-   if((MaxStickNick > 64) || (MaxStickRoll > 64) || (abs(PPM_in[EE_Parameter.Kanalbelegung[K_GIER]]) > 25))
+   if((MaxStickNick > 64) || (MaxStickRoll > 64) || (abs(ChannelYaw) > 25))
     {
      DriftNick /= 2;
      DriftRoll /= 2;
 ,138 → 1421,6
   }
   TrichterFlug = 0;
-/*
-  if(!Looping_Nick && !Looping_Roll && !TrichterFlug && EE_Parameter.Driftkomp)
-  {
-    MittelIntegralNick  /= ABGLEICH_ANZAHL;
-    MittelIntegralRoll  /= ABGLEICH_ANZAHL;
-        IntegralAccNick = (EE_Parameter.GyroAccFaktor * IntegralAccNick) / ABGLEICH_ANZAHL;
-        IntegralAccRoll = (EE_Parameter.GyroAccFaktor * IntegralAccRoll) / ABGLEICH_ANZAHL;
-    IntegralAccZ    = IntegralAccZ / ABGLEICH_ANZAHL;
-#define MAX_I 0
-// Nick ++++++++++++++++++++++++++++++++++++++++++++++++
-    IntegralFehlerNick = (long)(MittelIntegralNick - (long)IntegralAccNick);
-    ausgleichNick = IntegralFehlerNick / EE_Parameter.GyroAccAbgleich;
-// Roll ++++++++++++++++++++++++++++++++++++++++++++++++
-    IntegralFehlerRoll = (long)(MittelIntegralRoll - (long)IntegralAccRoll);
-    ausgleichRoll = IntegralFehlerRoll / EE_Parameter.GyroAccAbgleich;
-    LageKorrekturNick = ausgleichNick / ABGLEICH_ANZAHL;
-    LageKorrekturRoll = ausgleichRoll / ABGLEICH_ANZAHL;
-   if(((MaxStickNick > 64) || (MaxStickRoll > 64) || (abs(PPM_in[EE_Parameter.Kanalbelegung[K_GIER]]) > 25)) && (FromNaviCtrl_Value.Kalman_K == -1))
-    {
-     LageKorrekturNick /= 2;
-     LageKorrekturRoll /= 2;
-    }
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-// Gyro-Drift ermitteln
-// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-    MittelIntegralNick2 /= ABGLEICH_ANZAHL;
-    MittelIntegralRoll2 /= ABGLEICH_ANZAHL;
-    tmp_long  = IntegralNick2 - IntegralNick;
-    tmp_long2 = IntegralRoll2 - IntegralRoll;
-    IntegralFehlerNick = tmp_long;
-    IntegralFehlerRoll = tmp_long2;
-    Mess_IntegralNick2 -= IntegralFehlerNick;
-    Mess_IntegralRoll2 -= IntegralFehlerRoll;
-  if(EE_Parameter.Driftkomp)
-   {
-    if(GierGyroFehler > ABGLEICH_ANZAHL/2) { AdNeutralGier++; }
-    if(GierGyroFehler <-ABGLEICH_ANZAHL/2) { AdNeutralGier--; }
-   }
-    GierGyroFehler = 0;
-#define FEHLER_LIMIT  (ABGLEICH_ANZAHL / 2)
-#define FEHLER_LIMIT1 (ABGLEICH_ANZAHL * 2) //4
-#define FEHLER_LIMIT2 (ABGLEICH_ANZAHL * 16) //16
-#define BEWEGUNGS_LIMIT 20000
-// Nick +++++++++++++++++++++++++++++++++++++++++++++++++
-        cnt = 1;// + labs(IntegralFehlerNick) / 4096;
-        if(labs(IntegralFehlerNick) > FEHLER_LIMIT1) cnt = 4;
-        if(labs(MittelIntegralNick_Alt - MittelIntegralNick) < BEWEGUNGS_LIMIT || (FromNaviCtrl_Value.Kalman_MaxDrift > 3*8))
-        {
-        if(IntegralFehlerNick >  FEHLER_LIMIT2)
-         {
-           if(last_n_p)
-           {
-            cnt += labs(IntegralFehlerNick) / (FEHLER_LIMIT2 / 8);
-            ausgleichNick = IntegralFehlerNick / 8;
-            if(ausgleichNick > 5000) ausgleichNick = 5000;
-            LageKorrekturNick += ausgleichNick / ABGLEICH_ANZAHL;
-           }
-           else last_n_p = 1;
-         } else  last_n_p = 0;
-        if(IntegralFehlerNick < -FEHLER_LIMIT2)
-         {
-           if(last_n_n)
-            {
-             cnt += labs(IntegralFehlerNick) / (FEHLER_LIMIT2 / 8);
-             ausgleichNick = IntegralFehlerNick / 8;
-             if(ausgleichNick < -5000) ausgleichNick = -5000;
-             LageKorrekturNick += ausgleichNick / ABGLEICH_ANZAHL;
-            }
-           else last_n_n = 1;
-         } else  last_n_n = 0;
-        }
-        else
-        {
-         cnt = 0;
-         KompassSignalSchlecht = 100;
-        }
-        if(cnt > EE_Parameter.Driftkomp) cnt = EE_Parameter.Driftkomp;
-                if(FromNaviCtrl_Value.Kalman_MaxDrift) if(cnt > FromNaviCtrl_Value.Kalman_MaxDrift) cnt = FromNaviCtrl_Value.Kalman_MaxDrift;
-        if(IntegralFehlerNick >  FEHLER_LIMIT)   AdNeutralNick += cnt;
-        if(IntegralFehlerNick < -FEHLER_LIMIT)   AdNeutralNick -= cnt;
-// Roll +++++++++++++++++++++++++++++++++++++++++++++++++
-        cnt = 1;// + labs(IntegralFehlerRoll) / 4096;
-        if(labs(IntegralFehlerRoll) > FEHLER_LIMIT1) cnt = 4;
-        if(labs(MittelIntegralRoll_Alt - MittelIntegralRoll) < BEWEGUNGS_LIMIT || (FromNaviCtrl_Value.Kalman_MaxDrift > 3*8))
-        {
-        if(IntegralFehlerRoll >  FEHLER_LIMIT2)
-         {
-           if(last_r_p)
-           {
-            cnt += labs(IntegralFehlerRoll) / (FEHLER_LIMIT2 / 8);
-            ausgleichRoll = IntegralFehlerRoll / 8;
-            if(ausgleichRoll > 5000) ausgleichRoll = 5000;
-            LageKorrekturRoll += ausgleichRoll / ABGLEICH_ANZAHL;
-           }
-           else last_r_p = 1;
-         } else  last_r_p = 0;
-        if(IntegralFehlerRoll < -FEHLER_LIMIT2)
-         {
-           if(last_r_n)
-           {
-            cnt += labs(IntegralFehlerRoll) / (FEHLER_LIMIT2 / 8);
-            ausgleichRoll = IntegralFehlerRoll / 8;
-            if(ausgleichRoll < -5000) ausgleichRoll = -5000;
-            LageKorrekturRoll += ausgleichRoll / ABGLEICH_ANZAHL;
-           }
-           else last_r_n = 1;
-         } else  last_r_n = 0;
-        } else
-        {
-         cnt = 0;
-         KompassSignalSchlecht = 100;
-        }
-        if(cnt > EE_Parameter.Driftkomp) cnt = EE_Parameter.Driftkomp;
-                if(FromNaviCtrl_Value.Kalman_MaxDrift) if(cnt > FromNaviCtrl_Value.Kalman_MaxDrift) cnt = FromNaviCtrl_Value.Kalman_MaxDrift;
-        if(IntegralFehlerRoll >  FEHLER_LIMIT)   AdNeutralRoll += cnt;
-        if(IntegralFehlerRoll < -FEHLER_LIMIT)   AdNeutralRoll -= cnt;
-  }
-  else
-  {
-   LageKorrekturRoll = 0;
-   LageKorrekturNick = 0;
-   TrichterFlug = 0;
-  }
-*/
   if(!IntegralFaktor) { LageKorrekturRoll = 0; LageKorrekturNick = 0;} // z.B. bei HH
 // +++++++++++++++++++++++++++++++++++++++++++++++++++++
    MittelIntegralNick_Alt = MittelIntegralNick;
 ,7 → 1664,7
                 }
                 else // no switchable height control
                 {
-                        SollHoehe = ((int16_t) ExternHoehenValue + (int16_t) Parameter_HoehenSchalter) * (int)EE_Parameter.Hoehe_Verstaerkung;
+                        SollHoehe = (/*(int16_t) ExternHoehenValue + */(int16_t) Parameter_HoehenSchalter) * (int)EE_Parameter.Hoehe_Verstaerkung;
                         HoehenReglerAktiv = 1;
                 }
                 // calculate cos of nick and roll angle used for projection of the vertical hoover gas

/trunk/fc.h
101,7 → 101,6
extern int NeutralAccZ;
extern signed char NeutralAccZfine;
extern long Umschlag180Nick, Umschlag180Roll;
extern signed int ExternStickNick,ExternStickRoll,ExternStickGier;
extern unsigned char Parameter_UserParam1,Parameter_UserParam2,Parameter_UserParam3,Parameter_UserParam4,Parameter_UserParam5,Parameter_UserParam6,Parameter_UserParam7,Parameter_UserParam8;
extern int NaviAccNick,NaviAccRoll,NaviCntAcc;
extern unsigned int modell_fliegt;

 /trunk/hottmenu.c
 ,8 → 823,8
         case 6:
                         if(!show_poti)
                          {
-              HoTT_printfxy(0,6,"Ni:%4i Ro:%4i C:%3i",PPM_in[EE_Parameter.Kanalbelegung[K_NICK]],PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]], Parameter_ServoNickControl);
-                      HoTT_printfxy(0,7,"Gs:%4i Ya:%4i ",PPM_in[EE_Parameter.Kanalbelegung[K_GAS]]+127,PPM_in[EE_Parameter.Kanalbelegung[K_GIER]]);
+              HoTT_printfxy(0,6,"Ni:%4i Ro:%4i C:%3i",ChannelNick,ChannelRoll, Parameter_ServoNickControl);
+                      HoTT_printfxy(0,7,"Gs:%4i Ya:%4i ",ChannelGas+127,ChannelYaw);
                          }
                         else
                          {

/trunk/libfc1284.a
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

 /trunk/main.c
 ,8 → 72,8
 void CalMk3Mag(void)
 {
  static unsigned char stick = 1;
- if(PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] > -20) stick = 0;
- if((PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] < -70) && !stick)
+ if(ChannelNick > -20) stick = 0;
+ if((ChannelNick < -70) && !stick)
   {
    stick = 1;
    WinkelOut.CalcState++;
 ,7 → 178,7
     WDTCSR = 0;
     beeptime = 2500;
-        StickGier = 0; PPM_in[K_GAS] = 0; StickRoll = 0; StickNick = 0;
+        StickGier = 0; StickRoll = 0; StickNick = 0;
     if(PlatinenVersion >= 20)  GIER_GRAD_FAKTOR = 1220; else GIER_GRAD_FAKTOR = 1291; // unterschiedlich für ME und ENC
     ROT_OFF;
     GRN_ON;
 ,8 → 224,8
                 {
                         while(!CheckDelay(timer) && !(Motor[i].State & MOTOR_STATE_PRESENT_MASK) )
                         {
-                                SendMotorData();
-                                while(!(BLFlags & BLFLAG_TX_COMPLETE) && !CheckDelay(timer)); //wait for complete transfer
+                                if((BLFlags & BLFLAG_TX_COMPLETE)) SendMotorData();
+                                //while(!(BLFlags & BLFLAG_TX_COMPLETE) && !CheckDelay(timer)); //wait for complete transfer
                         }
                 }
                 if(Motor[i].State & MOTOR_STATE_PRESENT_MASK)
 ,9 → 290,7
         ROT_OFF;
     beeptime = 2000;
-    ExternControl.Digital[0] = 0x55;
         FlugMinuten = (unsigned int)GetParamByte(PID_FLIGHT_MINUTES) * 256 + (unsigned int)GetParamByte(PID_FLIGHT_MINUTES + 1);
         FlugMinutenGesamt = (unsigned int)GetParamByte(PID_FLIGHT_MINUTES_TOTAL) * 256 + (unsigned int)GetParamByte(PID_FLIGHT_MINUTES_TOTAL + 1);
 ,6 → 348,10
                                 PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] = 0;
                                 PPM_in[EE_Parameter.Kanalbelegung[K_GIER]] = 0;
                                 PPM_in[EE_Parameter.Kanalbelegung[K_GAS]] = 0;
+                                ChannelNick = 0;
+                                ChannelRoll = 0;
+                                ChannelYaw = 0;
+                                ChannelGas = 0;
                         }
 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 //if(HoehenReglerAktiv && NaviDataOkay && SenderOkay < 160 && SenderOkay > 10 && FromNaviCtrl_Value.SerialDataOkay > 220) SenderOkay = 160;
 ,10 → 428,6
                                 if(PcZugriff) PcZugriff--;
                                 else
                                 {
-                                        ExternControl.Config = 0;
-                                        ExternStickNick = 0;
-                                        ExternStickRoll = 0;
-                                        ExternStickGier = 0;
                                         if(!SenderOkay)
                                         {
                                           if(BeepMuster == 0xffff && DisableRcOffBeeping != 2)
 ,6 → 479,12
                                         }
                                 }
                                 // +++++++++++++++++++++++++++++++++
+                                if(ExternalControlTimeout)
+                                 {
+                                  ExternalControlTimeout--;
+                                  if(ExternalControlTimeout == 1) beeptime = 2000;
+                                 }
+                                // +++++++++++++++++++++++++++++++++
                                 // Sekundentakt
                 if(++second == 49)
                                  {

 /trunk/menu.c
 ,8 → 146,8
            for(i=1;i<9;i+=2) LCD_printfxy(0,i/2,"K%i:%4i  K%i:%4i ",i,PPM_in[i],i+1,PPM_in[i+1]);
            break;
     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]]+127,PPM_in[EE_Parameter.Kanalbelegung[K_GIER]]);
+           LCD_printfxy(0,0,"Ni:%4i  Ro:%4i ",ChannelNick,ChannelRoll);
+           LCD_printfxy(0,1,"Gs:%4i  Gi:%4i ",ChannelGas+127,ChannelYaw);
            LCD_printfxy(0,2,"P1:%4i  P2:%4i ",PPM_in[EE_Parameter.Kanalbelegung[K_POTI1]]+127,PPM_in[EE_Parameter.Kanalbelegung[K_POTI2]]+127);
            LCD_printfxy(0,3,"P3:%4i  P4:%4i ",PPM_in[EE_Parameter.Kanalbelegung[K_POTI3]]+127,PPM_in[EE_Parameter.Kanalbelegung[K_POTI4]]+127);
            break;

/trunk/rc.c
63,6 → 63,7
volatile char Channels,tmpChannels = 0;
volatile unsigned char NewPpmData = 1;
unsigned int PPM_Neutral = 466;
signed int ChannelNick,ChannelRoll,ChannelGas,ChannelYaw;

//############################################################################
// Clear the values

/trunk/rc.h
22,6 → 22,7
extern volatile unsigned char NewPpmData;
extern volatile char Channels,tmpChannels;
extern unsigned int PPM_Neutral;
extern signed int ChannelNick,ChannelRoll,ChannelGas,ChannelYaw;

// 0 -> frei bzw. ACT rssi
// 1 - 16 -> 1-16

 /trunk/spi.c
 ,6 → 1,7
 // ######################## SPI - FlightCtrl ###################
 #include "main.h"
 #include "eeprom.h"
+#include "uart.h"
 //struct str_ToNaviCtrl_Version   ToNaviCtrl_Version;
 //struct str_FromNaviCtrl_Version   FromNaviCtrl_Version;
 ,7 → 83,7
 }
 //------------------------------------------------------
-//SIGNAL(SIG_SPI)
+//SIaNAL(SIG_SPI)
 void SPI_TransmitByte(void)
 {
    static unsigned char SPI_RXState = 0;
 ,7 → 149,7
 //------------------------------------------------------
 void UpdateSPI_Buffer(void)
 {
-  signed int tmp;
+//  signed int tmp;
   static unsigned char motorindex, oldcommand = SPI_NCCMD_VERSION, slow_command;
   ToNaviCtrl.IntegralNick = (int) (IntegralNick / (long)(EE_Parameter.GyroAccFaktor * 4)); // etwa in 0.1 Grad
   ToNaviCtrl.IntegralRoll = (int) (IntegralRoll / (long)(EE_Parameter.GyroAccFaktor * 4)); // etwa in 0.1 Grad
 ,6 → 255,7
                                 ToNaviCtrl.Param.Byte[11] = EE_Parameter.SingleWpSpeed;
             break;
          case SPI_FCCMD_STICK:
+/*
               cli();
                 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;
 ,6 → 266,11
                 tmp = PPM_in[EE_Parameter.Kanalbelegung[K_NICK]]; if(tmp > 127) tmp = 127; else if(tmp < -127) tmp = -127;
               sei();
                                 ToNaviCtrl.Param.Byte[3] = (char) tmp;
+*/
+                                ToNaviCtrl.Param.Byte[0] = ChannelGas;
+                                ToNaviCtrl.Param.Byte[1] = ChannelYaw;
+                                ToNaviCtrl.Param.Byte[2] = ChannelRoll;
+                                ToNaviCtrl.Param.Byte[3] = ChannelNick;
                                 ToNaviCtrl.Param.Byte[4] = (unsigned char) Poti[0];
                                 ToNaviCtrl.Param.Byte[5] = (unsigned char) Poti[1];
                                 ToNaviCtrl.Param.Byte[6] = (unsigned char) Poti[2];

 /trunk/uart.c
 ,7 → 84,7
 unsigned volatile char NeueKoordinateEmpfangen = 0;
 unsigned volatile char UebertragungAbgeschlossen = 1;
 unsigned volatile char CntCrcError = 0;
-unsigned volatile char AnzahlEmpfangsBytes = 0;
+unsigned volatile char AnzahlEmpfangsBytes = 0;   // achtung: das ist die AscII-Buffer länge, nicht die Nettodatenlänge
 unsigned volatile char TxdBuffer[MAX_SENDE_BUFF];
 unsigned volatile char RxdBuffer[MAX_EMPFANGS_BUFF];
 ,8 → 98,9
 unsigned char MotorTest[16];
 unsigned char MeineSlaveAdresse = 1; // Flight-Ctrl
 unsigned char ConfirmFrame;
+unsigned char ExternalControlTimeout = 0;
 struct str_DebugOut    DebugOut;
-struct str_ExternControl  ExternControl;
+struct str_ExternControl  ExternalControl;
 struct str_VersionInfo VersionInfo;
 struct str_WinkelOut WinkelOut;
 struct str_Data3D Data3D;
 ,9 → 620,12
                                         PcZugriff = 255;
                                         break;
                         case 'b':
-                                        memcpy((unsigned char *)&ExternControl, (unsigned char *)pRxData, sizeof(ExternControl));
-                                        ConfirmFrame = ExternControl.Frame;
-                                        PcZugriff = 255;
+                                        if(AnzahlEmpfangsBytes < 20) // prevents that the old frame is guilty
+                                         {
+                                          memcpy((unsigned char *)&ExternalControl, (unsigned char *)pRxData, sizeof(ExternalControl));
+                                          ConfirmFrame = ExternalControl.Frame;
+                                          ExternalControlTimeout = 100; // 2 seconds timeout
+                                         }
                                         break;
                         case 'c': // Poll the 3D-Data
                     if(!Intervall3D) { if(pRxData[0]) Timer3D = SetDelay(pRxData[0] * 10);}
 ,7 → 793,7
         if(GetExternalControl && UebertragungAbgeschlossen)           // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen
         {
-                SendOutData('G',MeineSlaveAdresse, 1, (unsigned char *) &ExternControl, sizeof(ExternControl));
+                SendOutData('G',MeineSlaveAdresse, 1, (unsigned char *) &ExternalControl, sizeof(ExternalControl));
                 GetExternalControl = 0;
         }
     if(((DebugDataIntervall>0 && CheckDelay(Debug_Timer)) || DebugDataAnforderung) && UebertragungAbgeschlossen)

 /trunk/uart.h
 ,6 → 49,7
 };
 extern struct str_Data3D Data3D;
+/*
 struct str_ExternControl
 {
  unsigned char Digital[2];
 ,7 → 64,26
  unsigned char Config;
 };
 extern struct str_ExternControl   ExternControl;
+*/
+// defines for ExternalControl.Config
+#define EC_VALID                0x01  // only valid if this is 1
+#define EC_GAS_ADD              0x02  // if 1 -> use the GAS Value not as MAX
+#define EC_IGNORE_RC    0x80  // if 1 -> for Flying without RC-Control
+struct str_ExternControl
+{
+ signed char   Nick;
+ signed char   Roll;
+ signed char   Gier;
+ signed char   Gas;
+ unsigned char Frame;   // will return a confirm frame with this value
+ unsigned char Config;
+ unsigned char free;
+};
+extern struct str_ExternControl ExternalControl;
+extern unsigned char ExternalControlTimeout;
 // FC hardware errors
 // bitmask for UART_VersionInfo_t.HardwareError[0]

 /trunk/version.txt
 ,7 → 732,7
 .08a (10.10.2014)
  - Redundance now In Flag3
- - Boat-Moade implemented
+ - Boat-Mode implemented
  - New Gyro DriftCompensation implemented
  - sending Offset values to NC for Logging
  - Menu: Neutral Values of Gyro now in full resolution
 ,6 → 746,10
  - Bugfix: WP-Event was sometimes triggered two times
  - transmit HoverGas to NC for logging
+.09a (10.11.2014)
+ - New data structure of ExternalControl
+ - Internal Copies of the Channel values
 toDo:
 - CalAthmospheare nachführen
 - ExpandBaro kürzer?

Subversion Repositories FlightCtrl

Compare Revisions

Ignore whitespace Rev 2495 → Rev 2496