| /branches/V0.88e_ACC-HH_HR_MartinR/Spektrum.c |
|---|
| 6,6 → 6,10 |
| #include "main.h" |
| // Achtung: RECEIVER_SPEKTRUM_DX7EXP oder RECEIVER_SPEKTRUM_DX8EXP wird in der Main.h gesetzt |
| #ifndef WITHSPECTRUM /// MartinW |
| #warning : "### without SPECTRUM Code ###" |
| #endif |
| unsigned char SpektrumTimer = 0; |
| #if defined (RECEIVER_SPEKTRUM_DX7EXP) || defined (RECEIVER_SPEKTRUM_DX8EXP) |
| 75,6 → 79,9 |
| void SpektrumUartInit(void) |
| //############################################################################ |
| { |
| #ifdef WITHSPECTRUM /// MartinW main.h means no memsave |
| #warning : "### with left over Spectrum code ###" |
| // -- Start of USART1 initialisation for Spekturm seriell-mode |
| // USART1 Control and Status Register A, B, C and baud rate register |
| uint8_t sreg = SREG; |
| 128,6 → 135,7 |
| // restore global interrupt flags |
| SREG = sreg; |
| #endif |
| return; |
| } |
| 210,6 → 218,9 |
| //############################################################################ |
| void SpektrumParser(unsigned char c) |
| { |
| #ifdef WITHSPECTRUM /// MartinW main.h means no memsave |
| #warning : "### with left over Spectrum code ###" |
| static unsigned char Sync=0, FrameCnt=0, ByteHigh=0, ReSync=1, Frame2=0; |
| unsigned int Channel, index = 0; |
| signed int signal = 0, tmp; |
| 451,5 → 462,6 |
| SpektrumTimer = MIN_FRAMEGAP; |
| } |
| } |
| #endif |
| } |
| /branches/V0.88e_ACC-HH_HR_MartinR/analog.c |
|---|
| 58,6 → 58,7 |
| volatile int HiResNick = 2500, HiResRoll = 2500; |
| volatile int AdWertNick = 0, AdWertRoll = 0, AdWertGier = 0; |
| volatile int AdWertAccRoll = 0,AdWertAccNick = 0,AdWertAccHoch = 0; |
| //volatile char messanzahl_AccHoch = 0; // MartinR |
| volatile long Luftdruck = 32000; |
| volatile long SummenHoehe = 0; |
| volatile int StartLuftdruck; |
| 185,7 → 186,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; |
| 232,6 → 233,9 |
| break; |
| case 8: |
| AdWertAccHoch = (signed int) ADC - NeutralAccZ; |
| /* // MartinR: deaktivieren Anfang |
| if(AdWertAccHoch > 1) |
| { |
| if(NeutralAccZ < 750) |
| 250,7 → 254,10 |
| if(subcount < -100) { NeutralAccZ--; subcount += 100;} |
| } |
| } |
| // messanzahl_AccHoch = 1; |
| */ // MartinR: deaktivieren Ende |
| //messanzahl_AccHoch = 1; |
| Aktuell_az = ADC; |
| Mess_Integral_Hoch += AdWertAccHoch; // Integrieren |
| Mess_Integral_Hoch -= Mess_Integral_Hoch / 1024; // dämfen |
| 287,7 → 294,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; |
| 296,7 → 305,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; |
| 306,7 → 317,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 >= 16) // war bis 0.86 "18" |
| { |
| /branches/V0.88e_ACC-HH_HR_MartinR/capacity.c |
|---|
| 72,6 → 72,11 |
| Capacity.UsedCapacity = 0; |
| Capacity.ActualPower = 0; |
| Capacity.MinOfMaxPWM = 0; |
| #ifdef WITH_REMAINCAPACITY // only include functions if DEBUG is defined in main.h |
| #warning : "### with REMAIN CAPACITY ###" |
| Capacity.RemainCapacity = (Parameter_UserParam5*100); |
| #endif |
| update_timer = SetDelay(CAPACITY_UPDATE_INTERVAL); |
| } |
| 139,6 → 144,14 |
| { |
| Capacity.UsedCapacity++; // we have one mAh more |
| SubCounter -= SUB_COUNTER_LIMIT; // keep the remaining sub part |
| #ifdef WITH_REMAINCAPACITY // only include functions if DEBUG is defined in main.h |
| #warning : "### with REMAIN CAPACITY ###" |
| Capacity.RemainCapacity=(Parameter_UserParam5*100)-Capacity.UsedCapacity; //Added by metro |
| if((Capacity.RemainCapacity<=0)&&(Capacity.RemainCapacity%10==0)&&(Parameter_UserParam5!=0)) beeptime = 1000; |
| if((Capacity.RemainCapacity<=500)&&(Capacity.RemainCapacity%100==0)&&(Parameter_UserParam5!=0)) beeptime = 10000; |
| #endif |
| } |
| } // EOF check delay update timer |
| } |
| /branches/V0.88e_ACC-HH_HR_MartinR/capacity.h |
|---|
| 5,7 → 5,8 |
| { |
| unsigned short ActualCurrent; // in 0.1A Steps |
| unsigned short ActualPower; // in 0.1W |
| unsigned short UsedCapacity; // in mAh |
| signed short UsedCapacity; // in mAh //Modified by metro |
| signed short RemainCapacity; // in mAh //Added by metro |
| unsigned char MinOfMaxPWM; // BL Power Limit |
| } __attribute__((packed)) Capacity_t; |
| /branches/V0.88e_ACC-HH_HR_MartinR/eeprom.c |
|---|
| 150,22 → 150,22 |
| EE_Parameter.Hoehe_MinGas = 30; |
| EE_Parameter.MaxHoehe = 255; // Wert : 0-247 255 -> Poti1 |
| EE_Parameter.Hoehe_P = 15; // Wert : 0-32 |
| EE_Parameter.Luftdruck_D = 30; // Wert : 0-247 |
| EE_Parameter.Hoehe_ACC_Wirkung = 0; // Wert : 0-247 |
| EE_Parameter.Hoehe_P = 16; // Wert : 0-32 // MartinR: angepast |
| EE_Parameter.Luftdruck_D = 32; // Wert : 0-247 // MartinR: angepast |
| EE_Parameter.Hoehe_ACC_Wirkung = 0; // Wert : 0-247 // MartinR: angepast |
| EE_Parameter.Hoehe_HoverBand = 8; // Wert : 0-247 |
| EE_Parameter.Hoehe_GPS_Z = 20; // Wert : 0-247 |
| EE_Parameter.Hoehe_StickNeutralPoint = 0;// Wert : 0-247 (0 = Hover-Estimation) |
| EE_Parameter.Hoehe_Verstaerkung = 15; // Wert : 0-50 (15 -> ca. +/- 5m/sek bei Stick-Voll-Ausschlag) |
| 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 |
| 370,7 → 370,8 |
| // read paramset from eeprom |
| eeprom_read_block((void *) &EE_Parameter, (void*)(EEPROM_ADR_PARAMSET + PARAMSET_STRUCT_LEN * (setnumber - 1)), PARAMSET_STRUCT_LEN); |
| LED_Init(); |
| #if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__)) |
| #if ((defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__)) && defined(WITH_HOTTMENU)) |
| #warning : "### with Hottmenu ###" |
| LIBFC_HoTT_Clear(); |
| #endif |
| return 1; |
| 409,7 → 410,8 |
| // update active settings number |
| SetActiveParamSet(setnumber); |
| LED_Init(); |
| #if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__)) |
| #if ((defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__)) && defined(WITH_HOTTMENU)) |
| #warning : "### with Hottmenu ###" |
| LIBFC_HoTT_Clear(); |
| #endif |
| return 1; |
| /branches/V0.88e_ACC-HH_HR_MartinR/fc.c |
|---|
| 58,6 → 58,36 |
| #include "mymath.h" |
| #include "isqrt.h" |
| //MartinW; added vars |
| unsigned char loop1, loop2, loop3; |
| unsigned char settingdest = 5; |
| char keynumber=-7; |
| unsigned char jetistepstep[] = {1,5,10,25,50}, jetistep = 0; |
| unsigned short CurrentOffset = 0;/// |
| unsigned char Motors[8]; |
| unsigned char Motorsmax[8]; |
| unsigned short MotorsTmax; |
| unsigned char updatemotors=2; |
| //Panorama Trigger; |
| int degreeold =0; |
| int degreedivold =0; |
| int degreediv =0; |
| unsigned int panograd=0; |
| unsigned char panotrigger=0; |
| unsigned char calibration_done = 0; |
| unsigned char jetibeepcode[] = {130,'E','I','S','H'}; |
| ///MartinW; added vars END |
| unsigned char h,m,s; |
| unsigned int BaroExpandActive = 0; |
| int MesswertNick,MesswertRoll,MesswertGier,MesswertGierBias, RohMesswertNick,RohMesswertRoll; |
| 74,7 → 104,9 |
| 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; ///MartinW so war es |
| long Mess_Integral_Gier = 0; ///MartinW: Mess_Integral_Gier2 unbenutzt |
| long MittelIntegralNick,MittelIntegralRoll,MittelIntegralNick2,MittelIntegralRoll2; |
| long SummeNick=0,SummeRoll=0; |
| volatile long Mess_Integral_Hoch = 0; |
| 113,6 → 145,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; |
| 164,10 → 198,14 |
| 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, 11, 13, 14, 15, 15, 16, 16, 16, 15, 14, 13, 11, 10, 8, 6, 4, 2, 0, -2, -4, -6, -8, -10, -11, -13, -14, -15, -15, -16, -16, -16, -15, -15, -14, -13, -11, -10, -8, -6, -4, -2, 0, 2, 4, 6, 8, 10, 11, 13, 14, 15, 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 int modell_fliegt = 0; |
| volatile unsigned char FC_StatusFlags = 0, FC_StatusFlags2 = 0; |
| long GIER_GRAD_FAKTOR = 1291; |
| 201,9 → 239,21 |
| 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[22] = Capacity.ActualCurrent; |
| #ifdef WITH_REMAINCAPACITY // only include functions if DEBUG is defined in main.h |
| #warning : "### with REMAIN CAPACITY ###" |
| DebugOut.Analog[23] = Capacity.RemainCapacity; |
| #else |
| DebugOut.Analog[23] = Capacity.UsedCapacity; |
| #endif |
| DebugOut.Analog[24] = SollHoehe/5; |
| // DebugOut.Analog[22] = FromNaviCtrl_Value.GpsZ; |
| // DebugOut.Analog[29] = FromNaviCtrl_Value.SerialDataOkay; |
| 337,7 → 387,7 |
| Mittelwert_AccRoll = ACC_AMPLIFY * AdWertAccRoll; |
| IntegralNick = EE_Parameter.GyroAccFaktor * (long)Mittelwert_AccNick; |
| IntegralRoll = EE_Parameter.GyroAccFaktor * (long)Mittelwert_AccRoll; |
| Mess_IntegralNick = IntegralNick; |
| Mess_IntegralNick = IntegralNick; |
| Mess_IntegralRoll = IntegralRoll; |
| Mess_Integral_Gier = 0; |
| StartLuftdruck = Luftdruck; |
| 374,7 → 424,8 |
| if((NeutralAccY < 300) || (NeutralAccY > 750)) { VersionInfo.HardwareError[0] |= FC_ERROR0_ACC_ROLL; }; |
| if((NeutralAccZ < 512) || (NeutralAccZ > 850)) { VersionInfo.HardwareError[0] |= FC_ERROR0_ACC_TOP; }; |
| carefree_old = 70; |
| #if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__)) |
| #if ((defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__)) && defined(WITH_HOTTMENU)) |
| #warning : "### with Hottmenu ###" |
| LIBFC_HoTT_Clear(); |
| #endif |
| } |
| 389,8 → 440,10 |
| static signed int oldNick, oldRoll, d2Roll, d2Nick; |
| signed long winkel_nick, winkel_roll; |
| 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; |
| 433,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; |
| 484,11 → 539,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; } |
| 495,8 → 557,39 |
| 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; |
| 507,11 → 600,13 |
| 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; |
| 632,6 → 727,15 |
| 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 |
| 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; |
| 674,6 → 778,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; |
| 788,7 → 895,10 |
| CalibrationDone = 1; |
| ServoActive = 1; |
| DDRD |=0x80; // enable J7 -> Servo signal |
| JetiBeep = jetibeepcode[GetActiveParamSet()-1]; |
| Piep(GetActiveParamSet(),120); |
| PPM_in[13] = Parameter_UserParam5 -127 ; // MartinR: Initialisierungswerte für die seriellen Potis für Jeti+ |
| PPM_in[14] = Parameter_UserParam6 -127 ; // MartinR: Initialisierungswerte für die seriellen Potis für Jeti+ |
| } |
| } |
| } |
| 830,7 → 940,7 |
| MotorenEin = 1; |
| sollGier = 0; |
| Mess_Integral_Gier = 0; |
| Mess_Integral_Gier2 = 0; |
| // Mess_Integral_Gier2 = 0; |
| Mess_IntegralNick = EE_Parameter.GyroAccFaktor * (long)Mittelwert_AccNick; |
| Mess_IntegralRoll = EE_Parameter.GyroAccFaktor * (long)Mittelwert_AccRoll; |
| Mess_IntegralNick2 = IntegralNick; |
| 877,15 → 987,55 |
| 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(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]] * stick_p) / 4; |
| stick_roll = (stick_roll * 3 + PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]] * 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 |
| // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| 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; |
| 895,8 → 1045,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]; //MartinR: feinere Auflösung |
| //FromNC_Rotate_S = sintab[EE_Parameter.OrientationAngle]; //MartinR: so war es |
| FromNC_Rotate_S = sintab[EE_Parameter.OrientationAngle * 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; |
| } |
| 923,6 → 1075,9 |
| //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| //+ Analoge Steuerung per Seriell |
| //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| #ifdef WITH_ExternControl /// MartinW memorysaving |
| #warning : "### with ExternControl ###" |
| if(ExternControl.Config & 0x01 && Parameter_ExternalControl > 128) |
| { |
| StickNick += (int) ExternControl.Nick * (int) EE_Parameter.Stick_P; |
| 948,6 → 1103,10 |
| } |
| else MaxStickRoll--; |
| if(FC_StatusFlags & FC_STATUS_EMERGENCY_LANDING) {MaxStickNick = 0; MaxStickRoll = 0;} |
| #else |
| #warning : "### without ExternControl ###" |
| #endif |
| // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // Looping? |
| 1034,7 → 1193,8 |
| 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 |
| { |
| IntegralAccNick = 0; |
| IntegralAccRoll = 0; |
| 1048,6 → 1208,26 |
| 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: 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 |
| 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 |
| } |
| 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)) |
| 1107,7 → 1287,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; |
| 1267,14 → 1449,18 |
| tmp_int += (EE_Parameter.StickGier_P * StickGier) / 4; |
| tmp_int += CompassGierSetpoint; |
| sollGier = tmp_int; |
| Mess_Integral_Gier -= tmp_int; |
| if(Mess_Integral_Gier > 50000) Mess_Integral_Gier = 50000; // begrenzen |
| if(Mess_Integral_Gier <-50000) Mess_Integral_Gier =-50000; |
| //Mess_Integral_Gier -= tmp_int; // MartinR: so war es |
| Mess_Integral_Gier -= (tmp_int * 10) / 8; // MartinR: Test um Zurückschwingen bei hohen I-Faktoren zu verringern |
| //if(Mess_Integral_Gier > 50000) Mess_Integral_Gier = 50000; // begrenzen // MartinR: so war es |
| //if(Mess_Integral_Gier <-50000) Mess_Integral_Gier =-50000; // MartinR: so war es |
| if(Mess_Integral_Gier > 90000) Mess_Integral_Gier = 90000; // begrenzen // MartinR: Begrenzung verändert |
| if(Mess_Integral_Gier <-90000) Mess_Integral_Gier =-90000; // MartinR: Begrenzung verändert |
| // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // Kompass |
| // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| if(KompassValue >= 0 && (Parameter_GlobalConfig & CFG_KOMPASS_AKTIV)) |
| //if(KompassValue >= 0 && (EE_Parameter.GlobalConfig & CFG_KOMPASS_AKTIV)) // MartinR: so war es |
| if((KompassValue >= 0 && (EE_Parameter.GlobalConfig & CFG_KOMPASS_AKTIV)) && !(Parameter_UserParam1 > 50)) // MartinR: bei HH über Schalter wird der Kompass abgeschaltet |
| { |
| if(CalculateCompassTimer-- == 1) |
| { |
| 1331,8 → 1517,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 |
| 1422,7 → 1623,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--) |
| { |
| 1440,7 → 1642,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 |
| 1474,6 → 1686,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) |
| 1481,7 → 1694,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; |
| // Limit the maximum Altitude |
| 1500,7 → 1714,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; |
| AltitudeSetpointTrimming = -abs(StickGas - (StickGasHover - HEIGHT_CONTROL_STICKTHRESHOLD)); |
| 1521,7 → 1736,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 |
| 1535,7 → 1751,8 |
| 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 |
| 1604,20 → 1821,57 |
| 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 |
| LIMIT_MIN_MAX(tmp_long, -127 * STICK_GAIN, 256 * STICK_GAIN); // more than the full range makes no sense |
| //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 |
| tmp_long = (tmp_long * (long)Parameter_Hoehe_P) / 70L; // p-part // MartinR Anpassung an Standardwert |
| } |
| else |
| { |
| //tmp_long = (tmp_long * (long)Parameter_Hoehe_P) / 32L; // p-part |
| tmp_long = (tmp_long * (long)Parameter_Hoehe_P) / 90L; // MartinR Anpassung an Standardwert |
| } |
| // 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 ((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(Parameter_ExtraConfig & CFG2_HEIGHT_LIMIT) tmp_int /= 8; // reduce d-part in "Deckel" mode |
| 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); |
| 1624,9 → 1878,12 |
| LIMIT_MIN_MAX(tmp_long, -32 * STICK_GAIN, 64 * STICK_GAIN); |
| 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 |
| // ------------------------ ---------------------------------- |
| 1672,7 → 1929,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 |
| 1786,7 → 2044,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 |
| // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| 1821,6 → 2141,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 |
| // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| 1844,7 → 2167,8 |
| else if(Mixer.Motor[i][3] == -64) tmp_int -= GierMischanteil; |
| 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 |
| //if(tmp_int > tmp_motorwert[i]) tmp_int = (tmp_motorwert[i] + tmp_int) / 2; // MotorSmoothing // MartinR: so war es |
| if(tmp_int > tmp_motorwert[i]) tmp_int = ((2* tmp_motorwert[i] + tmp_int) / 2) + 1; // MartinR: evtl. stärkere Filterung um Hüpfen bei der Landung zu verringern |
| // else tmp_int = 2 * tmp_int - tmp_motorwert[i]; // original MotorSmoothing |
| else |
| { |
| /branches/V0.88e_ACC-HH_HR_MartinR/fc.h |
|---|
| 48,6 → 48,28 |
| #define CHK_POTI_MM(b,a,min,max) {CHK_POTI(b,a); LIMIT_MIN_MAX(b, min, max);} |
| #define CHK_POTI_MM_OFF(b,a,min,max,off) {CHK_POTI_OFF(b,a,off); LIMIT_MIN_MAX(b, min, max);} |
| /// MartinW; added vars |
| extern unsigned char Motors[8]; |
| unsigned char Motorsmax[8]; |
| unsigned short MotorsTmax; |
| extern unsigned char updatemotors; |
| extern unsigned char loop1, loop2, loop3; |
| extern unsigned char settingdest; |
| extern char keynumber; |
| extern unsigned short CurrentOffset;/// |
| extern signed char jetivalue1,jetivalue2,jetivalue3,jetivalue4; |
| extern int degreeold; |
| extern int degreedivold; |
| extern int degreediv; |
| extern unsigned int panograd; |
| extern unsigned char panotrigger; |
| extern int StickGas; |
| extern unsigned char calibration_done; |
| extern unsigned char jetibeepcode[]; |
| /// MartinW; added vars |
| extern unsigned char Sekunde,Minute; |
| extern unsigned int BaroExpandActive; |
| extern long IntegralNick,IntegralNick2; |
| 55,6 → 77,7 |
| //extern int IntegralNick,IntegralNick2; |
| //extern int IntegralRoll,IntegralRoll2; |
| extern unsigned char Poti[9]; |
| extern unsigned char jetistepstep[], jetistep; |
| extern long Mess_IntegralNick,Mess_IntegralNick2; |
| extern long Mess_IntegralRoll,Mess_IntegralRoll2; |
| 129,7 → 152,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.88e_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.c"></File><File path="jetimenu.h"></File><File path="capacity.c"></File><File path="capacity.h"></File><File path="hottmenu.c"></File><File path="hottmenu.h"></File><File path="sbus.c"></File><File path="sbus.h"></File></Project> |
| /branches/V0.88e_ACC-HH_HR_MartinR/hottmenu.h |
|---|
| 1,11 → 1,28 |
| #ifndef _HOTTMENU_H |
| #define _HOTTMENU_H |
| #if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__)) |
| typedef struct{ |
| char offset; |
| unsigned char min; |
| unsigned char max; |
| char name[4]; |
| unsigned char *Variable; |
| } Parameter_List_t; |
| #define MAXPARAM 43 //Muss eine ungerade Zahl sein |
| extern const Parameter_List_t Parameter_List[]; |
| #if ((defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__))) |
| #define MAX_ERR_NUMBER (29+1) |
| extern const char PROGMEM NC_ERROR_TEXT[MAX_ERR_NUMBER][17]; |
| extern char dummy; |
| extern unsigned char HottKeyboard,HoTT_RequestedSensor; |
| extern unsigned char HottUpdate(unsigned char key); |
| /branches/V0.88e_ACC-HH_HR_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 |
| // ----------------------------------------------------------- |
| 180,6 → 182,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 |
| // ----------------------------------------------------------- |
| 204,11 → 229,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.88e_ACC-HH_HR_MartinR/main.c |
|---|
| 53,6 → 53,7 |
| #include "main.h" |
| unsigned char DisableRcOffBeeping = 0; |
| unsigned char PlatinenVersion = 10; |
| unsigned char SendVersionToNavi = 1; |
| unsigned char BattLowVoltageWarning = 94; |
| unsigned int FlugMinuten = 0,FlugMinutenGesamt = 0; |
| unsigned int FlugSekunden = 0; |
| 60,11 → 61,14 |
| unsigned char FoundMotors = 0; |
| unsigned char JetiBeep = 0; // to allow any Morse-Beeping of the Jeti-Box |
| unsigned char metrotest; |
| void PrintLine(void) |
| { |
| printf("\n\r==================================="); |
| } |
| static char panodelay = 0; ///martinw |
| //static char panoleddelay = 0; ///martinw |
| void CalMk3Mag(void) |
| { |
| 108,7 → 112,8 |
| } |
| } |
| else BattLowVoltageWarning = EE_Parameter.UnterspannungsWarnung; |
| if(print) printf(" Low warning: %d.%d",BattLowVoltageWarning/10,BattLowVoltageWarning%10); |
| //if(print) printf(" Low warning: %d.%d",BattLowVoltageWarning/10,BattLowVoltageWarning%10); |
| if(print) printf("Low Batt level: %d.%d",BattLowVoltageWarning/10,BattLowVoltageWarning%10); /// Martinw; removed memorysaving |
| } |
| //############################################################################ |
| 159,13 → 164,13 |
| ADC_Init(); |
| I2C_Init(1); |
| SPI_MasterInit(); |
| Capacity_Init(); |
| //Capacity_Init(); //Moved by metro |
| LIBFC_Init(); |
| GRN_ON; |
| sei(); |
| ParamSet_Init(); |
| Capacity_Init(); //Moved by metro |
| // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // + Check connected BL-Ctrls |
| // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| 213,7 → 218,8 |
| //if(EE_Parameter.GlobalConfig & CFG_HOEHENREGELUNG) |
| { |
| printf("\n\rCalibrating pressure sensor.."); |
| //printf("\n\rCalibrating pressure sensor.."); |
| printf("\n\rCal. pressure sensor");/// Martinw; removed memorysaving |
| timer = SetDelay(1000); |
| SucheLuftruckOffset(); |
| while (!CheckDelay(timer)); |
| 238,7 → 244,11 |
| } |
| printf("\n\rFlight-time %u min Total:%u min", FlugMinuten, FlugMinutenGesamt); |
| #ifdef WITH_MKTOOL_Display // MartinW; for no MKT Display main.h |
| #warning : "### with MKTool Display ###" |
| LcdClear(); |
| #endif |
| I2CTimeout = 5000; |
| WinkelOut.Orientation = 1; |
| LipoDetection(1); |
| 252,6 → 262,14 |
| DebugOut.Status[0] = 0x01 | 0x02; |
| JetiBeep = 0; |
| if(EE_Parameter.ExtraConfig & CFG_NO_RCOFF_BEEPING) DisableRcOffBeeping = 1; |
| //#if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__)) ///MartinW; only for 1284er |
| //#warning : "### with Sponsored Message ###" |
| // printf("\n\rJETI+ / HoTT+ Version sponsored by Flyinghigh.ch, progammed by metro, MartinW\n\r"); |
| printf("\n\rACC-HH Version progammed by MartinR\n\r"); |
| //#endif |
| while (1) |
| { |
| if(ReceiverUpdateModeActive) while (1) PORTC &= ~(1<<7); // Beeper off |
| 312,7 → 330,8 |
| { |
| static unsigned char second; |
| timer += 20; // 20 ms interval |
| #if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__)) |
| #if ((defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__)) && defined(WITH_HOTTMENU)) |
| #warning : "### with Hottmenu ###" |
| if(EE_Parameter.Receiver == RECEIVER_HOTT) HoTT_Menu(); |
| #endif |
| if(MissingMotor) |
| 411,6 → 430,52 |
| timer = SetDelay(20); // falls "timer += 20;" mal nicht geht |
| } |
| } |
| #ifdef WITH_PANOTRIGGER /// MartinW main.h means no memsave |
| #warning : "### with Panorama Trigger Function ###" |
| //// Pano Trigger |
| if(Parameter_UserParam8 >= 200) //enable/disable Pano Trigger Function |
| { |
| if(Parameter_UserParam4 <=9) { Parameter_UserParam4 = 10; } |
| degreedivold = degreediv; |
| degreediv = (ErsatzKompass / GIER_GRAD_FAKTOR) / Parameter_UserParam4;//Division |
| if((degreediv-degreedivold)==2||(degreediv-degreedivold)==1||(degreediv-degreedivold)== -2||(degreediv-degreedivold)== -1) |
| { |
| if(panodelay == 0) |
| { |
| panotrigger= 1; // muss wieder geleert werden |
| ROT_ON; |
| J16_ON; |
| panodelay = Parameter_UserParam5; |
| } |
| } |
| else |
| { |
| if(panodelay <= Parameter_UserParam6) //ms Intervall |
| { |
| //panoleddelay = Parameter_UserParam6; |
| J16_OFF; |
| ROT_OFF; |
| } |
| if(panodelay > 0) |
| { |
| panodelay--; |
| } |
| } |
| }// END if(Parameter_UserParam4 >= 1) |
| //// Pano Trigger |
| #else |
| #warning : "### without Panorama Trigger Function ###" |
| #endif |
| LED_Update(); |
| Capacity_Update(); |
| } //else DebugOut.Analog[26]++; |
| /branches/V0.88e_ACC-HH_HR_MartinR/main.h |
|---|
| 7,6 → 7,36 |
| //#define RECEIVER_SPEKTRUM_DX7EXP |
| //#define RECEIVER_SPEKTRUM_DX8EXP |
| #if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__)) ///MartinW |
| #define WITH_MKTOOL_Display |
| #define WITH_JETI_SIMULATION |
| #define WITH_ExternControl |
| #define WITH_FULL_ANALOG_TEXT |
| #define WITHSPECTRUM |
| //#define WITH_REMAINCAPACITY |
| // #define WITH_PANOTRIGGER |
| #else |
| #endif |
| //#define WITH_MKTOOL_Display /// MartinW; with MKTool Display 70604-63130 |
| //#define WITHSPECTRUM /// MartinW; memsave |
| #define WITH_FULL_ANALOG_TEXT /// MartinW; memsave |
| #define WITH_ExternControl /// MartinW; memsave |
| //#define WITH_ORIGINAL_MOTORSMOOTHING /// MartinW; memsave 63312-63164 |
| #define WITH_JETI_SIMULATION /// MartinW; memsave 63312-63016 |
| #define WITH_JETI_BEEP /// MartinW; 63072-63038; 63216-63050 |
| //#define WITH_PANOTRIGGER /// MartinW; 64336-64112 |
| #define WITH_HOTTMENU /// Metro; |
| //#define WITH_REMAINCAPACITY /// Metro; |
| // neue Hardware |
| #define ROT_OFF {if((PlatinenVersion == 10)||(PlatinenVersion >= 20)) PORTB &=~0x01; else PORTB |= 0x01;} |
| #define ROT_ON {if((PlatinenVersion == 10)||(PlatinenVersion >= 20)) PORTB |= 0x01; else PORTB &=~0x01;} |
| /branches/V0.88e_ACC-HH_HR_MartinR/makefile |
|---|
| 10,6 → 10,7 |
| VERSION_SERIAL_MAJOR = 11 # Serial Protocol |
| VERSION_SERIAL_MINOR = 0 # Serial Protocol |
| NC_SPI_COMPATIBLE = 31 # Navi-Kompatibilität |
| MOD = ACC-HH |
| #------------------------------------------------------------------- |
| # ATMEGA644: 63487 is maximum |
| #------------------------------------------------------------------- |
| 57,82 → 58,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.88e_ACC-HH_HR_MartinR/spi.c |
|---|
| 207,7 → 207,9 |
| motorindex %= 12; |
| 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; |
| 362,7 → 364,8 |
| EarthMagneticInclinationTheoretic = FromNaviCtrl.Param.Byte[2]; |
| break; |
| #if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__)) |
| #if ((defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__)) && defined(WITH_HOTTMENU)) |
| #warning : "### with Hottmenu ###" |
| case SPI_NCCMD_HOTT_DATA: |
| if(EE_Parameter.Receiver == RECEIVER_HOTT) NC_Fills_HoTT_Telemety(); |
| break; |
| /branches/V0.88e_ACC-HH_HR_MartinR/timer0.c |
|---|
| 63,11 → 63,13 |
| 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; |
| volatile int16_t ServoNickValue = 0; |
| volatile int16_t ServoRollValue = 0; |
| volatile int16_t ServoPanValue = 0; // MartinR : für PAN-Funktion |
| enum { |
| 244,16 → 246,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)EE_Parameter.ServoNickComp * nick) / 512L; |
| // offset (Range from 0 to 255 * 3 = 765) |
| ServoNickOffset += ((int16_t)Parameter_ServoNickControl * (MULTIPLYER*16) - ServoNickOffset) / EE_Parameter.ServoManualControlSpeed; |
| 281,7 → 303,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)EE_Parameter.ServoRollComp * roll) / 512L; |
| ServoRollOffset += ((int16_t)Parameter_ServoRollControl * (MULTIPLYER*16) - ServoRollOffset) / EE_Parameter.ServoManualControlSpeed; |
| if(EE_Parameter.ServoCompInvert & 0x02) |
| 304,6 → 330,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; |
| } |
| } |
| 330,6 → 361,7 |
| if(PlatinenVersion < 20) |
| { |
| /* // MartinR : deaktiviert wegen Platzbedarf |
| //--------------------------- |
| // Nick servo state machine |
| //--------------------------- |
| 355,6 → 387,7 |
| // set pulse output active |
| PulseOutput = 1; |
| } |
| */ |
| } // EOF Nick servo state machine |
| else |
| { |
| 388,7 → 421,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.88e_ACC-HH_HR_MartinR/timer0.h |
|---|
| 20,3 → 20,5 |
| extern volatile unsigned char SendSPI, ServoActive, CalculateServoSignals; |
| extern volatile int16_t ServoNickValue; |
| extern volatile int16_t ServoRollValue; |
| extern volatile int16_t ServoPanValue; // MartinR : für PAN-Funktion |
| extern signed char cosinus, sinus; // MartinR : extern für PAN-Funktion |
| /branches/V0.88e_ACC-HH_HR_MartinR/uart.c |
|---|
| 109,6 → 109,13 |
| unsigned int AboTimeOut = 0; |
| unsigned volatile char ReceiverUpdateModeActive = 0; // 1 = Update 2 = JetiBox-Simulation |
| #ifdef WITH_FULL_ANALOG_TEXT /// MartinW main.h means no memsave |
| #warning : "### with normal ANALOG_TEXT[32][16] ###" |
| const unsigned char ANALOG_TEXT[32][16] PROGMEM = |
| { |
| //1234567890123456 |
| 128,25 → 135,66 |
| "Motor 2 ", |
| "Motor 3 ", |
| "Motor 4 ", //15 |
| "16 ", |
| "17 ", |
| "18 ", |
| "Motor 5 ",/// |
| "Motor 6 ",/// |
| "nc alt speed ", |
| "19 ", |
| "Servo ", //20 |
| "Hovergas ", |
| "Current [0.1A] ", |
| "Capacity [mAh] ", |
| "Height Setpoint ", |
| "25 ", //25 |
| "26 ", //"26 CPU OverLoad ", |
| "Hight Setpoint ", |
| "Motor 7 ", //25 /// |
| "Motor 8 ",/// |
| "Compass Setpoint", |
| "I2C-Error ", |
| "BL Limit ", |
| "GPS_Nick ", //30 |
| "GPS_Roll " |
| }; |
| }; |
| #else |
| #warning : "### with reduced ANALOG_TEXT[32][13] ###" |
| const unsigned char ANALOG_TEXT[32][13] PROGMEM = |
| { |
| //1234567890123456 |
| "AngleNick ", //0 |
| "AngleRoll ", |
| "AccNick ", |
| "AccRoll ", |
| "YawGyro ", |
| "Height Value ", //5 |
| "AccZ ", |
| "Gas ", |
| "Compass Value", |
| "Voltage[0.1V]", |
| "ReceiverLevel", //10 |
| "Gyro Compass ", |
| "Motor 1 ", |
| "Motor 2 ", |
| "Motor 3 ", |
| "Motor 4 ", //15 |
| "Motor 5 ",/// |
| "Motor 6 ",/// |
| "nc alt speed ", |
| "19 ", |
| "Servo ", //20 |
| "Hovergas ", |
| "Current[0.1A]", |
| "Capacity[mAh]", |
| "Hight Setp ", |
| "Motor 8 ", //25 /// |
| "Motor 9 ",/// |
| "Compass Setp ", |
| "I2C-Error ", |
| "BL Limit ", |
| "GPS_Nick ", //30 |
| "GPS_Roll " |
| }; |
| #endif |
| //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| //++ Sende-Part der Datenübertragung |
| //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| 202,7 → 250,12 |
| RxdBuffer[buf_ptr] = '\r'; |
| if(RxdBuffer[2] == 'R') |
| { |
| #ifdef WITH_MKTOOL_Display /// MartinW main.h |
| #warning : "### with MKTool Display ###" |
| LcdClear(); |
| #endif |
| wdt_enable(WDTO_250MS); // Reset-Commando |
| ServoActive = 0; |
| } |
| 500,6 → 553,12 |
| break; |
| case 'j': |
| if(MotorenEin) break; |
| #ifdef WITH_JETI_SIMULATION /// MartinW main.h means no memsave |
| #warning : "### with jeti update command ###" |
| tempchar1 = LIBFC_GetCPUType(); |
| if((tempchar1 == CPU_ATMEGA644P) || (tempchar1 == CPU_ATMEGA1284P)) |
| { |
| 558,6 → 617,11 |
| sei(); |
| } |
| #else |
| #warning : "### without jeti update command ###" |
| #endif |
| break; |
| } // case FC_ADDRESS: |
| 604,7 → 668,11 |
| break; |
| case 'h':// x-1 Displayzeilen |
| PcZugriff = 255; |
| #ifdef WITH_MKTOOL_Display /// MartinW memorysave |
| #warning : "### with MKTool Display ###" |
| PcZugriff = 255; |
| if((pRxData[0] & 0x80) == 0x00) // old format |
| { |
| DisplayLine = 2; |
| 624,6 → 692,8 |
| PcZugriff = 255; |
| MenuePunkt = pRxData[0]; |
| DebugDisplayAnforderung1 = 1; |
| #endif |
| break; |
| case 'v': // Version-Anforderung und Ausbaustufe |
| GetVersionAnforderung = 1; |
| 701,6 → 771,9 |
| Intervall3D = 0; |
| } |
| #ifdef WITH_MKTOOL_Display //main.h |
| #warning : "### with MKTool Display ###" |
| if(((Display_Interval>0 && CheckDelay(Display_Timer)) || DebugDisplayAnforderung) && UebertragungAbgeschlossen) |
| { |
| if(DisplayLine > 3)// new format |
| 723,6 → 796,9 |
| SendOutData('L', FC_ADDRESS, 3, &MenuePunkt, sizeof(MenuePunkt), &MaxMenue, sizeof(MaxMenue), DisplayBuff, sizeof(DisplayBuff)); |
| DebugDisplayAnforderung1 = 0; |
| } |
| #endif |
| if(GetVersionAnforderung && UebertragungAbgeschlossen) |
| { |
| SendOutData('V', FC_ADDRESS, 1, (unsigned char *) &VersionInfo, sizeof(VersionInfo)); |
| 765,9 → 841,25 |
| } |
| if(DebugTextAnforderung != 255) // Texte für die Analogdaten |
| { |
| #ifdef WITH_FULL_ANALOG_TEXT /// MartinW main.h means no memsave |
| #warning : "### with normal ANALOG_TEXT[32][16] ###" |
| unsigned char label[16]; // local sram buffer |
| memcpy_P(label, ANALOG_TEXT[DebugTextAnforderung], 16); // read lable from flash to sra |
| SendOutData('A', FC_ADDRESS, 2, (unsigned char *)&DebugTextAnforderung, sizeof(DebugTextAnforderung),label, 16); |
| #else |
| #warning : "### with reduced ANALOG_TEXT[32][13] ###" |
| unsigned char label[16]=" "; // local sram buffer ///MartinW; for MKTool, needs 32 bytes |
| memcpy_P(label, ANALOG_TEXT[DebugTextAnforderung], 13); // read lable from flash to sra |
| SendOutData('A', FC_ADDRESS, 2, (unsigned char *)&DebugTextAnforderung, sizeof(DebugTextAnforderung),label, 16); |
| #endif |
| DebugTextAnforderung = 255; |
| } |
| if(ConfirmFrame && UebertragungAbgeschlossen) // Datensatz bestätigen |
| /branches/V0.88e_ACC-HH_HR_MartinR/version.txt |
|---|
| 543,3 → 543,98 |
| - Kompassrichtung neu merken, wenn CF geschaltet wird |
| - "I" aus dem Hott-Menü entfernt und durch ":" ersetzt, weil das nur auf der mx-20 gut aussah |
| - Höhenregler-Settings: GPS-Z von 64 auf 20 reduziert |
| 0.88_ACC-HH_HR_MartinR 27.03.2012: |
| Ä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) |
| - 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 deaktiviert |
| - Ich fliege derzeit mit Höhe-P = 17 und Höhe-D = 32, Z-ACC=0 |
| 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. |