| /branches/V0.91L_ACC-HH_MartinR/analog.c |
|---|
| 343,7 → 343,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 |
| #if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__)) |
| if(ACC_AltitudeControl) |
| { |
| /branches/V0.91L_ACC-HH_MartinR/eeprom.c |
|---|
| 178,14 → 178,14 |
| EE_Parameter.StartLandChannel = 0; |
| EE_Parameter.LandingSpeed = 12; |
| EE_Parameter.UserParam1 = 0; // zur freien Verwendung |
| EE_Parameter.UserParam2 = 0; // zur freien Verwendung |
| EE_Parameter.UserParam3 = 0; // zur freien Verwendung |
| EE_Parameter.UserParam4 = 0; // zur freien Verwendung |
| EE_Parameter.UserParam5 = 0; // zur freien Verwendung |
| EE_Parameter.UserParam6 = 0; // zur freien Verwendung |
| EE_Parameter.UserParam7 = 0; // zur freien Verwendung |
| EE_Parameter.UserParam8 = 0; // zur freien Verwendung |
| EE_Parameter.UserParam1 = 0; // zur freien Verwendung //MartinR: Umschaltung HH-Mode |
| EE_Parameter.UserParam2 = 40; // zur freien Verwendung //MartinR: I-Faktor im HH-Mode |
| EE_Parameter.UserParam3 = 7; // zur freien Verwendung //MartinR: Stick-P-Wert im HH-Mode |
| EE_Parameter.UserParam4 = 8; // zur freien Verwendung //MartinR: Beschleunigungskompensation des Höhensensors: |
| EE_Parameter.UserParam5 = 0; // zur freien Verwendung // MartinR: |
| EE_Parameter.UserParam6 = 0; // zur freien Verwendung // MartinR: |
| EE_Parameter.UserParam7 = 0; // zur freien Verwendung //MartinR: Abschaltung des Kameraausgleichs: <50: mit Ausgleich, 50..100 nur Rollausgleich (kein Nickausgleich), >100: kein Ausgleich |
| EE_Parameter.UserParam8 = 125; // zur freien Verwendung //MartinR: Pan Servo |
| EE_Parameter.ServoNickControl = 128; // Wert : 0-247 // Stellung des Servos |
| EE_Parameter.ServoNickComp = 50; // Wert : 0-247 // Einfluss Gyro/Servo |
| /branches/V0.91L_ACC-HH_MartinR/fc.c |
|---|
| 114,6 → 114,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; |
| 167,10 → 169,16 |
| unsigned char Parameter_MaximumAltitude; |
| unsigned char Parameter_Servo3,Parameter_Servo4,Parameter_Servo5; |
| 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 |
| //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 // MartinR: so war es |
| const signed char sintab[62] = { 0, 2, 4, 6, 8, 10, 12, 13, 14, 15, 16, 16, 16, 16, 16, 15, 14, 13, 12, 10, 8, 6, 4, 2, 0, -2, -4, -6, -8, -10, -12, -13, -14, -15, -16, -16, -16, -16, -16, -15, -14, -13, -12, -10, -8, -6, -4, -2, 0, 2, 4, 6, 8, 10, 12, 13, 14, 15, 16, 16, 16}; // 7,5° steps //MartinR |
| signed char cosinus, sinus; // MartinR : extern für PAN-Funktion |
| 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 char stick_p; // MartinR: Test |
| unsigned char Parameter_NaviGpsModeControl; // MartinR: |
| unsigned int modell_fliegt = 0; |
| volatile unsigned char FC_StatusFlags = 0, FC_StatusFlags2 = 0; |
| long GIER_GRAD_FAKTOR = 1291; |
| 203,6 → 211,12 |
| DebugOut.Analog[13] = Motor[1].SetPoint; |
| DebugOut.Analog[14] = Motor[2].SetPoint; |
| DebugOut.Analog[15] = Motor[3].SetPoint; |
| DebugOut.Analog[16] = cosinus; // MartinR: zur Einstellung der Pan-Funktion |
| DebugOut.Analog[17] = sinus; // MartinR: test zur Einstellung der Pan-Funktion |
| DebugOut.Analog[18] = ServoPanValue; // MartinR: zur Einstellung der Pan-Funktion |
| DebugOut.Analog[19] = ServoRollValue; // MartinR: Test |
| DebugOut.Analog[20] = ServoNickValue; |
| DebugOut.Analog[21] = HoverGas; |
| DebugOut.Analog[22] = Capacity.ActualCurrent; |
| 472,9 → 486,11 |
| KopplungsteilNickRoll = tmpl3; |
| KopplungsteilRollNick = tmpl4; |
| tmpl4 -= tmpl3; |
| if(IntegralFaktor) // MartinR: nur im ACC-Mode |
| { |
| ErsatzKompass += tmpl4; |
| if(!Parameter_CouplingYawCorrection) Mess_Integral_Gier -= tmpl4/2; // Gier nachhelfen |
| } |
| tmpl = ((MesswertGier + tmpl4) * winkel_nick) / 2048L; |
| tmpl *= Parameter_AchsKopplung1; // 90 |
| tmpl /= 4096L; |
| 528,6 → 544,9 |
| MesswertNick = HiResNick / 8; |
| MesswertRoll = HiResRoll / 8; |
| // 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; } |
| 534,6 → 553,40 |
| 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 |
| #ifdef NO_GYRO_PROGRESSION // MartinR; keine Begrenzung |
| #warning : "### NO_GYRO_PROGRESSION ###" |
| //nichts tun |
| #else // mit Begrenzung |
| // 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 |
| #endif |
| if(Parameter_Gyro_D) |
| { |
| 681,6 → 734,17 |
| CHK_POTI(Parameter_DynamicStability,EE_Parameter.DynamicStability); |
| CHK_POTI(Parameter_ExternalControl,EE_Parameter.ExternalControl); |
| Ki = 10300 / (Parameter_I_Faktor + 1); |
| //Ki = (10300 / (Parameter_I_Faktor + 4)) + (StickGas /2); // MartinR: Test Gasabhängige Regelung |
| if(Parameter_UserParam1 > 50) KiHH = 10300 / (Parameter_UserParam2 + 1); else KiHH = Ki; // MartinR : für HH über Schalter |
| //if(Parameter_UserParam1 > 50) KiHH = (10300 / (Parameter_UserParam2 + 4)) + (StickGas /2); else KiHH = Ki; // MartinR : für HH über Schalter // MartinR: Test Gasabhängige Regelung |
| //Parameter_NaviGpsModeControl = EE_Parameter.NaviGpsModeControl; //MartinR: Standard: EE_Parameter.NaviGpsModeControl wird übertragen |
| Parameter_NaviGpsModeControl = GetChannelValue(EE_Parameter.NaviGpsModeChannel); //MartinR: Standard: EE_Parameter.NaviGpsModeChannel 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; |
| 728,6 → 792,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; |
| 1019,6 → 1086,12 |
| #if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__)) |
| SpeakHoTT = SPEAK_STARTING; |
| #endif |
| // MartinR: hinzugefügt Anfang |
| stick_nick_neutral = PPM_in[EE_Parameter.Kanalbelegung[K_NICK]]; // aktueller Stickwert wird als Neutralposition im HH verwendet, MartinR |
| stick_roll_neutral = PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]]; // aktueller Stickwert wird als Neutralposition im HH verwendet, MartinR |
| SummeNickHH = 0 ; // Zurücksetzen der Integratoren |
| SummeRollHH = 0 ; // Zurücksetzen der Integratoren |
| // MartinR: hinzugefügt Ende |
| } |
| else |
| { |
| 1093,15 → 1166,46 |
| unsigned char stick_p; |
| ParameterZuordnung(); |
| stick_p = EE_Parameter.Stick_P; |
| // MartinR: original: |
| /* |
| stick_nick = (stick_nick * 3 + PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] * 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]] * stick_p) / 4; |
| stick_roll += PPM_diff[EE_Parameter.Kanalbelegung[K_ROLL]] * EE_Parameter.Stick_D; |
| */ |
| // MartinR: geändert Anfang |
| if(IntegralFaktor) // ACC-Mode |
| { |
| stick_nick = (stick_nick * 3 + PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] * stick_p) / 4; |
| stick_roll = (stick_roll * 3 + PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] * stick_p) / 4; |
| stick_nick_neutral = PPM_in[EE_Parameter.Kanalbelegung[K_NICK]]; // beim Umschalten auf HH wird derletzte Stickwert als Neutralposition verwendet, MartinR |
| stick_roll_neutral = PPM_in[EE_Parameter.Kanalbelegung[K_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; |
| } |
| else // HH-Mode |
| { |
| if(Parameter_UserParam1 > 49) // MartinR: zweiter Stick_P Wert nur, wenn HH über Schalter aktiv ist |
| { |
| stick_nick = ((PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] - stick_nick_neutral) * Parameter_UserParam3); |
| stick_roll = ((PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] - stick_roll_neutral) * Parameter_UserParam3); |
| } |
| else |
| { |
| stick_nick = ((PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] - stick_nick_neutral) * stick_p); |
| stick_roll = ((PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] - stick_roll_neutral) * stick_p); |
| } |
| } |
| // MartinR: geändert Ende |
| // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // CareFree und freie Wahl der vorderen Richtung |
| // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| if(CareFree) |
| //if(CareFree) // MartinR: so war es |
| if(CareFree && IntegralFaktor) // MartinR: CareFree nur im ACC-Mode |
| { |
| signed int nick, roll; |
| nick = stick_nick / 4; |
| 1111,8 → 1215,10 |
| } |
| else |
| { |
| FromNC_Rotate_C = sintab[EE_Parameter.OrientationAngle + 6]; |
| FromNC_Rotate_S = sintab[EE_Parameter.OrientationAngle]; |
| //FromNC_Rotate_C = sintab[EE_Parameter.OrientationAngle + 6]; //MartinR: so war es |
| FromNC_Rotate_C = (sintab[EE_Parameter.OrientationAngle * 2 + 12]) / 2; //MartinR: feinere Auflösung |
| //FromNC_Rotate_S = sintab[EE_Parameter.OrientationAngle]; //MartinR: so war es |
| FromNC_Rotate_S = (sintab[EE_Parameter.OrientationAngle * 2]) / 2; //MartinR: feinere Auflösung |
| StickNick = ((FromNC_Rotate_C * stick_nick) + (FromNC_Rotate_S * stick_roll)) / 8; |
| StickRoll = ((FromNC_Rotate_C * stick_roll) - (FromNC_Rotate_S * stick_nick)) / 8; |
| } |
| 1132,7 → 1238,7 |
| StickGas = PPM_in[EE_Parameter.Kanalbelegung[K_GAS]] + 127; |
| GyroFaktor = (Parameter_Gyro_P + 10.0); |
| IntegralFaktor = Parameter_Gyro_I; |
| // IntegralFaktor = Parameter_Gyro_I; // MartinR: war mal hier |
| GyroFaktorGier = (Parameter_Gyro_Gier_P + 10.0); |
| IntegralFaktorGier = Parameter_Gyro_Gier_I; |
| 1249,7 → 1355,27 |
| MittelIntegralNick2 += IntegralNick2; |
| MittelIntegralRoll2 += IntegralRoll2; |
| if(Looping_Nick || Looping_Roll) |
| 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: Reset der Integratoren beim Zurückschalten vom HH- in den ACC-Mode |
| IntegralRoll = 0; // MartinR: Reset der Integratoren beim Zurückschalten vom HH- in den ACC-Mode |
| Mess_IntegralNick = 0; // MartinR: Reset der Integratoren beim Zurückschalten vom HH- in den ACC-Mode |
| Mess_IntegralRoll = 0; // MartinR: Reset der Integratoren beim Zurückschalten vom HH- in den ACC-Mode |
| Mess_Integral_Gier = 0; // MartinR: Reset der Integratoren beim Zurückschalten vom HH- in den ACC-Mode |
| sollGier = 0; |
| Integral_Gier = 0; // MartinR: Reset der Integratoren beim Zurückschalten vom HH- in den ACC-Mode |
| //Mess_Integral_Gier2 = 0; // MartinR: Reset der Integratoren beim Zurückschalten vom HH- in den ACC-Mode |
| KompassSollWert = KompassValue; // MartinR: aktuelle Ausrichtung beibehalten |
| ErsatzKompass = KompassValue * GIER_GRAD_FAKTOR; // MartinR: aktuelle Ausrichtung beibehalten |
| NeueKompassRichtungMerken = 1; // MartinR: aktuelle Ausrichtung beibehalten |
| } |
| // 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 |
| // MartinR: beim ACC-Loop oder beim zurückschalten von HH auf ACC |
| { |
| IntegralAccNick = 0; |
| IntegralAccRoll = 0; |
| 1263,6 → 1389,9 |
| LageKorrekturNick = 0; |
| LageKorrekturRoll = 0; |
| } |
| if((EE_Parameter.GlobalConfig & CFG_HEADING_HOLD) || (Parameter_UserParam1 > 49)) IntegralFaktor = 0; // MartinR geändert und verschoben |
| else IntegralFaktor = Parameter_Gyro_I; // MartinR: geändert |
| // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| if(!Looping_Nick && !Looping_Roll && (Aktuell_az > 512 || MotorenEin)) |
| 1317,7 → 1446,9 |
| 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 |
| { |
| MittelIntegralNick /= ABGLEICH_ANZAHL; |
| MittelIntegralRoll /= ABGLEICH_ANZAHL; |
| 1485,7 → 1616,8 |
| // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // Kompass |
| // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| if(KompassValue >= 0 && (Parameter_GlobalConfig & CFG_KOMPASS_AKTIV)) |
| //if(KompassValue >= 0 && (Parameter_GlobalConfig & CFG_KOMPASS_AKTIV)) // MartinR: so war es |
| if((KompassValue >= 0 && (Parameter_GlobalConfig & CFG_KOMPASS_AKTIV)) && !(Parameter_UserParam1 > 50)) // MartinR: bei HH über Schalter wird der Kompass abgeschaltet |
| { |
| if(CalculateCompassTimer-- == 1) |
| { |
| 1542,8 → 1674,23 |
| 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: nur Kompass wird bei HH deaktiviert |
| //Integral_Gier = 0; // MartinR: nur Kompass wird bei HH deaktiviert |
| } |
| 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)); |
| // Maximalwerte abfangen |
| 1560,6 → 1707,10 |
| // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| if(UBat > BattLowVoltageWarning) GasMischanteil = ((unsigned int)GasMischanteil * BattLowVoltageWarning) / UBat; // Gas auf das aktuelle Spannungvieveau beziehen |
| GasMischanteil *= STICK_GAIN; |
| //MartinR: Höhenregler nur mit 1284er Prozessor: |
| #if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__)) |
| // if height control is activated |
| if((Parameter_GlobalConfig & CFG_HOEHENREGELUNG) && !(Looping_Roll || Looping_Nick) && !(VersionInfo.HardwareError[0] & 0x7F)) // Höhenregelung |
| { |
| 1633,7 → 1784,8 |
| // if height control is activated by an rc channel |
| if(Parameter_GlobalConfig & CFG_HOEHEN_SCHALTER) // Regler wird über Schalter gesteuert |
| { // check if parameter is less than activation threshold |
| if(Parameter_HoehenSchalter < 50) // for 3 or 2-state switch height control is disabled in lowest position |
| // if(Parameter_HoehenSchalter < 50) // for 3 or 2-state switch height control is disabled in lowest position // MartinR :so war es |
| if((Parameter_HoehenSchalter < 50) || (Parameter_UserParam1 > 140) ) // MartinR: Schalter aus oder HH ohne Höhenregler über UsererParam1 an |
| { //height control not active |
| if(!delay--) |
| { |
| 1658,7 → 1810,17 |
| else // no switchable height control |
| { |
| SollHoehe = ((int16_t) ExternHoehenValue + (int16_t) Parameter_HoehenSchalter) * (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 |
| tmp_int = (int)(IntegralNick/GIER_GRAD_FAKTOR); // nick angle in deg |
| 2018,6 → 2180,9 |
| FC_StatusFlags |= (FC_STATUS_VARIO_TRIM_UP|FC_STATUS_VARIO_TRIM_DOWN); |
| } // EOF no height control |
| // MartinR: Höhenregler nur noch mit 1284er Prozessor |
| #endif |
| // Limits the maximum gas in case of "Out of Range emergency landing" |
| if(NC_To_FC_Flags & NC_TO_FC_EMERGENCY_LANDING) |
| { |
| 2061,7 → 2226,69 |
| 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 |
| // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| 2096,6 → 2323,9 |
| if(pd_ergebnis_roll > tmp_int) pd_ergebnis_roll = tmp_int; |
| if(pd_ergebnis_roll < -tmp_int) pd_ergebnis_roll = -tmp_int; |
| */ |
| // MartinR: alt Ende |
| // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // Universal Mixer |
| // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| /branches/V0.91L_ACC-HH_MartinR/fc.h |
|---|
| 144,7 → 144,9 |
| extern unsigned char Parameter_J17Timing; // for the J17 Output |
| extern unsigned char Parameter_GlobalConfig; |
| extern unsigned char Parameter_ExtraConfig; |
| 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]; |
| //extern const signed char sintab[31]; // MartinR: so war es |
| extern const signed char sintab[62]; // MartinR: für feinere Auflösung |
| #endif //_FC_H |
| /branches/V0.91L_ACC-HH_MartinR/jetimenu.c |
|---|
| 68,6 → 68,8 |
| #define JetiBox_printfxy(x,y,format, args...) { LIBFC_JetiBox_SetPos(y * 16 + x); _printf_P(&LIBFC_JetiBox_Putchar, PSTR(format) , ## args);} |
| #define JetiBox_printf(format, args...) { _printf_P(&LIBFC_JetiBox_Putchar, PSTR(format) , ## args);} |
| #define LIMIT_MIN_MAX(value, min, max) {if(value <= min) value = min; else if(value >= max) value = max;} //MartinR |
| // ----------------------------------------------------------- |
| // the menu functions |
| // ----------------------------------------------------------- |
| 188,6 → 190,29 |
| } |
| // MartinR für Jeti+ Anfang |
| void Menu_spoti1(uint8_t key) |
| { //0123456789ABCDEF |
| JetiBox_printfxy(0,0,">%3i=Serialpot1",(PPM_in[13] + 127)); |
| //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; |
| LIMIT_MIN_MAX(PPM_in[13], -127, 128); // MartinR: Begrenzung |
| } |
| 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] + 127)); |
| if(key== JETIBOX_KEY_UP) PPM_in[14] = PPM_in[14]+2; |
| if(key== JETIBOX_KEY_DOWN) PPM_in[14] = PPM_in[14]-2; |
| LIMIT_MIN_MAX(PPM_in[14], -127, 128); // MartinR: Begrenzung |
| } |
| // MartinR für Jeti+ Ende |
| // ----------------------------------------------------------- |
| // the menu topology |
| // ----------------------------------------------------------- |
| 212,11 → 237,17 |
| const MENU_ENTRY JetiBox_Menu[] PROGMEM= |
| { // l r u d pHandler |
| #if !defined (RECEIVER_SPEKTRUM_DX7EXP) && !defined (RECEIVER_SPEKTRUM_DX8EXP) |
| {4, 1, 0, 0, &Menu_Status }, // 0 |
| //{4, 1, 0, 0, &Menu_Status }, // 0 // MartinR: so war es |
| {6, 1, 0, 0, &Menu_Status }, // 0 // MartinR: geändert |
| {0, 2, 1, 1, &Menu_Temperature }, // 1 |
| {1, 3, 2, 2, &Menu_Battery }, // 2 |
| {2, 4, 3, 3, &Menu_PosInfo }, // 3 |
| {3, 0, 4, 4, &Magnet_Values } // 4 |
| //{3, 0, 4, 4, &Magnet_Values } // 4 // MartinR: so war es |
| {3, 5, 4, 4, &Magnet_Values }, // 4 // MartinR: geändert |
| {4, 6, 5, 5, &Menu_spoti1 }, // 5 // MartinR: für Jeti+ |
| {5, 0, 6, 6, &Menu_spoti2 }, // 6 // MartinR: für Jeti+ |
| #endif |
| }; |
| /branches/V0.91L_ACC-HH_MartinR/makefile |
|---|
| 11,6 → 11,7 |
| VERSION_SERIAL_MINOR = 0 # Serial Protocol |
| NC_SPI_COMPATIBLE = 55 # Navi-Kompatibilität |
| LIB_FC_COMPATIBLE = 3 # Library |
| MOD = ACC-HH_MartinR |
| #------------------------------------------------------------------- |
| # ATMEGA644: 63487 is maximum |
| #------------------------------------------------------------------- |
| 58,82 → 59,82 |
| # 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)_$(MOD) |
| endif |
| ifeq ($(VERSION_PATCH), 1) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)b_SVN$(REV) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)b_SVN$(REV)_$(MOD) |
| endif |
| ifeq ($(VERSION_PATCH), 2) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)c_SVN$(REV) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)c_SVN$(REV)_$(MOD) |
| endif |
| ifeq ($(VERSION_PATCH), 3) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)d_SVN$(REV) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)d_SVN$(REV)_$(MOD) |
| endif |
| ifeq ($(VERSION_PATCH), 4) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)e_SVN$(REV) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)e_SVN$(REV)_$(MOD) |
| endif |
| ifeq ($(VERSION_PATCH), 5) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)f_SVN$(REV) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)f_SVN$(REV)_$(MOD) |
| endif |
| ifeq ($(VERSION_PATCH), 6) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)g_SVN$(REV) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)g_SVN$(REV)_$(MOD) |
| endif |
| ifeq ($(VERSION_PATCH), 7) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)h_SVN$(REV) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)h_SVN$(REV)_$(MOD) |
| endif |
| ifeq ($(VERSION_PATCH), 8) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)i_SVN$(REV) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)i_SVN$(REV)_$(MOD) |
| endif |
| ifeq ($(VERSION_PATCH), 9) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)j_SVN$(REV) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)j_SVN$(REV)_$(MOD) |
| endif |
| ifeq ($(VERSION_PATCH), 10) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)k_SVN$(REV) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)k_SVN$(REV)_$(MOD) |
| endif |
| ifeq ($(VERSION_PATCH), 11) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)L_SVN$(REV) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)L_SVN$(REV)_$(MOD) |
| endif |
| ifeq ($(VERSION_PATCH), 12) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)m_SVN$(REV) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)m_SVN$(REV)_$(MOD) |
| endif |
| ifeq ($(VERSION_PATCH), 13) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)n_SVN$(REV) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)n_SVN$(REV)_$(MOD) |
| endif |
| ifeq ($(VERSION_PATCH), 14) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)o_SVN$(REV) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)o_SVN$(REV)_$(MOD) |
| endif |
| ifeq ($(VERSION_PATCH), 15) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)p_SVN$(REV) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)p_SVN$(REV)_$(MOD) |
| endif |
| ifeq ($(VERSION_PATCH), 16) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)q_SVN$(REV) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)q_SVN$(REV)_$(MOD) |
| endif |
| ifeq ($(VERSION_PATCH), 17) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)r_SVN$(REV) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)r_SVN$(REV)_$(MOD) |
| endif |
| ifeq ($(VERSION_PATCH), 18) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)s_SVN$(REV) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)s_SVN$(REV)_$(MOD) |
| endif |
| ifeq ($(VERSION_PATCH), 19) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)t_SVN$(REV) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)t_SVN$(REV)_$(MOD) |
| endif |
| ifeq ($(VERSION_PATCH), 20) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)u_SVN$(REV) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)u_SVN$(REV)_$(MOD) |
| endif |
| ifeq ($(VERSION_PATCH), 21) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)v_SVN$(REV) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)v_SVN$(REV)_$(MOD) |
| endif |
| ifeq ($(VERSION_PATCH), 22) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)w_SVN$(REV) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)w_SVN$(REV)_$(MOD) |
| endif |
| ifeq ($(VERSION_PATCH), 23) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)x_SVN$(REV) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)x_SVN$(REV)_$(MOD) |
| endif |
| ifeq ($(VERSION_PATCH), 24) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)y_SVN$(REV) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)y_SVN$(REV)_$(MOD) |
| endif |
| ifeq ($(VERSION_PATCH), 25) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)z_SVN$(REV) |
| TARGET = Flight-Ctrl_$(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)z_SVN$(REV)_$(MOD) |
| endif |
| /branches/V0.91L_ACC-HH_MartinR/rc.c |
|---|
| 72,7 → 72,8 |
| unsigned char i; |
| for(i=0;i<MAX_RC_IN;i++) |
| { |
| if(i < 5) PPM_in[i] = 0; else PPM_in[i] = -127; |
| //if(i < 5) PPM_in[i] = 0; else PPM_in[i] = -127; // MartinR: so war es |
| if((i < 5)||((i>16) & (i<25))) PPM_in[i] = 0; else PPM_in[i] = -127; // MartinR: Initialisierung der seriellen Kanäle auf 0 |
| PPM_diff[i] = 0; |
| } |
| PPM_in[PPM_IN_MAX] = +127; |
| /branches/V0.91L_ACC-HH_MartinR/spi.c |
|---|
| 180,7 → 180,8 |
| ToNaviCtrl.Param.Int[0] = Capacity.ActualCurrent; // 0.1A |
| ToNaviCtrl.Param.Int[1] = Capacity.UsedCapacity; // mAh |
| ToNaviCtrl.Param.Byte[4] = (unsigned char) UBat; // 0.1V |
| ToNaviCtrl.Param.Byte[5] = GetChannelValue(EE_Parameter.NaviGpsModeChannel); // GPS-Mode control |
| //ToNaviCtrl.Param.Byte[5] = GetChannelValue(EE_Parameter.NaviGpsModeChannel); // GPS-Mode control // MartinR: so war es |
| ToNaviCtrl.Param.Byte[5] = Parameter_NaviGpsModeControl; // MartinR: wird wiederverwendet für GPS free bei HH |
| ToNaviCtrl.Param.Byte[6] = VarioCharacter; |
| ToNaviCtrl.Param.Byte[7] = motorindex; |
| ToNaviCtrl.Param.Byte[8] = Motor[motorindex].MaxPWM; |
| /branches/V0.91L_ACC-HH_MartinR/timer0.c |
|---|
| 64,6 → 64,7 |
| uint16_t RemainingPulse = 0; |
| volatile int16_t ServoNickOffset = (255 / 2) * MULTIPLYER * 16; // initial value near center positon |
| volatile int16_t ServoRollOffset = (255 / 2) * MULTIPLYER * 16; // initial value near center positon |
| volatile int16_t ServoPanOffset = (255 / 2) * MULTIPLYER * 16; // MartinR: für Pan-Funktion |
| unsigned int BeepMuster = 0xffff; |
| signed int NickServoValue = 128 * MULTIPLYER * 16; |
| 70,6 → 71,7 |
| volatile int16_t ServoNickValue = 0; |
| volatile int16_t ServoRollValue = 0; |
| volatile int16_t ServoPanValue = 0; // MartinR : für PAN-Funktion |
| enum { |
| 263,16 → 265,36 |
| void CalculateServo(void) |
| { |
| signed char cosinus, sinus; |
| //signed char cosinus, sinus; // MartinR : so war es |
| extern signed char cosinus, sinus; // MartinR : extern für PAN-Funktion |
| signed long nick, roll; |
| cosinus = sintab[EE_Parameter.CamOrientation + 6]; |
| sinus = sintab[EE_Parameter.CamOrientation]; |
| nick = 0; // MartinR : StartWert bei abgeschalteten Nick/ Roll ausgleich |
| roll = 0; // MartinR : StartWert bei abgeschalteten Nick/ Roll ausgleich |
| int tmp; // MartinR : für PAN-Funktion // Wert : 0-24 -> 0-360 -> 15° steps |
| /* // MartinR: bisher |
| tmp = EE_Parameter.CamOrientation + ((Parameter_Servo4 - 125) * (Parameter_UserParam8 - 125)) / 400 ; //MartinR : für PAN-Funktion |
| if (tmp < 0) tmp = 24- (abs(tmp)) % 24 ; // MartinR :Modulo 24 |
| else tmp = tmp % 24 ; // MartinR :Modulo 24 |
| */ |
| tmp = EE_Parameter.CamOrientation + ((Parameter_Servo4 - 125) * (Parameter_UserParam8 - 125)) / 200 ; //MartinR : für PAN-Funktion |
| if (tmp < 0) tmp = 48- (abs(tmp)) % 48 ; // MartinR :Modulo 48 |
| else tmp = tmp % 48 ; // MartinR :Modulo 48 |
| // cosinus = sintab[EE_Parameter.CamOrientation + 6]; // MartinR : so war es |
| // sinus = sintab[EE_Parameter.CamOrientation]; // MartinR : so war es |
| //cosinus = sintab[tmp + 6]; // MartinR : für PAN-Funktion |
| cosinus += (2*sintab[tmp + 12]- cosinus + 1) / 2; // MartinR : für PAN-Funktion |
| sinus += (2*sintab[tmp] - sinus + 1) / 2; // MartinR : für PAN-Funktion |
| if(CalculateServoSignals == 1) |
| { |
| nick = (cosinus * IntegralNick) / 128L - (sinus * IntegralRoll) / 128L; |
| if (Parameter_UserParam7 < 50) // MartinR: um per UserParameter den Nickausgleich abzuschalten |
| { |
| //nick = (cosinus * IntegralNick) / 128L - (sinus * IntegralRoll) / 128L; // MartinR: so war es |
| nick = (cosinus * IntegralNick) / 512L - (sinus * IntegralRoll) / 512L; // MartinR: bessere Auflösung |
| nick -= POI_KameraNick * 7; |
| } |
| nick = ((long)Parameter_ServoNickComp * nick) / 512L; |
| // offset (Range from 0 to 255 * 3 = 765) |
| if(EE_Parameter.ServoCompInvert & SERVO_RELATIVE) ServoNickOffset = NickServoValue; |
| 302,7 → 324,11 |
| } |
| else |
| { |
| roll = (cosinus * IntegralRoll) / 128L + (sinus * IntegralNick) / 128L; |
| if (Parameter_UserParam7 < 100) // MartinR: um per UserParameter den Nickausgleich abzuschalten |
| { |
| //roll = (cosinus * IntegralRoll) / 128L + (sinus * IntegralNick) / 128L; // MartinR: so war es |
| roll = (cosinus * IntegralRoll) / 512L + (sinus * IntegralNick) / 512L; // MartinR: bessere Auflösung |
| } |
| roll = ((long)Parameter_ServoRollComp * roll) / 512L; |
| ServoRollOffset += ((int16_t)Parameter_ServoRollControl * (MULTIPLYER*16) - ServoRollOffset) / EE_Parameter.ServoManualControlSpeed; |
| if(EE_Parameter.ServoCompInvert & SERVO_ROLL_INV) |
| 325,6 → 351,11 |
| { |
| ServoRollValue = (int16_t)EE_Parameter.ServoRollMax * MULTIPLYER; |
| } |
| // MartinR: Filterung der Pan- Funktion |
| ServoPanOffset += ((int16_t)Parameter_Servo4 * (MULTIPLYER*16) - ServoPanOffset) / EE_Parameter.ServoManualControlSpeed; |
| ServoPanValue = (int16_t)ServoPanOffset/16; // offset (Range from 0 to 255 * 3 = 765) |
| CalculateServoSignals = 0; |
| } |
| } |
| 413,7 → 444,8 |
| RemainingPulse += ((int16_t)Parameter_Servo3 * MULTIPLYER) - (256 / 2) * MULTIPLYER; |
| break; |
| case 4: |
| RemainingPulse += ((int16_t)Parameter_Servo4 * MULTIPLYER) - (256 / 2) * MULTIPLYER; |
| //RemainingPulse += ((int16_t)Parameter_Servo4 * MULTIPLYER) - (256 / 2) * MULTIPLYER; // MartinR: so war es |
| RemainingPulse += ServoPanValue - (256 / 2) * MULTIPLYER; // MartinR: zur Filterung der Pan-Funktion |
| break; |
| case 5: |
| RemainingPulse += ((int16_t)Parameter_Servo5 * MULTIPLYER) - (256 / 2) * MULTIPLYER; |
| /branches/V0.91L_ACC-HH_MartinR/timer0.h |
|---|
| 23,3 → 23,5 |
| extern volatile int16_t ServoRollValue; |
| extern signed int NickServoValue; |
| extern unsigned char JustMK3MagConnected; |
| extern volatile int16_t ServoPanValue; // MartinR : für PAN-Funktion |
| extern signed char cosinus, sinus; // MartinR : extern für PAN-Funktion |
| /branches/V0.91L_ACC-HH_MartinR/uart.c |
|---|
| 128,11 → 128,11 |
| "Motor 2 ", |
| "Motor 3 ", |
| "Motor 4 ", //15 |
| "16 ", |
| "17 ", |
| "18 ", |
| "19 ", |
| "Servo ", //20 |
| "PAN-Cos ",//MartinR |
| "PAN-Sin ",//MartinR |
| "PAN-Servo ",//MartinR |
| "Servo-Roll ",//MartinR |
| "Servo-Nick ", //20 |
| "Hovergas ", |
| "Current [0.1A] ", |
| "Capacity [mAh] ", |
| 772,8 → 772,10 |
| { |
| WinkelOut.Winkel[0] = (int) (IntegralNick / (EE_Parameter.GyroAccFaktor * 4)); // etwa in 0.1 Grad |
| WinkelOut.Winkel[1] = (int) (IntegralRoll / (EE_Parameter.GyroAccFaktor * 4)); // etwa in 0.1 Grad |
| WinkelOut.UserParameter[0] = Parameter_UserParam1; |
| WinkelOut.UserParameter[1] = Parameter_UserParam2; |
| //WinkelOut.UserParameter[0] = Parameter_UserParam1;//MartinR: so war es |
| //WinkelOut.UserParameter[1] = Parameter_UserParam2; |
| WinkelOut.UserParameter[0] = 0; // Martin R: deaktiviert,da userParameter amnderweitig verwendet |
| WinkelOut.UserParameter[1] = 0; |
| SendOutData('k', MK3MAG_ADDRESS, 1, (unsigned char *) &WinkelOut,sizeof(WinkelOut)); |
| if(WinkelOut.CalcState > 4) WinkelOut.CalcState = 6; // wird dann in SPI auf Null gesetzt |
| if(!NaviDataOkay) Kompass_Timer = SetDelay(99); |
| /branches/V0.91L_ACC-HH_MartinR/version.txt |
|---|
| 613,4 → 613,94 |
| // 30 Fix -> -127 |
| // 31 Fix -> 0 |
| // 32 Fix -> 128 |
| 0.90_ACC-HH_MartinR 30.05.2013: |
| Änderungen in: fc.c, fc.h, spi.c, analog.c, jetimenue.c, timer0.c, eeprom.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, 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 |
| - UserParameter8: für Pan Funktion (siehe unten), hier zunächst 125 eintragen, |
| damit es keine Probleme mit dem Kamera-Nickausgleich gibt |
| - 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ß) |
| weitere Änderungen: |
| - in der analog.c wurde das Nachführen von "NeutralAccZ" deaktiviert |
| - 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: |
| es gibt 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. |
| 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) |
| Die Pan-Funktion ist fest dem Servoausgang 4 zugeordnet |
| Im MK-Tool legst du ganz normal fest, welcher Sender-Kanal dem Servo 4 (Pan) zugeordnet wird. |
| über UserParameter 8 musst Du die Verstärkung und Richtung festlegen: 125= 0, 126=+1, 124=-1.... |
| Vorgehensweise: |
| 1. die Pan- Funktion auf Servo 4 einstecken |
| 2. den Senderkanal für Pan auf Servo 4 legen |
| 3. zunächst UserParameter 8 auf 125 einstellen |
| 4. die Pan-Funktion mechanisch so ausrichten, dass bei Pan-Neutral-Stellung des Senders die Kamera nach vorne zeigt. Dann den Nick und Rollausgleich einstellen / prüfen |
| 5. im MK-Tool auf Flight-Ctrl gehen und die Werte unter 16 und 17 (die zwei Werte nach den Motoren) beobachten |
| 6. im MK-Tool sollte nun bei [16]: 32 und bei [17]: 0 erscheinen |
| 7. die Kamera über den Sender um 90° nach rechts schwenken |
| 8. UserParameter 8 nun so einstellen (langsam erhöhen oder verringern), dass bei [16]: 0 und bei [17]: 32 erscheint |
| 9. Nick- und Rollausgleich beobachten |
| 10. Kamera um 90° nach links schwenken und wieder Nick- und Rollausgleich beobachten |
| Das sind die Sollwerte, die Du über die Einstellung von UserParameter 8 und der Kameraausrichtung im MK-Tool erreichen musst: |
| Kamerarichtung Kanal 16 / 17 (im MK-Tool) |
| 0 32 / 0 |
| 45 links 24 / -24 |
| 90 links 0 / -32 |
| 135 links -24 / -24 |
| 180 -32 / 0 |
| 45 rechts 24 / 24 |
| 90 rechts 0 / 32 |
| 135 rechts -24 / 24 |
| 180 -32 / 0 |
| Abhängig von der Linearität des Pan-Servos wird man diese Werte nicht immer genau erreichen. |
| Dann so gut wie möglich ausmitteln. |