| /test_branches/FC2_2/analog.c |
|---|
| 376,7 → 376,6 |
| Luftdruck -= Luftdruck/16; |
| Luftdruck += tmpLuftdruck; |
| HoehenWert = StartLuftdruck - Luftdruck; // cm |
| //HoehenWert = HoehenWert + AdWertAccHoch * 41 / 256; // Weight-compsensation <------- |
| } |
| else |
| #endif |
| /test_branches/FC2_2/eeprom.c |
|---|
| 138,8 → 138,7 |
| EE_Parameter.GyroAccAbgleich = 32; // 1/k |
| EE_Parameter.BitConfig = 0; // Looping usw. |
| EE_Parameter.GlobalConfig = CFG_ACHSENKOPPLUNG_AKTIV | CFG_KOMPASS_AKTIV | CFG_GPS_AKTIV | CFG_HOEHEN_SCHALTER; |
| EE_Parameter.ExtraConfig = CFG_GPS_AID | CFG2_VARIO_BEEP; |
| EE_Parameter.GlobalConfig3 = CFG3_SPEAK_ALL;//CFG3_VARIO_FAILSAFE; |
| EE_Parameter.ExtraConfig = CFG_GPS_AID | CFG2_VARIO_BEEP | CFG_LEARNABLE_CAREFREE; |
| EE_Parameter.Receiver = RECEIVER_HOTT; |
| EE_Parameter.MotorSafetySwitch = 0; |
| EE_Parameter.ExternalControl = 0; |
| 149,7 → 148,7 |
| EE_Parameter.KompassWirkung = 64; // Wert : 0-247 |
| EE_Parameter.Hoehe_MinGas = 30; |
| EE_Parameter.MaxHoehe = 255; // Wert : 0-247 255 -> Poti1 |
| EE_Parameter.HoeheChannel = 5; // Wert : 0-32 |
| #if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__)) |
| if(ACC_AltitudeControl) |
| { |
| 158,6 → 157,9 |
| EE_Parameter.Hoehe_ACC_Wirkung = 30; // Wert : 0-247 |
| EE_Parameter.Hoehe_HoverBand = 1; // Wert : 0-247 |
| EE_Parameter.Hoehe_GPS_Z = 0; // Wert : 0-247 |
| EE_Parameter.Hoehe_StickNeutralPoint = 127;// Wert : 0-247 (0 = Hover-Estimation) |
| EE_Parameter.GlobalConfig3 = CFG3_SPEAK_ALL;// |
| EE_Parameter.FailSafeTime = 30; // 0 = off |
| } |
| else |
| #endif |
| 167,10 → 169,14 |
| EE_Parameter.Hoehe_ACC_Wirkung = 0; // Wert : 0-247 |
| 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.GlobalConfig3 = CFG3_SPEAK_ALL; |
| EE_Parameter.FailSafeTime = 0; // 0 = off |
| } |
| 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.StartLandChannel = 0; |
| EE_Parameter.LandingSpeed = 12; |
| EE_Parameter.UserParam1 = 0; // zur freien Verwendung |
| EE_Parameter.UserParam2 = 0; // zur freien Verwendung |
| 184,7 → 190,7 |
| EE_Parameter.ServoNickControl = 128; // Wert : 0-247 // Stellung des Servos |
| EE_Parameter.ServoNickComp = 50; // Wert : 0-247 // Einfluss Gyro/Servo |
| EE_Parameter.ServoCompInvert = 2; // Wert : 0-247 // Richtung Einfluss Gyro/Servo |
| EE_Parameter.ServoNickMin = 15; // Wert : 0-247 // Anschlag |
| EE_Parameter.ServoNickMin = 24; // Wert : 0-247 // Anschlag |
| EE_Parameter.ServoNickMax = 230; // Wert : 0-247 // Anschlag |
| EE_Parameter.ServoNickRefresh = 4; |
| EE_Parameter.Servo3 = 125; |
| 208,30 → 214,29 |
| EE_Parameter.LoopThreshold = 90; // Wert: 0-247 Schwelle für Stickausschlag |
| EE_Parameter.LoopHysterese = 50; |
| EE_Parameter.NaviGpsModeControl = 254; // 254 -> Poti 2 |
| EE_Parameter.NaviGpsModeChannel = 6; // Kanal 6 |
| EE_Parameter.NaviGpsGain = 100; |
| EE_Parameter.NaviGpsP = 90; |
| EE_Parameter.NaviGpsI = 90; |
| EE_Parameter.NaviGpsD = 90; |
| EE_Parameter.NaviGpsP = 100; |
| EE_Parameter.NaviGpsI = 90; |
| EE_Parameter.NaviGpsD = 120; |
| EE_Parameter.NaviGpsA = 40; |
| EE_Parameter.NaviGpsPLimit = 75; |
| EE_Parameter.NaviGpsILimit = 85; |
| EE_Parameter.NaviGpsDLimit = 75; |
| EE_Parameter.NaviGpsACC = 0; |
| EE_Parameter.NaviGpsMinSat = 6; |
| EE_Parameter.NaviStickThreshold = 8; |
| EE_Parameter.NaviWindCorrection = 90; |
| EE_Parameter.NaviWindCorrection = 50; |
| EE_Parameter.NaviAccCompensation = 42; |
| EE_Parameter.NaviOperatingRadius = 245; |
| EE_Parameter.NaviAngleLimitation = 140; |
| EE_Parameter.NaviPH_LoginTime = 5; |
| EE_Parameter.NaviPH_LoginTime = 2; |
| EE_Parameter.OrientationAngle = 0; |
| EE_Parameter.CareFreeModeControl = 0; |
| EE_Parameter.CareFreeChannel = 0; |
| EE_Parameter.UnterspannungsWarnung = 33; // Wert : 0-247 ( Automatische Zellenerkennung bei < 50) |
| EE_Parameter.NotGas = 65; // Wert : 0-247 // Gaswert bei Empangsverlust (ggf. in Prozent) |
| EE_Parameter.NotGasZeit = 90; // Wert : 0-247 // Zeit bis auf NotGas geschaltet wird, wg. Rx-Problemen |
| EE_Parameter.MotorSmooth = 0; |
| EE_Parameter.ComingHomeAltitude = 0; // 0 = don't change |
| EE_Parameter.FailSafeTime = 0; // 0 = off |
| EE_Parameter.MaxAltitude = 150; // 0 = off |
| EE_Parameter.AchsKopplung1 = 125; |
| EE_Parameter.AchsKopplung2 = 52; |
| 285,7 → 290,7 |
| /***************************************************/ |
| /* Default Values for parameter set 2 */ |
| /***************************************************/ |
| void ParamSet_DefaultSet2(void) // beginner |
| void ParamSet_DefaultSet2(void) // Agil |
| { |
| CommonDefaults(); |
| EE_Parameter.Stick_P = 8; // Wert : 1-20 |
| 299,7 → 304,7 |
| EE_Parameter.I_Faktor = 16; |
| EE_Parameter.CouplingYawCorrection = 70; |
| EE_Parameter.DynamicStability = 70; |
| memcpy(EE_Parameter.Name, "Normal",6); |
| memcpy(EE_Parameter.Name, "Agile",5); |
| EE_Parameter.crc = RAM_Checksum((uint8_t*)(&EE_Parameter), sizeof(EE_Parameter)-1); |
| } |
| 306,7 → 311,7 |
| /***************************************************/ |
| /* Default Values for parameter set 3 */ |
| /***************************************************/ |
| void ParamSet_DefaultSet3(void) // beginner |
| void ParamSet_DefaultSet3(void) // Easy |
| { |
| CommonDefaults(); |
| EE_Parameter.Stick_P = 6; // Wert : 1-20 |
| 507,6 → 512,7 |
| setnumber = 3; |
| eeprom_write_byte((void*)(EEPROM_ADR_PARAM_BEGIN+PID_ACTIVE_SET), setnumber); |
| } |
| ActiveParamSet = setnumber; |
| return(setnumber); |
| } |
| 517,6 → 523,7 |
| { |
| if(setnumber > 5) setnumber = 5; |
| if(setnumber < 1) setnumber = 1; |
| ActiveParamSet = setnumber; |
| eeprom_write_byte((uint8_t*)(EEPROM_ADR_PARAM_BEGIN + PID_ACTIVE_SET), setnumber); |
| } |
| 565,15 → 572,23 |
| void ParamSet_Init(void) |
| { |
| uint8_t channel_backup = 0, bad_params = 0, ee_default = 0,i; |
| if(EEPARAM_REVISION != GetParamByte(PID_EE_REVISION) ) |
| #if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__)) |
| if(PlatinenVersion != GetParamByte(PID_HARDWARE_VERSION)) |
| { |
| if(PlatinenVersion == 22 && GetParamByte(PID_HARDWARE_VERSION) == 21 && !(PIND & 0x10)) SetParamByte(PID_EE_REVISION,0); // reset the Settings if the Version changed to V2.2 |
| SetParamByte(PID_HARDWARE_VERSION,PlatinenVersion); // Remember the Version number |
| wdt_enable(WDTO_15MS); // Reset-Commando |
| printf("\n\r--> Hardware Version Byte Changed <--"); |
| while(1); |
| } |
| #endif |
| if((EEPARAM_REVISION) != GetParamByte(PID_EE_REVISION)) |
| { |
| ee_default = 1; // software update or forced by mktool |
| } |
| // 1st check for a valid channel backup in eeprom |
| i = EEProm_Checksum(EEPROM_ADR_CHANNELS, sizeof(EE_Parameter.Kanalbelegung)); |
| if(i == eeprom_read_byte((uint8_t*)(EEPROM_ADR_CHANNELS + sizeof(EE_Parameter.Kanalbelegung))) ) channel_backup = 1; |
| if(i == eeprom_read_byte((uint8_t*)(EEPROM_ADR_CHANNELS + sizeof(EE_Parameter.Kanalbelegung)))) channel_backup = 1; |
| // parameter check |
| 590,13 → 605,10 |
| ParamSet_DefaultSet1(); // Fill ParamSet Structure to default parameter set 1 (Sport) |
| break; |
| case 2: |
| ParamSet_DefaultSet2(); // Kamera |
| ParamSet_DefaultSet2(); // Normal |
| break; |
| case 3: |
| ParamSet_DefaultSet3(); // Beginner |
| break; |
| default: |
| ParamSet_DefaultSet3(); // Kamera |
| ParamSet_DefaultSet3(); // Easy |
| break; |
| } |
| if(channel_backup) // if we have an channel mapping backup in eeprom |
| 615,8 → 627,6 |
| // default-Setting is parameter set 3 |
| SetActiveParamSet(3); |
| } |
| // read active parameter set to ParamSet stucture |
| i = GetActiveParamSet(); |
| ParamSet_ReadFromEEProm(i); |
| 629,7 → 639,7 |
| MixerTable_Default(); // Quadro |
| MixerTable_WriteToEEProm(); |
| } |
| if(ee_default) SetParamByte(PID_EE_REVISION, EEPARAM_REVISION); |
| if(ee_default) SetParamByte(PID_EE_REVISION, (EEPARAM_REVISION)); |
| // determine motornumber |
| RequiredMotors = 0; |
| for(i = 0; i < 16; i++) |
| /test_branches/FC2_2/eeprom.h |
|---|
| 4,10 → 4,11 |
| #include <inttypes.h> |
| #include "twimaster.h" |
| #define EEPARAM_REVISION 93 // is count up, if paramater stucture has changed (compatibility) |
| #define EEMIXER_REVISION 1 // is count up, if mixer stucture has changed (compatibility) |
| #define EEPARAM_REVISION 95 // is count up, if paramater stucture has changed (compatibility) |
| #define EEMIXER_REVISION 1 // is count up, if mixer stucture has changed (compatibility) |
| #define EEPROM_ADR_PARAM_BEGIN 0 |
| #define EE_DUMMY 0 // Byte |
| #define PID_EE_REVISION 1 // byte |
| #define PID_ACTIVE_SET 2 // byte |
| #define PID_PRESSURE_OFFSET 3 // byte |
| 20,9 → 21,10 |
| #define PID_FLIGHT_MINUTES 14 // word |
| #define PID_SPEAK_HOTT_CFG 16 // Byte |
| #define PID_HARDWARE_VERSION 17 // Byte |
| #define EEPROM_ADR_CHANNELS 80 // 80 - 93, 12 bytes + 1 byte crc |
| #define EEPROM_ADR_PARAMSET 100 // 100 - 650, 5 * 110 bytes |
| #define EEPROM_ADR_PARAMSET 100 // 100 - 725, 5 * 125 bytes |
| #define EEPROM_ADR_MIXERTABLE 1000 // 1000 - 1078, 78 bytes |
| #define EEPROM_ADR_BLCONFIG 1200 // 1200 - 1296, 12 * 8 bytes |
| 142,7 → 144,7 |
| unsigned char GlobalConfig; // 0x01=Höhenregler aktiv,0x02=Kompass aktiv, 0x04=GPS aktiv, 0x08=Heading Hold aktiv |
| unsigned char Hoehe_MinGas; // Wert : 0-100 |
| unsigned char Luftdruck_D; // Wert : 0-250 |
| unsigned char MaxHoehe; // Wert : 0-32 |
| unsigned char HoeheChannel; // Wert : 0-32 |
| unsigned char Hoehe_P; // Wert : 0-32 |
| unsigned char Hoehe_Verstaerkung; // Wert : 0-50 |
| unsigned char Hoehe_ACC_Wirkung; // Wert : 0-250 |
| 212,7 → 214,7 |
| unsigned char WARN_J17_Bitmask; // for the J17 Output |
| //---NaviCtrl--------------------------------------------- |
| unsigned char NaviOut1Parameter; // for the J16 Output |
| unsigned char NaviGpsModeControl; // Parameters for the Naviboard |
| unsigned char NaviGpsModeChannel; // Parameters for the Naviboard |
| unsigned char NaviGpsGain; |
| unsigned char NaviGpsP; |
| unsigned char NaviGpsI; |
| 220,7 → 222,7 |
| unsigned char NaviGpsPLimit; |
| unsigned char NaviGpsILimit; |
| unsigned char NaviGpsDLimit; |
| unsigned char NaviGpsACC; |
| unsigned char NaviGpsA; |
| unsigned char NaviGpsMinSat; |
| unsigned char NaviStickThreshold; |
| unsigned char NaviWindCorrection; |
| 232,7 → 234,7 |
| unsigned char ExternalControl; // for serial Control |
| //---CareFree--------------------------------------------- |
| unsigned char OrientationAngle; // Where is the front-direction? |
| unsigned char CareFreeModeControl; // switch for CareFree |
| unsigned char CareFreeChannel; // switch for CareFree |
| unsigned char MotorSafetySwitch; |
| unsigned char MotorSmooth; |
| unsigned char ComingHomeAltitude; |
| 241,6 → 243,8 |
| unsigned char FailsafeChannel; // if the value of this channel is > 100, the MK reports "RC-Lost" |
| unsigned char ServoFilterNick; |
| unsigned char ServoFilterRoll; |
| unsigned char StartLandChannel; |
| unsigned char LandingSpeed; |
| //------------------------------------------------ |
| unsigned char BitConfig; // (war Loop-Cfg) Bitcodiert: 0x01=oben, 0x02=unten, 0x04=links, 0x08=rechts / wird getrennt behandelt |
| unsigned char ServoCompInvert; // // 0x01 = Nick, 0x02 = Roll, 0x04 = relative moving // WICHTIG!!! am Ende lassen |
| 248,7 → 252,7 |
| unsigned char GlobalConfig3; // bitcodiert |
| char Name[12]; |
| unsigned char crc; // must be the last byte! |
| } paramset_t; |
| } paramset_t; // 127 bytes |
| #define PARAMSET_STRUCT_LEN sizeof(paramset_t) |
| /test_branches/FC2_2/fc.c |
|---|
| 118,7 → 118,7 |
| unsigned char Looping_Links = 0, Looping_Rechts = 0, Looping_Unten = 0, Looping_Oben = 0; |
| unsigned char Parameter_Luftdruck_D = 48; // Wert : 0-250 |
| unsigned char Parameter_HoehenSchalter = 251; // Wert : 0-250 |
| unsigned char Parameter_HoehenSchalter = 0; // Wert : 0-250 |
| unsigned char Parameter_Hoehe_P = 16; // Wert : 0-32 |
| unsigned char Parameter_Hoehe_ACC_Wirkung = 58; // Wert : 0-250 |
| unsigned char Parameter_KompassWirkung = 64; // Wert : 0-250 |
| 138,6 → 138,7 |
| unsigned char Parameter_UserParam6 = 0; |
| unsigned char Parameter_UserParam7 = 0; |
| unsigned char Parameter_UserParam8 = 0; |
| unsigned char Parameter_NickControl = 100; |
| unsigned char Parameter_ServoNickControl = 100; |
| unsigned char Parameter_ServoRollControl = 100; |
| unsigned char Parameter_ServoNickComp = 50; |
| 152,12 → 153,11 |
| unsigned char Parameter_J16Timing; // for the J16 Output |
| unsigned char Parameter_J17Bitmask; // for the J17 Output |
| unsigned char Parameter_J17Timing; // for the J17 Output |
| unsigned char Parameter_NaviGpsModeControl; // Parameters for the Naviboard |
| unsigned char Parameter_NaviGpsGain; |
| unsigned char Parameter_NaviGpsP; |
| unsigned char Parameter_NaviGpsI; |
| unsigned char Parameter_NaviGpsD; |
| unsigned char Parameter_NaviGpsACC; |
| unsigned char Parameter_NaviGpsA; |
| unsigned char Parameter_NaviOperatingRadius; |
| unsigned char Parameter_NaviWindCorrection; |
| unsigned char Parameter_NaviSpeedCompensation; |
| 206,6 → 206,7 |
| DebugOut.Analog[14] = Motor[2].SetPoint; |
| DebugOut.Analog[15] = Motor[3].SetPoint; |
| DebugOut.Analog[20] = ServoNickValue; |
| DebugOut.Analog[21] = HoverGas; |
| DebugOut.Analog[22] = Capacity.ActualCurrent; |
| DebugOut.Analog[23] = Capacity.UsedCapacity; |
| DebugOut.Analog[24] = SollHoehe/10; |
| 214,16 → 215,11 |
| DebugOut.Analog[30] = GPS_Nick; |
| DebugOut.Analog[31] = GPS_Roll; |
| if(VersionInfo.HardwareError[0] || VersionInfo.HardwareError[1]) DebugOut.Status[1] |= 1; else DebugOut.Status[1] &= 0xfe; |
| DebugOut.Analog[16] = Variance; |
| DebugOut.Analog[17] = VarioMeter; |
| DebugOut.Analog[18] = HoehenWertF; |
| //DebugOut.Analog[25] = VarioMeter;///8192; |
| DebugOut.Analog[26] = NeutralAccZfine; |
| //DebugOut.Analog[16] = Variance; |
| //DebugOut.Analog[17] = VarioMeter; |
| //DebugOut.Analog[18] = HoehenWertF; |
| //DebugOut.Analog[25] = Parameter_Hoehe_P; |
| //DebugOut.Analog[26] = Parameter_Luftdruck_D; |
| } |
| 278,7 → 274,10 |
| //############################################################################ |
| // Nullwerte ermitteln |
| unsigned char SetNeutral(unsigned char AccAdjustment) // retuns: "sucess" |
| // Parameter: 0 -> after switch on (ignore ACC-Z fault) |
| // Parameter: 1 -> before Start |
| // Parameter: 2 -> calibrate and store ACC |
| unsigned char SetNeutral(unsigned char AdjustmentMode) // retuns: "sucess" |
| //############################################################################ |
| { |
| unsigned char i, sucess = 1; |
| 325,7 → 324,7 |
| StartNeutralRoll = AdNeutralRoll; |
| StartNeutralNick = AdNeutralNick; |
| if(AccAdjustment) |
| if(AdjustmentMode == 2) |
| { |
| NeutralAccX = abs(Mittelwert_AccNick) / (2*ACC_AMPLIFY); |
| NeutralAccY = abs(Mittelwert_AccRoll) / (2*ACC_AMPLIFY); |
| 348,7 → 347,8 |
| sucess = 0; |
| } |
| } |
| MesswertNick = 0; |
| EEAR = EE_DUMMY; // Set the EEPROM Address pointer to an unused space |
| MesswertNick = 0; |
| MesswertRoll = 0; |
| MesswertGier = 0; |
| Delay_ms_Mess(100); |
| 380,15 → 380,15 |
| Poti[i] = PPM_in[EE_Parameter.Kanalbelegung[K_POTI1 + i]] + 127; |
| } |
| SenderOkay = 100; |
| if(ServoActive) |
| if(ServoActive) DDRD |=0x80; // enable J7 -> Servo signal |
| else |
| { |
| DDRD |=0x80; // enable J7 -> Servo signal |
| } |
| else |
| { |
| // if(EE_Parameter.ServoCompInvert & SERVO_NICK_INV) NickServoValue = ((128 + 60) * 4 * 16); // neutral position = upper 1/4 |
| // else |
| NickServoValue = ((128 - 60) * 4 * 16); // neutral position = lower 1/4 |
| if((EE_Parameter.ServoCompInvert & SERVO_NICK_INV) && (EE_Parameter.ServoCompInvert & SERVO_RELATIVE)) NickServoValue = 12000;//((128 + 60) * 4 * 16); // neutral position = upper 1/4// else |
| else NickServoValue = ((128 - 60) * 4 * 16); // neutral position = lower 1/4 |
| CalculateServoSignals = 1; |
| CalculateServo(); // nick |
| CalculateServo(); // roll |
| } |
| #if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__)) |
| 399,12 → 399,11 |
| CosAttitude = c_cos_8192(tilt1); |
| NeutralAccZ = (long)((long) (NeutralAccZ - 512) * 8192 + 4096) / CosAttitude + 512; |
| if(tilt1 > 20) sucess = 0; // calibration must be within 20° Tilt angle |
| if(ACC_AltitudeControl) if((NeutralAccZ < 682 - 25) || (NeutralAccZ > 682 + 25)) { VersionInfo.HardwareError[0] |= FC_ERROR0_ACC_TOP; sucess = 0;}; |
| if(AdjustmentMode != 0 && ACC_AltitudeControl) if((NeutralAccZ < 682 - 25) || (NeutralAccZ > 682 + 25)) { VersionInfo.HardwareError[0] |= FC_ERROR0_ACC_TOP; sucess = 0;}; |
| #else |
| NeutralAccZ = (int16_t)GetParamWord(PID_ACC_TOP); |
| EEAR = EE_DUMMY; // Set the EEPROM Address pointer to an unused space |
| #endif |
| if((AdNeutralNick < 150 * 16) || (AdNeutralNick > 850 * 16)) { VersionInfo.HardwareError[0] |= FC_ERROR0_GYRO_NICK; }; |
| if((AdNeutralRoll < 150 * 16) || (AdNeutralRoll > 850 * 16)) { VersionInfo.HardwareError[0] |= FC_ERROR0_GYRO_ROLL; }; |
| if((AdNeutralGier < 150 * 2) || (AdNeutralGier > 850 * 2)) { VersionInfo.HardwareError[0] |= FC_ERROR0_GYRO_YAW; }; |
| 604,8 → 603,15 |
| } |
| } |
| unsigned char GetChannelValue(unsigned char ch) // gives the unsigned value of the channel |
| { |
| int tmp2; |
| if(ch == 0) return(0); |
| tmp2 = PPM_in[ch] + 127; |
| if(tmp2 > 255) tmp2 = 255; else if(tmp2 < 0) tmp2 = 0; |
| return(tmp2); |
| } |
| //############################################################################ |
| // Trägt ggf. das Poti als Parameter ein |
| void ParameterZuordnung(void) |
| 636,14 → 642,14 |
| if(EE_Parameter.Servo3 == 247) { if(PORTC & (1<<PORTC2)) Parameter_Servo3 = 140; else Parameter_Servo3 = 70;} // Out1 (J16) |
| else if(EE_Parameter.Servo3 == 246) { if(PORTC & (1<<PORTC3)) Parameter_Servo3 = 140; else Parameter_Servo3 = 70;} |
| else CHK_POTI(Parameter_Servo3,EE_Parameter.Servo3); |
| else CHK_POTI_MM(Parameter_Servo3,EE_Parameter.Servo3, 24, 255); |
| if(EE_Parameter.Servo4 == 247) { if(PORTC & (1<<PORTC2)) Parameter_Servo4 = 140; else Parameter_Servo4 = 70;} |
| else if(EE_Parameter.Servo4 == 246) { if(PORTC & (1<<PORTC3)) Parameter_Servo4 = 140; else Parameter_Servo4 = 70;} // Out2 (J17) |
| else CHK_POTI(Parameter_Servo4,EE_Parameter.Servo4); |
| else CHK_POTI_MM(Parameter_Servo4,EE_Parameter.Servo4, 24, 255); |
| CHK_POTI(Parameter_Servo5,EE_Parameter.Servo5); |
| CHK_POTI(Parameter_HoehenSchalter,EE_Parameter.MaxHoehe); |
| CHK_POTI_MM(Parameter_Servo5,EE_Parameter.Servo5, 24, 255); |
| Parameter_HoehenSchalter = GetChannelValue(EE_Parameter.HoeheChannel); |
| CHK_POTI(Parameter_Hoehe_ACC_Wirkung,EE_Parameter.Hoehe_ACC_Wirkung); |
| CHK_POTI(Parameter_Hoehe_GPS_Z,EE_Parameter.Hoehe_GPS_Z); |
| CHK_POTI(Parameter_KompassWirkung,EE_Parameter.KompassWirkung); |
| 679,11 → 685,11 |
| MAX_GAS = EE_Parameter.Gas_Max; |
| MIN_GAS = EE_Parameter.Gas_Min; |
| tmp = EE_Parameter.CareFreeModeControl; |
| if(tmp > 50) |
| if(EE_Parameter.CareFreeChannel) |
| { |
| CareFree = 1; |
| if(tmp >= 248 && Poti[255 - tmp] < 50) CareFree = 0; |
| if(PPM_in[EE_Parameter.CareFreeChannel] < -64) CareFree = 0; |
| // if(tmp >= 248 && Poti[255 - tmp] < 50) CareFree = 0; |
| if(carefree_old != CareFree) |
| { |
| if(carefree_old < 3) |
| 713,7 → 719,7 |
| BeepMuster = 0xA400; |
| CareFree = 0; |
| } |
| if(CareFree) { FC_StatusFlags2 |= FC_STATUS2_CAREFREE; if(Parameter_AchsKopplung1 < 210) Parameter_AchsKopplung1 += 30;} else FC_StatusFlags2 &= ~FC_STATUS2_CAREFREE; |
| if(CareFree) { FC_StatusFlags2 |= FC_STATUS2_CAREFREE; /*if(Parameter_AchsKopplung1 < 210) Parameter_AchsKopplung1 += 30;*/} else FC_StatusFlags2 &= ~FC_STATUS2_CAREFREE; |
| } |
| //############################################################################ |
| 789,6 → 795,30 |
| // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| if(SenderOkay > 140) |
| { |
| #if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__)) |
| static unsigned int trigger = 1000; |
| static unsigned char old_switch = 100; |
| if(EE_Parameter.StartLandChannel && EE_Parameter.LandingSpeed) |
| { |
| if(PPM_in[EE_Parameter.StartLandChannel] > 50) |
| { |
| if(old_switch == 50) if(FC_StatusFlags2 & FC_STATUS2_WAIT_FOR_TAKEOFF) { FC_StatusFlags2 |= FC_STATUS2_AUTO_STARTING; SpeakHoTT = SPEAK_RISING;} |
| FC_StatusFlags2 &= ~FC_STATUS2_AUTO_LANDING; |
| old_switch = 150; |
| } |
| else |
| if(PPM_in[EE_Parameter.StartLandChannel] < -50) |
| { |
| if(old_switch == 150) { FC_StatusFlags2 |= FC_STATUS2_AUTO_LANDING; SpeakHoTT = SPEAK_SINKING;} |
| FC_StatusFlags2 &= ~FC_STATUS2_AUTO_STARTING; |
| old_switch = 50; |
| } |
| else |
| { |
| FC_StatusFlags2 &= ~(FC_STATUS2_AUTO_STARTING | FC_STATUS2_AUTO_LANDING); |
| } |
| } |
| #endif |
| FC_StatusFlags &= ~FC_STATUS_EMERGENCY_LANDING; |
| RcLostTimer = EE_Parameter.NotGasZeit * 50; |
| if(GasMischanteil > 40 && MotorenEin) |
| 802,6 → 832,9 |
| sollGier = 0; |
| Mess_Integral_Gier = 0; |
| FC_StatusFlags2 |= FC_STATUS2_WAIT_FOR_TAKEOFF; |
| #if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__)) |
| old_switch = 100; |
| #endif |
| } |
| else |
| { |
| 808,21 → 841,31 |
| FC_StatusFlags |= FC_STATUS_FLY; |
| if(FC_StatusFlags2 & FC_STATUS2_WAIT_FOR_TAKEOFF) |
| { |
| /* |
| if(Parameter_UserParam3 > 50) |
| { |
| FromNC_AltitudeSpeed = 15; |
| FromNC_AltitudeSetpoint = 500; |
| } |
| #if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__)) |
| if((NC_To_FC_Flags & NC_TO_FC_AUTOSTART || FC_StatusFlags2 & FC_STATUS2_AUTO_STARTING) && (VarioCharacter == '=') && ACC_AltitudeControl) |
| { |
| FromNC_AltitudeSpeed = 80; |
| FromNC_AltitudeSetpoint = 500; |
| SollHoehe = 500; |
| trigger = 1000; |
| if(NC_To_FC_Flags & NC_TO_FC_AUTOSTART) SpeakHoTT = SPEAK_NEXT_WP; |
| /* if(StartTrigger != 2) |
| { |
| StartTrigger = 1; |
| if(HoverGas < STICK_GAIN * 35) HoverGas = STICK_GAIN * 35; |
| } |
| */ |
| if(HoehenWert > 150 || HoehenWert < -350 || !(Parameter_GlobalConfig & CFG_HOEHENREGELUNG)) |
| } |
| // else FC_StatusFlags2 &= ~(FC_STATUS2_AUTO_STARTING); |
| #endif |
| if(HoehenWertF > 150 || HoehenWert < -350 || !(Parameter_GlobalConfig & CFG_HOEHENREGELUNG)) |
| { |
| FC_StatusFlags2 &= ~FC_STATUS2_WAIT_FOR_TAKEOFF; |
| #if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__)) |
| SpeakHoTT = SPEAK_RISING; |
| //SollHoehe = 250; |
| trigger = 1000; |
| if(FC_StatusFlags2 & FC_STATUS2_AUTO_STARTING) { FromNC_AltitudeSpeed = 0; SollHoehe = 300;/*HoehenWertF + 100;*/} |
| else SpeakHoTT = SPEAK_RISING; |
| #endif |
| beeptime = 5000; |
| FC_StatusFlags2 &= ~(FC_STATUS2_WAIT_FOR_TAKEOFF | FC_STATUS2_AUTO_STARTING | FC_STATUS2_AUTO_LANDING); |
| } |
| SummeNick = 0; |
| SummeRoll = 0; |
| 830,23 → 873,39 |
| // sollGier = 0; |
| if(modell_fliegt > 1000) modell_fliegt = 1000; // for the Hooverpoint-Estimation |
| } |
| /* |
| else |
| if(Parameter_UserParam3 > 150) |
| { |
| if(HoehenWert > 2500) FromNC_AltitudeSpeed = 30; |
| else |
| if(HoehenWert > 1500) FromNC_AltitudeSpeed = 30; |
| else |
| { |
| FromNC_AltitudeSpeed = 10; |
| SummeNick -= SummeNick / 4; |
| SummeRoll -= SummeRoll / 4; |
| } |
| FromNC_AltitudeSetpoint = -300; |
| } |
| */ |
| } |
| else // Flying mode |
| { |
| #if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__)) |
| if((FC_StatusFlags2 & FC_STATUS2_AUTO_LANDING) && (VarioCharacter == 'v' || VarioCharacter == '=') && ACC_AltitudeControl) |
| { |
| FromNC_AltitudeSpeed = EE_Parameter.LandingSpeed; |
| FromNC_AltitudeSetpoint = -20000; |
| } |
| if(trigger < 1000) |
| { |
| trigger++; |
| SummeNick = 0; |
| SummeRoll = 0; |
| Mess_Integral_Gier = 0; |
| SollHoehe = HoehenWertF - 300; |
| if(trigger == 1000 && FC_StatusFlags2 & FC_STATUS2_AUTO_LANDING && VarioCharacter != '+') |
| { |
| FC_StatusFlags2 &= ~FC_STATUS2_AUTO_LANDING; |
| FC_StatusFlags2 |= FC_STATUS2_WAIT_FOR_TAKEOFF; // go back into starting state |
| } |
| } |
| else |
| if(ACC_AltitudeControl && (VarioCharacter == 'v' || VarioCharacter == '-') && HoehenWert < 1000 /*&& FromNC_AltitudeSetpoint < 0*/) |
| { |
| if(Aktuell_az > 940) |
| { |
| trigger = 0; |
| SpeakHoTT = SPEAK_LANDING; |
| }; |
| } |
| #endif |
| } |
| } // end of: modell_fliegt > 256 |
| if((PPM_in[EE_Parameter.Kanalbelegung[K_GAS]] > 80) && MotorenEin == 0) |
| { |
| // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| 876,7 → 935,7 |
| } |
| else |
| { |
| ParamSet_ReadFromEEProm(GetActiveParamSet()); |
| ParamSet_ReadFromEEProm(ActiveParamSet); |
| LipoDetection(0); |
| LIBFC_ReceiverInit(EE_Parameter.Receiver); |
| if((Parameter_GlobalConfig & CFG_HOEHENREGELUNG)) // Höhenregelung aktiviert? |
| 883,8 → 942,7 |
| { |
| if((MessLuftdruck > 950) || (MessLuftdruck < 750)) SucheLuftruckOffset(); |
| } |
| // ServoActive = 0; |
| CalibrationDone = SetNeutral(0); |
| CalibrationDone = SetNeutral(1); |
| ServoActive = 1; |
| DDRD |=0x80; // enable J7 -> Servo signal |
| #if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__)) |
| 892,8 → 950,9 |
| else |
| if(!CalibrationDone) SpeakHoTT = SPEAK_ERR_CALIBARTION; |
| else SpeakHoTT = SPEAK_CALIBRATE; |
| ShowSettingNameTime = 5; // for HoTT & Jeti |
| #endif |
| Piep(GetActiveParamSet(),120); |
| Piep(ActiveParamSet,120); |
| } |
| } |
| } |
| 905,7 → 964,7 |
| MotorenEin = 0; |
| delay_neutral = 0; |
| modell_fliegt = 0; |
| CalibrationDone = SetNeutral(1); |
| CalibrationDone = SetNeutral(2); // store ACC values into EEPROM |
| #if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__)) |
| if(VersionInfo.HardwareError[0]) SpeakHoTT = SPEAK_ERR_SENSOR; |
| else |
| 912,7 → 971,7 |
| if(!CalibrationDone) SpeakHoTT = SPEAK_ERR_CALIBARTION; |
| else SpeakHoTT = SPEAK_CALIBRATE; |
| #endif |
| Piep(GetActiveParamSet(),120); |
| Piep(ActiveParamSet,120); |
| } |
| } |
| else delay_neutral = 0; |
| 920,7 → 979,7 |
| // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // Gas ist unten |
| // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| if(PPM_in[EE_Parameter.Kanalbelegung[K_GAS]] < 35-120) |
| if(PPM_in[EE_Parameter.Kanalbelegung[K_GAS]] < -100) |
| { |
| if(PPM_diff[EE_Parameter.MotorSafetySwitch & 127] > 5) move_safety_switch = 100; |
| else |
| 928,7 → 987,7 |
| // Motoren Starten |
| if(!MotorenEin) |
| { |
| if((((PPM_in[EE_Parameter.Kanalbelegung[K_GIER]] < -75) && ((!(EE_Parameter.GlobalConfig3 & CFG3_MOTOR_SWITCH_MODE) && PPM_in[EE_Parameter.MotorSafetySwitch] < -75) || EE_Parameter.MotorSafetySwitch == 0))) |
| if((((PPM_in[EE_Parameter.Kanalbelegung[K_GIER]] < -100) && ((!(EE_Parameter.GlobalConfig3 & CFG3_MOTOR_SWITCH_MODE) && PPM_in[EE_Parameter.MotorSafetySwitch] < -75) || EE_Parameter.MotorSafetySwitch == 0))) |
| || (((EE_Parameter.GlobalConfig3 & CFG3_MOTOR_SWITCH_MODE) && PPM_in[EE_Parameter.MotorSafetySwitch] > -10 && move_safety_switch == 100))) |
| { |
| // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| 939,6 → 998,7 |
| HoehenWertF = 0; |
| HoehenWert = 0; |
| SummenHoehe = 0; |
| if((PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] > -100 || abs(PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]]) < 100) && EE_Parameter.MotorSafetySwitch == 0) delay_einschalten = 0; |
| if(++delay_einschalten > 253) |
| { |
| delay_einschalten = 0; |
| 978,16 → 1038,28 |
| else // only if motors are running |
| { |
| // if((PPM_in[EE_Parameter.Kanalbelegung[K_GIER]] > 75) && (PPM_in[EE_Parameter.MotorSafetySwitch] < -75 || EE_Parameter.MotorSafetySwitch == 0)) |
| if((((PPM_in[EE_Parameter.Kanalbelegung[K_GIER]] > 75) && ((!(EE_Parameter.GlobalConfig3 & CFG3_MOTOR_SWITCH_MODE) && PPM_in[EE_Parameter.MotorSafetySwitch] < -75) || EE_Parameter.MotorSafetySwitch == 0))) |
| if((((PPM_in[EE_Parameter.Kanalbelegung[K_GIER]] > 100) && ((!(EE_Parameter.GlobalConfig3 & CFG3_MOTOR_SWITCH_MODE) && PPM_in[EE_Parameter.MotorSafetySwitch] < -75) || EE_Parameter.MotorSafetySwitch == 0))) |
| || (((EE_Parameter.GlobalConfig3 & CFG3_MOTOR_SWITCH_MODE) && PPM_in[EE_Parameter.MotorSafetySwitch] < -50 && move_safety_switch == -100))) |
| { |
| if((PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] > -100 || abs(PPM_in[EE_Parameter.Kanalbelegung[K_ROLL]]) < 100) && EE_Parameter.MotorSafetySwitch == 0) |
| { |
| delay_ausschalten = 0; |
| } |
| else |
| { |
| SummeNick = 0; |
| SummeRoll = 0; |
| StickNick = 0; |
| StickRoll = 0; |
| } |
| if(++delay_ausschalten > 250) // nicht sofort |
| { |
| MotorenEin = 0; |
| delay_ausschalten = 0; |
| modell_fliegt = 0; |
| FC_StatusFlags2 &= ~(FC_STATUS2_WAIT_FOR_TAKEOFF | FC_STATUS2_AUTO_STARTING | FC_STATUS2_AUTO_LANDING); |
| #if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__)) |
| SpeakHoTT = SPEAK_MK_OFF; |
| SpeakHoTT = SPEAK_MK_OFF; |
| #endif |
| } |
| } |
| 1197,7 → 1269,7 |
| if(!Looping_Nick && !Looping_Roll && (Aktuell_az > 512 || MotorenEin)) |
| { |
| long tmp_long, tmp_long2; |
| if(FromNaviCtrl_Value.Kalman_K > 0 /*&& !TrichterFlug*/) |
| if(FromNaviCtrl_Value.Kalman_K > 0 /*&& Parameter_UserParam1 < 100*/) |
| { |
| tmp_long = (long)(IntegralNick / EE_Parameter.GyroAccFaktor - (long)(Mittelwert_AccNick - FromNaviCtrl.AccErrorN)); |
| tmp_long2 = (long)(IntegralRoll / EE_Parameter.GyroAccFaktor - (long)(Mittelwert_AccRoll - FromNaviCtrl.AccErrorR)); |
| 1488,12 → 1560,11 |
| // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| // Höhenregelung |
| // Die Höhenregelung schwächt lediglich das Gas ab, erhöht es allerdings nicht |
| // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| if(UBat > BattLowVoltageWarning) GasMischanteil = ((unsigned int)GasMischanteil * BattLowVoltageWarning) / UBat; // Gas auf das aktuelle Spannungvieveau beziehen |
| GasMischanteil *= STICK_GAIN; |
| // if height control is activated |
| if((Parameter_GlobalConfig & CFG_HOEHENREGELUNG) && !(Looping_Roll || Looping_Nick)) // Höhenregelung |
| if((Parameter_GlobalConfig & CFG_HOEHENREGELUNG) && !(Looping_Roll || Looping_Nick) && !(VersionInfo.HardwareError[0] & 0x7F)) // Höhenregelung |
| { |
| #define HOVER_GAS_AVERAGE 16384L // 16384 * 2ms = 32s averaging |
| #define HC_GAS_AVERAGE 4 // 4 * 2ms= 8ms averaging |
| 1509,8 → 1580,6 |
| static unsigned long HoverGasFilter = 0; |
| static unsigned char delay = 100, BaroAtUpperLimit = 0, BaroAtLowerLimit = 0; |
| // get the current hooverpoint |
| DebugOut.Analog[21] = HoverGas; |
| // Expand the measurement |
| // measurement of air pressure close to upper limit and no overflow in correction of the new OCR0A value occurs |
| 1719,7 → 1788,7 |
| else SollHoehe -= EE_Parameter.Hoehe_Verstaerkung / 3; |
| } |
| HeightTrimming = 0; |
| LIMIT_MIN_MAX(SollHoehe, (HoehenWertF-1024), (HoehenWertF+1024)); // max. 10m Unterschied |
| LIMIT_MIN_MAX(SollHoehe, (HoehenWert-1024), (HoehenWert+1024)); // max. 10m Unterschied |
| if(Parameter_ExtraConfig & CFG2_VARIO_BEEP) beeptime = 100; |
| //update hoover gas stick value when setpoint is shifted |
| if(!EE_Parameter.Hoehe_StickNeutralPoint && FromNC_AltitudeSpeed == 0) |
| 1829,6 → 1898,7 |
| } |
| else GasMischanteil = FilterHCGas + (GasMischanteil - HoverGas) / 4; // only in Vario-Mode |
| } |
| #if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__)) |
| else // ACC-Altitude control |
| { |
| // from this point the Heigth Control Algorithm is identical for both versions |
| 1859,7 → 1929,6 |
| LIMIT_MIN_MAX(tmp_long,-511 * STICK_GAIN, 512 * STICK_GAIN); |
| GasReduction += tmp_long; |
| } // EOF no baro range expanding |
| DebugOut.Analog[19] = -GasReduction; |
| HCGas -= GasReduction; |
| LIMIT_MIN_MAX(HCGas, HoverGasMin, HoverGasMax); // limits gas around hover point |
| // strech control output by inverse attitude projection 1/cos |
| 1880,6 → 1949,7 |
| } |
| else GasMischanteil = FilterHCGas; |
| } // end of ACC-Altitude control |
| #endif |
| } |
| }// EOF height control active |
| else // HC not active |
| 1902,7 → 1972,7 |
| if((FC_StatusFlags & FC_STATUS_FLY))// && !(FC_SatusFlags & FC_STATUS_EMERGENCY_LANDING)) |
| { |
| //if(HoverGasFilter == 0 || StartTrigger == 1) HoverGasFilter = HOVER_GAS_AVERAGE * (unsigned long)(GasMischanteil); // init estimation |
| if(HoverGasFilter == 0 || StartTrigger == 1) HoverGasFilter = HOVER_GAS_AVERAGE * (unsigned long)(HoverGas); // neu |
| if(HoverGasFilter == 0 || StartTrigger == 1) HoverGasFilter = HOVER_GAS_AVERAGE * (unsigned long)(HoverGas); // 0.90f: geändert |
| if(StartTrigger == 1) StartTrigger = 2; |
| tmp_long2 = (int32_t)GasMischanteil; // take current thrust |
| tmp_long2 *= CosAttitude; // apply attitude projection |
| /test_branches/FC2_2/fc.h |
|---|
| 27,13 → 27,18 |
| #define FC_STATUS2_OUT1_ACTIVE 0x08 |
| #define FC_STATUS2_OUT2_ACTIVE 0x10 |
| #define FC_STATUS2_WAIT_FOR_TAKEOFF 0x20 // Motor Running, but still on the ground |
| #define FC_STATUS2_AUTO_STARTING 0x40 |
| #define FC_STATUS2_AUTO_LANDING 0x80 |
| //NC_To_FC_Flags |
| #define NC_TO_FC_FLYING_RANGE 0x01 |
| #define NC_TO_FC_EMERGENCY_LANDING 0x02 |
| #define NC_TO_FC_AUTOSTART 0x04 |
| #define NC_TO_FC_AUTOLANDING 0x08 // not used |
| extern volatile unsigned char FC_StatusFlags, FC_StatusFlags2; |
| extern void ParameterZuordnung(void); |
| extern unsigned char GetChannelValue(unsigned char ch); // gives the unsigned value of the channel |
| #define Poti1 Poti[0] |
| #define Poti2 Poti[1] |
| 119,7 → 124,7 |
| extern signed char WaypointTrimming; |
| extern int HoverGas; |
| extern unsigned char Parameter_Luftdruck_D; |
| extern unsigned char Parameter_MaxHoehe; |
| //extern unsigned char Parameter_MaxHoehe; |
| extern unsigned char Parameter_Hoehe_P; |
| extern unsigned char Parameter_Hoehe_ACC_Wirkung; |
| extern unsigned char Parameter_KompassWirkung; |
| /test_branches/FC2_2/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="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><File path="hottmenu.c"></File><File path="hottmenu.h"></File></Project> |
| /test_branches/FC2_2/hottmenu.c |
|---|
| 79,6 → 79,7 |
| #define HOTT_KEY_SET 6 |
| #define HOTT_KEY_LEFT 8 |
| #define VARIO_ZERO 30000 |
| unsigned char NaviData_WaypointIndex = 0, NaviData_WaypointNumber = 0, NaviData_TargetHoldTime = 0; |
| unsigned int NaviData_TargetDistance = 0; |
| 88,10 → 89,11 |
| ElectricAirPacket_t ElectricAirPacket; |
| HoTTGeneral_t HoTTGeneral; |
| unsigned char SpeakHoTT = SPEAK_MIKROKOPTER; |
| unsigned char ToNC_SpeakHoTT = 0; |
| unsigned char ToNC_SpeakHoTT = 0, ShowSettingNameTime = 0; |
| int HoTTVarioMeter = 0; |
| const char PROGMEM MIKROKOPTER[] = {" MikroKopter "}; |
| const char PROGMEM UNDERVOLTAGE[] = {" !! LiPo voltage !! "}; |
| const char PROGMEM SETTING[] = {"Set :"}; |
| const char PROGMEM NC_ERROR_TEXT[MAX_ERR_NUMBER][17] = |
| { |
| //0123456789123456 |
| 276,32 → 278,31 |
| unsigned int BuildHoTT_Vario(void) |
| { |
| unsigned int tmp = 30000; |
| unsigned int tmp = VARIO_ZERO; |
| if(VarioCharacter == '+' || VarioCharacter == '-') |
| { |
| tmp = 30000 + (AltitudeSetpointTrimming * EE_Parameter.Hoehe_Verstaerkung) / 3; |
| if(tmp < 30000 && tmp > 30000 - 50) tmp = 30000 - 50; // weil es sonst erst bei < 0,5m/sek piept |
| tmp = VARIO_ZERO + (AltitudeSetpointTrimming * EE_Parameter.Hoehe_Verstaerkung) / 3; |
| if(tmp < VARIO_ZERO && tmp > VARIO_ZERO - 50) tmp = VARIO_ZERO - 50; // weil es sonst erst bei < 0,5m/sek piept |
| } |
| else |
| if((VarioCharacter == ' ') && (FC_StatusFlags & FC_STATUS_FLY)) |
| { |
| tmp = 30000 + HoTTVarioMeter; |
| if(tmp > 30000) |
| tmp = VARIO_ZERO + HoTTVarioMeter; |
| if(tmp > VARIO_ZERO) |
| { |
| if(tmp < 30000 + 100) tmp = 30000; |
| if(tmp < VARIO_ZERO + 100) tmp = VARIO_ZERO; |
| else tmp -= 100; |
| } |
| if(tmp < 30000) |
| if(tmp < VARIO_ZERO) |
| { |
| if(tmp > 30000 - 100) tmp = 30000; |
| if(tmp > VARIO_ZERO - 100) tmp = VARIO_ZERO; |
| else tmp += 100; |
| } |
| } |
| else |
| if(VarioCharacter == '^') tmp = 30000 + FromNC_AltitudeSpeed * 10; |
| if(VarioCharacter == '^') tmp = VARIO_ZERO + FromNC_AltitudeSpeed * 10; |
| else |
| if(VarioCharacter == 'v') tmp = 30000 - FromNC_AltitudeSpeed * 10; |
| if(VarioCharacter == 'v') tmp = VARIO_ZERO - FromNC_AltitudeSpeed * 10; |
| return(tmp); |
| } |
| 308,14 → 309,14 |
| //--------------------------------------------------------------- |
| unsigned char HoTT_Telemety(unsigned char packet_request) |
| { |
| unsigned char i; |
| unsigned char i; |
| //Debug("rqst: %02X",packet_request); |
| switch(packet_request) |
| { |
| case HOTT_VARIO_PACKET_ID: |
| GPSPacket.WarnBeep = HoTT_Waring(); // Achtung: das ist richtig hier, damit der Varioton schon vorher abgestellt wird |
| VarioPacket.Altitude = HoehenWert/100 + 500; |
| VarioPacket.m_sec = BuildHoTT_Vario(); |
| if(!GPSPacket.WarnBeep) VarioPacket.m_sec = BuildHoTT_Vario(); else VarioPacket.m_sec = VARIO_ZERO; |
| VarioPacket.m_3sec = VarioPacket.m_sec; |
| VarioPacket.m_10sec = VarioPacket.m_sec; |
| if (VarioPacket.Altitude < VarioPacket.MinAltitude) VarioPacket.MinAltitude = VarioPacket.Altitude; |
| 334,6 → 335,16 |
| } |
| else |
| if(FC_StatusFlags & FC_STATUS_LOWBAT) for(i=0; i<21;i++) VarioPacket.Text[i] = pgm_read_byte(&UNDERVOLTAGE[i]); // no Error |
| else |
| if(ShowSettingNameTime) // no Error |
| { |
| for(i=0; i<sizeof(SETTING);i++) VarioPacket.Text[i] = pgm_read_byte(&SETTING[i]); |
| VarioPacket.Text[4] = '0' + ActiveParamSet; |
| for(i=0; i<sizeof(EE_Parameter.Name);i++) VarioPacket.Text[i+7] = EE_Parameter.Name[i]; // no Error |
| VarioPacket.Text[18] = ' '; |
| VarioPacket.Text[19] = ' '; |
| VarioPacket.Text[20] = ' '; |
| } |
| else |
| if(NaviData_WaypointNumber) |
| { |
| 362,12 → 373,21 |
| VarioPacket.Text[17] = '0'+(tmp) % 10; |
| VarioPacket.Text[18] = 's'; |
| VarioPacket.Text[19] = ' '; |
| //unsigned char NaviData_WaypointIndex = 0, NaviData_WaypointNumber = 0, NaviData_TargetHoldTime = 0; |
| //unsigned int NaviData_TargetDistance = 0; |
| } |
| else |
| for(i=0; i<21;i++) VarioPacket.Text[i] = pgm_read_byte(&MIKROKOPTER[i]); // no Error |
| if(!CalibrationDone) |
| { |
| for(i=0; i<17;i++) VarioPacket.Text[i] = pgm_read_byte(&MIKROKOPTER[i+2]); // no Error and not calibrated |
| VarioPacket.Text[16] = '0'+VERSION_MAJOR; |
| VarioPacket.Text[17] = '.'; |
| VarioPacket.Text[18] = '0'+VERSION_MINOR/10; |
| VarioPacket.Text[19] = '0'+VERSION_MINOR%10; |
| VarioPacket.Text[20] = 'a'+VERSION_PATCH; |
| } |
| else |
| { |
| for(i=0; i<21;i++) VarioPacket.Text[i] = pgm_read_byte(&MIKROKOPTER[i]); // no Error |
| } |
| return(sizeof(VarioPacket)); |
| break; |
| 376,10 → 396,10 |
| // GPSPacket.Distance = GPSInfo.HomeDistance/10; // macht die NC |
| // GPSPacket.Heading = GPSInfo.HomeBearing/2; // macht die NC |
| // GPSPacket.Speed = (GPSInfo.Speed * 36) / 10; // macht die NC |
| GPSPacket.m_sec = BuildHoTT_Vario(); |
| // GPSPacket.WarnBeep = HoTT_Waring(); //(wird jetzt weiter oben gemacht) |
| if(!GPSPacket.WarnBeep) GPSPacket.m_sec = BuildHoTT_Vario(); else GPSPacket.m_sec = VARIO_ZERO; |
| GPSPacket.m_3sec = 120; |
| GPSPacket.NumOfSats = GPSInfo.NumOfSats; |
| GPSPacket.WarnBeep = HoTT_Waring(); |
| if(GPSInfo.Flags & FLAG_DIFFSOLN) GPSPacket.SatFix = 'D'; |
| else |
| if(GPSInfo.SatFix == SATFIX_3D) GPSPacket.SatFix = ' '; |
| 401,7 → 421,7 |
| ElectricAirPacket.VoltageCell7 = GPSInfo.HomeDistance/20; |
| ElectricAirPacket.VoltageCell13 = ElectricAirPacket.VoltageCell6; |
| ElectricAirPacket.VoltageCell14 = ElectricAirPacket.VoltageCell7; |
| ElectricAirPacket.m_sec = BuildHoTT_Vario(); |
| if(!GPSPacket.WarnBeep) ElectricAirPacket.m_sec = BuildHoTT_Vario(); else ElectricAirPacket.m_sec = VARIO_ZERO; |
| ElectricAirPacket.m_3sec = 120; |
| ElectricAirPacket.InputVoltage = UBat; |
| ElectricAirPacket.Temperature1 = MinBlTempertaure + 20; |
| 426,7 → 446,7 |
| HoTTGeneral.Altitude = HoehenWert/100 + 500; |
| HoTTGeneral.Battery1 = UBat; |
| HoTTGeneral.Battery2 = UBat; |
| HoTTGeneral.m_sec = BuildHoTT_Vario(); |
| if(!GPSPacket.WarnBeep) HoTTGeneral.m_sec = BuildHoTT_Vario(); else HoTTGeneral.m_sec = VARIO_ZERO; |
| HoTTGeneral.m_3sec = 120; |
| HoTTGeneral.InputVoltage = UBat; |
| HoTTGeneral.Temperature1 = MinBlTempertaure + 20; |
| 687,7 → 707,7 |
| switch(line++) |
| { |
| case 0: |
| HoTT_printfxy_INV(0,0,"Setting:%u %s ",GetActiveParamSet(),EE_Parameter.Name); |
| HoTT_printfxy_INV(0,0,"Setting:%u %s ",ActiveParamSet,EE_Parameter.Name); |
| break; |
| case 1: HoTT_printfxy(0,1,"Min:%2i.%1iV %s ",BattLowVoltageWarning/10, BattLowVoltageWarning%10, Mixer.Name); |
| break; |
| 706,7 → 726,7 |
| HoTT_printf("DISABLED"); |
| break; |
| case 3: HoTT_printfxy(0,3,"CF:"); |
| if(!EE_Parameter.CareFreeModeControl) HoTT_printf("DISABLED") |
| if(!EE_Parameter.CareFreeChannel) HoTT_printf("DISABLED") |
| else |
| { |
| if(CareFree) HoTT_printf(" (ON) ") else HoTT_printf(" (OFF)"); |
| 717,7 → 737,7 |
| if(!(Parameter_GlobalConfig & CFG_GPS_AKTIV)) HoTT_printf("DISABLED") |
| else |
| { |
| CHK_POTI(tmp,EE_Parameter.NaviGpsModeControl); |
| tmp = GetChannelValue(EE_Parameter.NaviGpsModeChannel); |
| if(tmp < 50) HoTT_printf("(FREE)") |
| else |
| if(tmp >= 180) HoTT_printf("(HOME)") |
| /test_branches/FC2_2/hottmenu.h |
|---|
| 48,7 → 48,7 |
| extern unsigned char HottKeyboard,HoTT_RequestedSensor; |
| extern unsigned char HottUpdate(unsigned char key); |
| extern unsigned char SpeakHoTT; |
| extern unsigned char SpeakHoTT,ShowSettingNameTime; |
| extern unsigned char ToNC_SpeakHoTT; |
| extern volatile unsigned char *HoTT_DataPointer; |
| extern unsigned char MaxBlTempertaure; |
| /test_branches/FC2_2/jeti_ex.c |
|---|
| 69,7 → 69,8 |
| { |
| // Label[10] unit[3], data type, Data , position of decimal point |
| // "1234567890", "123", |
| { "-=.M_K.=-" , " ", 1, 0 , 0 }, // first one is device name // datatype 1 = -8192...8192 |
| // { "-=.M_K.=-" , " ", 1, 0 , 0 }, // first one is device name // datatype 1 = -8192...8192 |
| { "MK " , " ", 1, 0 , 0 }, // first one is device name // datatype 1 = -8192...8192 |
| { "Voltage " , "V ", 1, 0 , 1 }, // ID 1 |
| { "Current " , "A ", 1, 0 , 1 }, // ID 2 |
| { "Capacity " , "Ah ", 1, 0 , 2 }, // ID 3 |
| /test_branches/FC2_2/jetimenu.c |
|---|
| 99,11 → 99,19 |
| else |
| { |
| JetiBox_printfxy(6,0,"ERROR: %2d ",NC_ErrorCode); |
| if(MotorenEin) JetiBeep = 'O'; |
| // if(MotorenEin) JetiBeep = 'O'; |
| } |
| } |
| else |
| if(ShowSettingNameTime) |
| { |
| LIBFC_JetiBox_Clear(); |
| JetiBox_printfxy(0,1,"Set%d:%s ",ActiveParamSet,EE_Parameter.Name); |
| return; // nichts weiter ausgeben |
| } |
| #else |
| if(NC_ErrorCode) { JetiBox_printfxy(6,0,"ERROR: %2d ",NC_ErrorCode); if(MotorenEin) JetiBeep = 'O';}; |
| if(NC_ErrorCode) { JetiBox_printfxy(6,0,"ERROR: %2d ",NC_ErrorCode); if(MotorenEin) JetiBeep = 'S';}; |
| #endif |
| JetiBox_printfxy(0,1,"%4i %2i:%02i",Capacity.UsedCapacity,FlugSekunden/60,FlugSekunden%60); |
| if(Parameter_GlobalConfig & CFG_HOEHENREGELUNG) |
| /test_branches/FC2_2/led.c |
|---|
| 25,10 → 25,11 |
| static unsigned char J17Bitmask = 0; |
| static unsigned char J16Warn = 0, J17Warn = 0; |
| static unsigned char from_nc = 0; |
| if(FromNC_WP_EventChannel != -127) { from_nc = (unsigned char) FromNC_WP_EventChannel + 127; /*beeptime = 300;*/}; |
| if(!delay--) // 20ms Intervall |
| { |
| delay = 9; |
| if(FromNC_WP_EventChannel != -127) from_nc = (unsigned char) FromNC_WP_EventChannel + 127; |
| if(FC_StatusFlags & (FC_STATUS_LOWBAT | FC_STATUS_EMERGENCY_LANDING) || (VersionInfo.HardwareError[1] & FC_ERROR1_I2C)) |
| { |
| if(EE_Parameter.WARN_J16_Bitmask) |
| 120,7 → 121,7 |
| if(J17Mask & EE_Parameter.WARN_J17_Bitmask) J17_ON; else J17_OFF; |
| } |
| if(PORTC & (1<<PORTC2)) FC_StatusFlags2 |= FC_STATUS2_OUT1_ACTIVE; else FC_StatusFlags2 &= ~FC_STATUS2_OUT1_ACTIVE; // Out1 (J16) |
| if(PORTC & (1<<PORTC2)) FC_StatusFlags2 |= FC_STATUS2_OUT1_ACTIVE; //else FC_StatusFlags2 &= ~FC_STATUS2_OUT1_ACTIVE; // Out1 (J16) -> wird in der SPI zurück gesetzt |
| if(PORTC & (1<<PORTC3)) FC_StatusFlags2 |= FC_STATUS2_OUT2_ACTIVE; else FC_StatusFlags2 &= ~FC_STATUS2_OUT2_ACTIVE; // Out2 (J17) |
| } |
| } |
| /test_branches/FC2_2/libfc.h |
|---|
| 8,7 → 8,6 |
| #define CPU_ATMEGA1284P 4 |
| extern void LIBFC_Init(unsigned char); |
| //extern long ACC_AltitudeFusion(unsigned char init); |
| extern void LIBFC_Polling(void); |
| extern void LIBFC_ReceiverInit(unsigned char rtype); |
| 18,4 → 17,8 |
| extern void LIBFC_CheckSettings(void); |
| extern unsigned char LIBFC_GetCPUType(void); |
| #if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__)) |
| //extern long ACC_AltitudeFusion(unsigned char init); |
| #endif |
| #endif //_LIBFC_H |
| /test_branches/FC2_2/libfc1284.a |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| /test_branches/FC2_2/libfc644.a |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| /test_branches/FC2_2/main.c |
|---|
| 59,6 → 59,7 |
| pVoidFnct_pVoidFnctChar_const_fmt _printf_P; |
| unsigned char FoundMotors = 0; |
| unsigned char JetiBeep = 0; // to allow any Morse-Beeping of the Jeti-Box |
| unsigned char ActiveParamSet = 3; |
| void PrintLine(void) |
| { |
| 116,13 → 117,14 |
| //############################################################################ |
| { |
| unsigned int timer,i,timer2 = 0, timerPolling; |
| unsigned char update_spi = 1; |
| DDRB = 0x00; |
| PORTB = 0x00; |
| PORTB = 0x00; |
| DDRD = 0x0A; // UART & J3 J4 J5 |
| PORTD = 0x5F; // PPM-Input & UART |
| for(timer = 0; timer < 1000; timer++); // verzögern |
| #if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__)) |
| unsigned char AccZ_ErrorCnt = 0; |
| if(PINB & 0x02) |
| { |
| if(PIND & 0x10) PlatinenVersion = 21; // No Bridge from J4 to GND |
| 132,7 → 134,6 |
| { |
| PlatinenVersion = 23; ACC_AltitudeControl = 1; |
| } |
| #else |
| if(PINB & 0x01) |
| { |
| 149,7 → 150,6 |
| PORTD = 0x47; // |
| } |
| } |
| #endif |
| DDRC = 0x81; // I2C, Spaker |
| 253,7 → 253,6 |
| FlugMinutenGesamt = 0; |
| } |
| printf("\n\rFlight-time %u min Total:%u min", FlugMinuten, FlugMinutenGesamt); |
| LcdClear(); |
| I2CTimeout = 5000; |
| WinkelOut.Orientation = 1; |
| 265,13 → 264,15 |
| timerPolling = SetDelay(250); |
| Debug(ANSI_CLEAR "FC-Start!\n\rFlugzeit: %d min", FlugMinutenGesamt); // Note: this won't waste flash memory, if #DEBUG is not active |
| //printf("\n\rEE_Parameter size:%i\n\r", PARAMSET_STRUCT_LEN); |
| DebugOut.Status[0] = 0x01 | 0x02; |
| JetiBeep = 0; |
| if(EE_Parameter.ExtraConfig & CFG_NO_RCOFF_BEEPING) DisableRcOffBeeping = 1; |
| while (1) |
| EEAR = EE_DUMMY; // Set the EEPROM Address pointer to an unused space |
| while(1) |
| { |
| if(ReceiverUpdateModeActive) while (1) PORTC &= ~(1<<7); // Beeper off |
| //GRN_ON; |
| if(UpdateMotor && AdReady) // ReglerIntervall |
| { |
| 333,6 → 334,18 |
| if(EE_Parameter.Receiver == RECEIVER_HOTT) HoTT_Menu(); |
| else |
| if(EE_Parameter.Receiver == RECEIVER_JETI) BuildJeti_Vario(); |
| // ++++++++++++++++++++++++++++ |
| // + check the ACC-Z range |
| if(ACC_AltitudeControl && ((Aktuell_az < 300) || (DebugOut.Analog[7] < (128 * 4) && Aktuell_az > 850))) // DebugOut.Analog[7] = GasMischanteil |
| { |
| if(++AccZ_ErrorCnt > 50) |
| { |
| if(MotorenEin) VersionInfo.HardwareError[0] |= FC_ERROR0_ACC_TOP; |
| else CalibrationDone = 0; |
| } |
| } |
| else AccZ_ErrorCnt = 0; |
| // ++++++++++++++++++++++++++++ |
| #endif |
| if(MissingMotor) |
| { |
| 368,6 → 381,7 |
| { |
| NaviDataOkay--; |
| VersionInfo.HardwareError[1] &= ~FC_ERROR1_SPI_RX; |
| VersionInfo.Flags |= FC_VERSION_FLAG_NC_PRESENT; |
| } |
| else |
| { |
| 385,9 → 399,13 |
| GPS_Roll = 0; |
| GPS_Aid_StickMultiplikator = 0; |
| GPSInfo.Flags = 0; |
| FromNaviCtrl_Value.Kalman_K = -1; |
| FromNaviCtrl.AccErrorN = 0; |
| FromNaviCtrl.AccErrorR = 0; |
| FromNaviCtrl.CompassValue = -1; |
| FromNC_AltitudeSpeed = 0; |
| FromNC_AltitudeSetpoint = 0; |
| VersionInfo.Flags &= ~FC_VERSION_FLAG_NC_PRESENT; |
| NaviDataOkay = 0; |
| } |
| if(UBat < BattLowVoltageWarning) |
| 400,14 → 418,16 |
| } |
| } |
| else if(!beeptime) FC_StatusFlags &= ~FC_STATUS_LOWBAT; |
| SPI_StartTransmitPacket(); |
| SendSPI = 4; |
| SendSPI = SPI_BYTEGAP; |
| EEAR = EE_DUMMY; // Set the EEPROM Address pointer to an unused space |
| // +++++++++++++++++++++++++++++++++ |
| // Sekundentakt |
| if(++second == 49) |
| { |
| second = 0; |
| #if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__)) |
| if(ShowSettingNameTime) ShowSettingNameTime--; |
| #endif |
| if(FC_StatusFlags & FC_STATUS_FLY) FlugSekunden++; |
| else timer2 = 1450; // 0,5 Minuten aufrunden |
| if(modell_fliegt < 1024) |
| 434,10 → 454,11 |
| Capacity_Update(); |
| } //else DebugOut.Analog[26]++; |
| } |
| } |
| if(!SendSPI) { SPI_TransmitByte(); } |
| if(update_spi) update_spi--; |
| } // 500Hz |
| if(update_spi == 0) { SPI_StartTransmitPacket(); update_spi = 12;} // 41Hz |
| else if(!SendSPI) { SPI_TransmitByte(); } |
| } |
| return (1); |
| } |
| //DebugOut.Analog[16] |
| /test_branches/FC2_2/main.h |
|---|
| 35,6 → 35,7 |
| void LipoDetection(unsigned char print); |
| extern unsigned int FlugMinuten,FlugMinutenGesamt,FlugSekunden; |
| extern void PrintLine(void); // "=================================" |
| extern unsigned char ActiveParamSet; |
| #include <avr/pgmspace.h> |
| /test_branches/FC2_2/makefile |
|---|
| 4,13 → 4,13 |
| #MCU = atmega644p |
| F_CPU = 20000000 |
| #------------------------------------------------------------------- |
| VERSION_MAJOR = 0 |
| VERSION_MINOR = 90 |
| VERSION_PATCH = 5 |
| VERSION_MAJOR = 2 |
| VERSION_MINOR = 00 |
| VERSION_PATCH = 0 |
| VERSION_SERIAL_MAJOR = 11 # Serial Protocol |
| VERSION_SERIAL_MINOR = 0 # Serial Protocol |
| NC_SPI_COMPATIBLE = 53 # Navi-Kompatibilität |
| LIB_FC_COMPATIBLE = 2 # Library |
| NC_SPI_COMPATIBLE = 55 # Navi-Kompatibilität |
| LIB_FC_COMPATIBLE = 3 # Library |
| #------------------------------------------------------------------- |
| # ATMEGA644: 63487 is maximum |
| #------------------------------------------------------------------- |
| 453,7 → 453,6 |
| clean_list : |
| @echo |
| @echo $(MSG_CLEANING) |
| $(REMOVE) Flight-Ctrl_*.hex |
| $(REMOVE) Flight-Ctrl_*.eep |
| $(REMOVE) $(TARGET).obj |
| $(REMOVE) $(TARGET).cof |
| /test_branches/FC2_2/menu.c |
|---|
| 92,7 → 92,7 |
| case 0: |
| LCD_printfxy(0,0,"+ MikroKopter +"); |
| LCD_printfxy(0,1,"HW:V%d.%d SW:%d.%d%c V4",PlatinenVersion/10,PlatinenVersion%10, VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH +'a'); |
| LCD_printfxy(0,2,"Setting:%d %s", GetActiveParamSet(),Mixer.Name); |
| LCD_printfxy(0,2,"Setting:%d %s", ActiveParamSet,Mixer.Name); |
| if(VersionInfo.HardwareError[1] & FC_ERROR1_MIXER) LCD_printfxy(0,3,"Mixer Error!") |
| else |
| 191,7 → 191,7 |
| break; |
| case 8: |
| LCD_printfxy(0,0,"Receiver"); |
| LCD_printfxy(0,1,"RC-RSSI: %4i", PPM_in[0]); |
| // LCD_printfxy(0,1,"RC-RSSI: %4i", PPM_in[0]); |
| LCD_printfxy(0,2,"RC-Quality: %4i", SenderOkay); |
| LCD_printfxy(0,3,"RC-Channels:%4i", Channels-1); |
| break; |
| /test_branches/FC2_2/rc.c |
|---|
| 57,9 → 57,9 |
| #include "rc.h" |
| #include "main.h" |
| // Achtung: ACT_S3D_SUMMENSIGNAL wird in der Main.h gesetzt |
| volatile int PPM_in[26]; |
| volatile int PPM_diff[26]; // das diffenzierte Stick-Signal |
| #define MAX_RC_IN 16+12+3+4 // 16ch + 12ser + 3stages + 4 reserved |
| volatile int PPM_in[MAX_RC_IN]; |
| volatile int PPM_diff[MAX_RC_IN]; // das differnzierte Stick-Signal |
| volatile char Channels,tmpChannels = 0; |
| volatile unsigned char NewPpmData = 1; |
| unsigned int PPM_Neutral = 466; |
| 66,15 → 66,18 |
| //############################################################################ |
| // Clear the values |
| void rc_sum_init (void) |
| void rc_sum_init(void) |
| //############################################################################ |
| { |
| unsigned char i; |
| for(i=0;i<26;i++) |
| for(i=0;i<MAX_RC_IN;i++) |
| { |
| if(i < 5) PPM_in[i] = 0; else PPM_in[i] = -127; |
| PPM_diff[i] = 0; |
| } |
| PPM_in[PPM_IN_MAX] = +127; |
| PPM_in[PPM_IN_OFF] = -127; |
| PPM_in[PPM_IN_MID] = 0; |
| AdNeutralGier = 0; |
| AdNeutralRoll = 0; |
| AdNeutralNick = 0; |
| 87,7 → 90,9 |
| ISR(TIMER1_CAPT_vect) |
| //############################################################################ |
| { |
| #if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__)) |
| if(!(EE_Parameter.ExtraConfig & CFG_SENSITIVE_RC)) |
| #endif |
| { |
| static unsigned int AltICR=0; |
| signed int signal = 0,tmp; |
| 104,7 → 109,7 |
| } |
| else |
| { |
| if(index < 13) |
| if(index < 13+4) |
| { |
| if((signal > 250) && (signal < 687)) |
| { |
| 122,6 → 127,8 |
| PPM_in[index] = tmp; |
| } |
| index++; |
| #if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__)) |
| #else |
| if(PlatinenVersion < 20) |
| { |
| if(index == 5) J3High; else J3Low; // Servosignal an J3 anlegen |
| 128,16 → 135,18 |
| if(index == 6) J4High; else J4Low; // Servosignal an J4 anlegen |
| if(index == 7) J5High; else J5Low; // Servosignal an J5 anlegen |
| } |
| #endif |
| } |
| } |
| } |
| #if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__)) |
| else |
| { |
| static unsigned int AltICR=0; |
| static int ppm_in[13]; |
| static int ppm_diff[13]; |
| static int old_ppm_in[13]; |
| static int old_ppm_diff[13]; |
| static int ppm_in[13+4]; |
| static int ppm_diff[13+4]; |
| static int old_ppm_in[13+4]; |
| static int old_ppm_diff[13+4]; |
| signed int signal = 0,tmp; |
| static unsigned char index, okay_cnt = 0; |
| signal = (unsigned int) ICR1 - AltICR; |
| 151,7 → 160,7 |
| if(okay_cnt > 10) |
| { |
| NewPpmData = 0; // Null bedeutet: Neue Daten |
| for(index = 0; index < 13; index++) |
| for(index = 0; index < 13+4; index++) |
| { |
| if(okay_cnt > 30) |
| { |
| 174,7 → 183,7 |
| } |
| else |
| { |
| if(index < 13) |
| if(index < 13+4) |
| { |
| if((signal > 250) && (signal < 687)) |
| { |
| 198,6 → 207,8 |
| ppm_in[index] = tmp; |
| } |
| else ROT_ON; |
| #if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__)) |
| #else |
| if(PlatinenVersion < 20) |
| { |
| if(index == 5) J3High; else J3Low; // Servosignal an J3 anlegen |
| 204,6 → 215,7 |
| if(index == 6) J4High; else J4Low; // Servosignal an J4 anlegen |
| if(index == 7) J5High; else J5Low; // Servosignal an J5 anlegen |
| } |
| #endif |
| } |
| if(index < 20) index++; |
| else |
| 212,7 → 224,7 |
| unsigned char i; |
| ROT_ON; |
| index = 30; |
| for(i=0;i<13;i++) // restore from older data |
| for(i=0;i<13+4;i++) // restore from older data |
| { |
| PPM_in[i] = old_ppm_in[i]; |
| PPM_diff[i] = 0; |
| 221,6 → 233,8 |
| } |
| } |
| } |
| #endif |
| } |
| #else |
| /test_branches/FC2_2/rc.h |
|---|
| 13,15 → 13,30 |
| #define TIMER_RELOAD_VALUE 250 |
| #endif |
| #define GAS PPM_in[2] |
| #define FromNC_WP_EventChannel PPM_in[25] // WP_EVENT-Channel-Value |
| #define MAX_RC_IN 16+12+3+4 // 16ch + 12ser + 3stages + 4 reserved |
| extern void rc_sum_init (void); |
| extern volatile int PPM_in[26]; |
| extern volatile int PPM_diff[26]; // das diffenzierte Stick-Signal |
| extern volatile int PPM_in[MAX_RC_IN]; |
| extern volatile int PPM_diff[MAX_RC_IN]; // das diffenzierte Stick-Signal |
| extern volatile unsigned char NewPpmData; |
| extern volatile char Channels,tmpChannels; |
| extern unsigned int PPM_Neutral; |
| // 0 -> frei bzw. ACT rssi |
| // 1 - 16 -> 1-16 |
| // 17 - 28 -> 12 Serial channels |
| // 29 -> WP-Event kanal |
| // 30 -> -127 |
| // 31 -> 0 |
| // 32 -> 128 |
| #define SERIAL_POTI_START 17 |
| #define WP_EVENT_PPM_IN 29 |
| #define PPM_IN_OFF 30 |
| #define PPM_IN_MAX 31 |
| #define PPM_IN_MID 32 |
| #define FromNC_WP_EventChannel PPM_in[WP_EVENT_PPM_IN] // WP_EVENT-Channel-Value |
| #endif //_RC_H |
| /test_branches/FC2_2/spi.c |
|---|
| 21,9 → 21,9 |
| unsigned char SPI_RxDataValid,NaviDataOkay = 250; |
| unsigned char SPI_CommandSequence[] = { SPI_FCCMD_STICK, SPI_FCCMD_USER, SPI_FCCMD_PARAMETER1, |
| SPI_FCCMD_STICK, SPI_FCCMD_MISC, SPI_FCCMD_VERSION, |
| SPI_FCCMD_STICK, SPI_FCCMD_SERVOS, SPI_FCCMD_ACCU, |
| SPI_FCCMD_STICK, SPI_FCCMD_PARAMETER2 |
| SPI_FCCMD_STICK, SPI_FCCMD_VERSION, SPI_FCCMD_BL_ACCU, |
| SPI_FCCMD_STICK, SPI_FCCMD_USER, SPI_FCCMD_MISC,SPI_FCCMD_SERVOS, |
| SPI_FCCMD_STICK, SPI_FCCMD_PARAMETER2, SPI_FCCMD_BL_ACCU |
| }; |
| unsigned char SPI_CommandCounter = 0; |
| unsigned char NC_ErrorCode = 0; |
| 65,10 → 65,7 |
| //------------------------------------------------------ |
| void SPI_StartTransmitPacket(void) |
| { |
| //if ((SLAVE_SELECT_PORT & (1 << SPI_SLAVE_SELECT)) == 0) return; // transfer of prev. packet not completed |
| if (!SPITransferCompleted) return; |
| // _delay_us(30); |
| SLAVE_SELECT_PORT &= ~(1 << SPI_SLAVE_SELECT); // SelectSlave |
| SPI_TX_Buffer = (unsigned char *) &ToNaviCtrl; |
| 77,17 → 74,9 |
| SPITransferCompleted = 0; |
| UpdateSPI_Buffer(); // update buffer |
| SPI_BufferIndex = 1; |
| // -- Debug-Output --- |
| //---- |
| asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); |
| asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); |
| asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); |
| ToNaviCtrl.Chksum = ToNaviCtrl.Sync1; |
| SPDR = ToNaviCtrl.Sync1; // Start transmission |
| // SLAVE_SELECT_PORT |= (1 << SPI_SLAVE_SELECT); // DeselectSlave |
| } |
| //------------------------------------------------------ |
| 100,8 → 89,7 |
| if (SPITransferCompleted) return; |
| if (!(SPSR & (1 << SPIF))) return; |
| SendSPI = 4; |
| SendSPI = SPI_BYTEGAP; |
| // _delay_us(30); |
| SLAVE_SELECT_PORT |= (1 << SPI_SLAVE_SELECT); // DeselectSlave |
| 109,7 → 97,6 |
| switch ( SPI_RXState) |
| { |
| case 0: |
| SPI_RxBufferIndex = 0; |
| rxchksum = rxdata; |
| if (rxdata == 0x81 ) { SPI_RXState = 1; } // 1. Syncbyte ok |
| 126,7 → 113,6 |
| //DebugOut.Analog[19]++; |
| if (SPI_RxBufferIndex >= sizeof(FromNaviCtrl)) |
| { |
| if (rxdata == rxchksum) |
| { |
| unsigned char *ptr = (unsigned char *)&FromNaviCtrl; |
| 137,8 → 123,6 |
| { |
| SPI_RxDataValid = 0; |
| } |
| SPI_RXState = 0; |
| } |
| else rxchksum += rxdata; |
| 149,15 → 133,10 |
| if (SPI_BufferIndex < sizeof(ToNaviCtrl)) |
| { |
| SLAVE_SELECT_PORT &= ~(1 << SPI_SLAVE_SELECT); // SelectSlave |
| asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); |
| asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); |
| asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); |
| asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); asm volatile ("nop"); |
| SPDR = SPI_TX_Buffer[SPI_BufferIndex]; |
| ToNaviCtrl.Chksum += SPI_TX_Buffer[SPI_BufferIndex]; |
| // SLAVE_SELECT_PORT |= (1 << SPI_SLAVE_SELECT); // DeselectSlave |
| } |
| } |
| else SPITransferCompleted = 1; |
| SPI_BufferIndex++; |
| 192,31 → 171,32 |
| ToNaviCtrl.Param.Byte[8] = FC_StatusFlags; |
| //if(FC_StatusFlags2 & FC_STATUS2_WAIT_FOR_TAKEOFF) ToNaviCtrl.Param.Byte[8] &= ~FC_STATUS_FLY; |
| FC_StatusFlags &= ~(FC_STATUS_CALIBRATE | FC_STATUS_START); |
| ToNaviCtrl.Param.Byte[9] = GetActiveParamSet(); |
| ToNaviCtrl.Param.Byte[9] = ActiveParamSet; |
| ToNaviCtrl.Param.Byte[10] = EE_Parameter.ComingHomeAltitude; |
| ToNaviCtrl.Param.Byte[11] = FC_StatusFlags2; |
| if(!(PORTC & (1<<PORTC2))) FC_StatusFlags2 &= ~FC_STATUS2_OUT1_ACTIVE; // Out1 (J16) |
| break; |
| case SPI_FCCMD_ACCU: |
| case SPI_FCCMD_BL_ACCU: |
| 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] = (unsigned char) BattLowVoltageWarning; //0.1V |
| ToNaviCtrl.Param.Byte[5] = GetChannelValue(EE_Parameter.NaviGpsModeChannel); // GPS-Mode control |
| ToNaviCtrl.Param.Byte[6] = VarioCharacter; |
| ToNaviCtrl.Param.Byte[7] = motorindex; |
| ToNaviCtrl.Param.Byte[8] = Motor[motorindex].MaxPWM; |
| ToNaviCtrl.Param.Byte[9] = Motor[motorindex].State; |
| ToNaviCtrl.Param.Byte[10] = Motor[motorindex].Temperature; |
| ToNaviCtrl.Param.Byte[11] = Motor[motorindex++].Current; |
| motorindex %= 12; |
| ToNaviCtrl.Param.Byte[11] = Motor[motorindex].Current; |
| if(Mixer.Motor[++motorindex][0] == 0) // next motor is not used ? |
| while(Mixer.Motor[motorindex][0] == 0 && motorindex) motorindex = (motorindex + 1) % 12; |
| break; |
| case SPI_FCCMD_PARAMETER1: |
| ToNaviCtrl.Param.Byte[0] = EE_Parameter.NaviGpsModeControl; // Parameters for the Naviboard |
| ToNaviCtrl.Param.Byte[1] = EE_Parameter.NaviGpsGain; |
| ToNaviCtrl.Param.Byte[0] = (unsigned char) BattLowVoltageWarning; //0.1V |
| ToNaviCtrl.Param.Byte[1] = EE_Parameter.NaviGpsGain; // Parameters for the Naviboard |
| ToNaviCtrl.Param.Byte[2] = EE_Parameter.NaviGpsP; |
| ToNaviCtrl.Param.Byte[3] = EE_Parameter.NaviGpsI; |
| ToNaviCtrl.Param.Byte[4] = EE_Parameter.NaviGpsD; |
| ToNaviCtrl.Param.Byte[5] = EE_Parameter.NaviGpsACC; |
| ToNaviCtrl.Param.Byte[5] = EE_Parameter.NaviGpsA; |
| ToNaviCtrl.Param.Byte[6] = EE_Parameter.NaviGpsMinSat; |
| ToNaviCtrl.Param.Byte[7] = EE_Parameter.NaviStickThreshold; |
| ToNaviCtrl.Param.Byte[8] = EE_Parameter.NaviOperatingRadius; |
| 237,6 → 217,7 |
| #else |
| ToNaviCtrl.Param.Byte[1] = 0; |
| #endif |
| ToNaviCtrl.Param.Byte[2] = EE_Parameter.LandingSpeed; |
| break; |
| case SPI_FCCMD_STICK: |
| cli(); |
| 272,7 → 253,8 |
| ToNaviCtrl.Param.Byte[7] = EE_Parameter.NaviGpsILimit; |
| ToNaviCtrl.Param.Byte[8] = EE_Parameter.NaviGpsDLimit; |
| ToNaviCtrl.Param.Byte[9] = (unsigned char) SenderOkay; |
| ToNaviCtrl.Param.Byte[10] = (unsigned char) PPM_in[0]; |
| // ToNaviCtrl.Param.Byte[10] = (unsigned char) PPM_in[0]; // ACT RSSI |
| ToNaviCtrl.Param.Byte[10] = 0; |
| ToNaviCtrl.Param.Byte[11] = DebugOut.Analog[7] / 4; //GasMischanteil |
| break; |
| case SPI_FCCMD_VERSION: |
| 285,7 → 267,7 |
| ToNaviCtrl.Param.Byte[6] = VersionInfo.HardwareError[1]; |
| VersionInfo.HardwareError[0] &= ~FC_ERROR0_CAREFREE; // VersionInfo.HardwareError[0] = 0; |
| VersionInfo.HardwareError[1] &= FC_ERROR1_MIXER; |
| ToNaviCtrl.Param.Byte[7] = VersionInfo.HardwareError[2]; // unused |
| ToNaviCtrl.Param.Byte[7] = 0; |
| ToNaviCtrl.Param.Byte[8] = Parameter_GlobalConfig; |
| ToNaviCtrl.Param.Byte[9] = Parameter_ExtraConfig; |
| ToNaviCtrl.Param.Byte[10] = EE_Parameter.OrientationAngle; |
| 370,7 → 352,7 |
| GPSInfo.Speed = FromNaviCtrl.Param.Byte[3]; |
| GPSInfo.HomeDistance = FromNaviCtrl.Param.Int[2]; |
| GPSInfo.HomeBearing = FromNaviCtrl.Param.sInt[3]; |
| PPM_in[25] = (signed char) FromNaviCtrl.Param.Byte[8]; // WP_EVENT-Channel-Value (FromNC_WP_EventChannel) |
| PPM_in[WP_EVENT_PPM_IN] = (signed char) FromNaviCtrl.Param.Byte[8]; // WP_EVENT-Channel-Value (FromNC_WP_EventChannel) |
| FromNC_AltitudeSpeed = FromNaviCtrl.Param.Byte[9]; |
| FromNC_AltitudeSetpoint = (long) FromNaviCtrl.Param.sInt[5] * 10; // in cm |
| break; |
| /test_branches/FC2_2/spi.h |
|---|
| 6,7 → 6,7 |
| #include "vector.h" |
| #define USE_SPI_COMMUNICATION |
| #define SPI_BYTEGAP 3 |
| //----------------------------------------- |
| #define DDR_SPI DDRB |
| #define SLAVE_SELECT_DDR_PORT DDRC |
| 62,7 → 62,7 |
| #define SPI_FCCMD_PARAMETER1 13 |
| #define SPI_FCCMD_VERSION 14 |
| #define SPI_FCCMD_SERVOS 15 |
| #define SPI_FCCMD_ACCU 16 |
| #define SPI_FCCMD_BL_ACCU 16 |
| #define SPI_FCCMD_PARAMETER2 17 |
| struct str_ToNaviCtrl |
| /test_branches/FC2_2/timer0.c |
|---|
| 60,6 → 60,7 |
| volatile unsigned int cntKompass = 0; |
| volatile unsigned int beeptime = 0; |
| volatile unsigned char SendSPI = 0, ServoActive = 0, CalculateServoSignals = 1; |
| unsigned char JustMK3MagConnected = 0; |
| 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 |
| 85,7 → 86,7 |
| ISR(TIMER0_OVF_vect) // 9,7kHz |
| { |
| static unsigned char cnt_1ms = 1,cnt = 0, compass_active = 0; |
| static unsigned char cnt_1ms = 1,cnt = 0; |
| unsigned char pieper_ein = 0; |
| if(SendSPI) SendSPI--; |
| if(SpektrumTimer) SpektrumTimer--; |
| 97,7 → 98,7 |
| cnt_1ms %= 2; |
| if(!cnt_1ms) UpdateMotor = 1; |
| if(!(PINC & 0x10)) compass_active = 1; |
| if(!(PINC & 0x10)) JustMK3MagConnected = 1; |
| if(beeptime) |
| { |
| 129,11 → 130,11 |
| } |
| #endif |
| } |
| if(compass_active && !NaviDataOkay && Parameter_GlobalConfig & CFG_KOMPASS_AKTIV) |
| if(JustMK3MagConnected && !NaviDataOkay && Parameter_GlobalConfig & CFG_KOMPASS_AKTIV) |
| { |
| if(PINC & 0x10) |
| { |
| if(++cntKompass > 1000) compass_active = 0; |
| if(++cntKompass > 1000) JustMK3MagConnected = 0; |
| } |
| else |
| { |
| /test_branches/FC2_2/timer0.h |
|---|
| 22,3 → 22,4 |
| extern volatile int16_t ServoNickValue; |
| extern volatile int16_t ServoRollValue; |
| extern signed int NickServoValue; |
| extern unsigned char JustMK3MagConnected; |
| /test_branches/FC2_2/uart.c |
|---|
| 64,8 → 64,8 |
| #define BL_CTRL_ADDRESS 5 |
| #define ABO_TIMEOUT 4000 // disable abo after 4 seconds |
| #define MAX_SENDE_BUFF 175 |
| #define MAX_EMPFANGS_BUFF 175 |
| #define MAX_SENDE_BUFF 220 |
| #define MAX_EMPFANGS_BUFF 220 |
| #define BLPARAM_REVISION 1 |
| #define MASK_SET_PWM_SCALING 0x01 |
| 128,10 → 128,10 |
| "Motor 2 ", |
| "Motor 3 ", |
| "Motor 4 ", //15 |
| "16 Variance ", |
| "17 vv ", |
| "18 HoehenWertF ", |
| "19 GasEinwirkung", |
| "16 ", |
| "17 ", |
| "18 ", |
| "19 ", |
| "Servo ", //20 |
| "Hovergas ", |
| "Current [0.1A] ", |
| 138,7 → 138,7 |
| "Capacity [mAh] ", |
| "Height Setpoint ", |
| "25 ", //25 |
| "26 AccZfine ", //"26 CPU OverLoad ", |
| "26 ", //"26 CPU OverLoad ", |
| "Compass Setpoint", |
| "I2C-Error ", |
| "BL Limit ", |
| 206,7 → 206,6 |
| wdt_enable(WDTO_250MS); // Reset-Commando |
| ServoActive = 0; |
| } |
| } |
| } |
| else |
| 244,6 → 243,7 |
| { |
| tmpCRC += TxdBuffer[i]; |
| } |
| // if(i > MAX_SENDE_BUFF - 3) tmpCRC += 11; |
| tmpCRC %= 4096; |
| TxdBuffer[i++] = '=' + tmpCRC / 64; |
| TxdBuffer[i++] = '=' + tmpCRC % 64; |
| 250,10 → 250,10 |
| TxdBuffer[i++] = '\r'; |
| UebertragungAbgeschlossen = 0; |
| UDR0 = TxdBuffer[0]; |
| //if(DebugOut.Analog[] < i) DebugOut.Analog[] = i; |
| } |
| // -------------------------------------------------------------------------- |
| void SendOutData(unsigned char cmd,unsigned char address, unsigned char BufferAnzahl, ...) //unsigned char *snd, unsigned char len) |
| { |
| 410,6 → 410,7 |
| case 'q':// "Get"-Anforderung für Settings |
| // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen |
| if(MotorenEin) break; |
| if((10 <= pRxData[0]) && (pRxData[0] < 20)) |
| { |
| tempchar1 = pRxData[0] - 10; |
| 439,7 → 440,6 |
| while(!UebertragungAbgeschlossen); |
| SendOutData('Q', FC_ADDRESS, 2, &tempchar1, sizeof(tempchar1), (unsigned char *) &EE_Parameter, sizeof(EE_Parameter) - 1); |
| Debug("Lese Setting %d", tempchar1); |
| break; |
| case 's': // Parametersatz speichern |
| 462,20 → 462,18 |
| LIBFC_ReceiverInit(EE_Parameter.Receiver); |
| break; |
| case 'f': // auf anderen Parametersatz umschalten |
| if(MotorenEin) break; |
| if((1 <= pRxData[0]) && (pRxData[0] <= 5)) ParamSet_ReadFromEEProm(pRxData[0]); |
| tempchar1 = GetActiveParamSet(); |
| while(!UebertragungAbgeschlossen); |
| SendOutData('F', FC_ADDRESS, 1, &tempchar1, sizeof(tempchar1)); |
| if(!MotorenEin) Piep(tempchar1,110); |
| Piep(tempchar1,110); |
| LipoDetection(0); |
| LIBFC_ReceiverInit(EE_Parameter.Receiver); |
| break; |
| case 'y':// serial Potis |
| PPM_in[13] = (signed char) pRxData[0]; PPM_in[14] = (signed char) pRxData[1]; PPM_in[15] = (signed char) pRxData[2]; PPM_in[16] = (signed char) pRxData[3]; |
| PPM_in[17] = (signed char) pRxData[4]; PPM_in[18] = (signed char) pRxData[5]; PPM_in[19] = (signed char) pRxData[6]; PPM_in[20] = (signed char) pRxData[7]; |
| PPM_in[21] = (signed char) pRxData[8]; PPM_in[22] = (signed char) pRxData[9]; PPM_in[23] = (signed char) pRxData[10]; PPM_in[24] = (signed char) pRxData[11]; |
| for(tempchar1 = 0; tempchar1 < 12; tempchar1++) PPM_in[SERIAL_POTI_START + tempchar1] = (signed char) pRxData[tempchar1]; |
| break; |
| case 'u': // request BL parameter |
| Debug("Reading BL %d", pRxData[0]); |
| // try to read BL configuration |
| 485,7 → 483,6 |
| while(!UebertragungAbgeschlossen); // wait for previous frame to be sent |
| SendOutData('U', FC_ADDRESS, 4, &tempchar1, sizeof(tempchar1), &tempchar2, sizeof(tempchar2), &pRxData[0], 1, &BLConfig, sizeof(BLConfig_t)); |
| break; |
| case 'w': // write BL parameter |
| Debug("Writing BL %d", pRxData[0]); |
| if(RxDataLen >= 1+sizeof(BLConfig_t)) |
| 683,8 → 680,9 |
| VersionInfo.SWMinor = VERSION_MINOR; |
| VersionInfo.SWPatch = VERSION_PATCH; |
| VersionInfo.ProtoMajor = VERSION_SERIAL_MAJOR; |
| VersionInfo.ProtoMinor = VERSION_SERIAL_MINOR; |
| VersionInfo.reserved1 = 0; |
| VersionInfo.reserved2 = 0; |
| VersionInfo.HWMajor = PlatinenVersion; |
| pRxData = 0; |
| RxDataLen = 0; |
| } |
| 735,16 → 733,6 |
| SendOutData('G',MeineSlaveAdresse, 1, (unsigned char *) &ExternControl, sizeof(ExternControl)); |
| GetExternalControl = 0; |
| } |
| if((CheckDelay(Kompass_Timer)) && UebertragungAbgeschlossen) |
| { |
| 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; |
| SendOutData('k', MK3MAG_ADDRESS, 1, (unsigned char *) &WinkelOut,sizeof(WinkelOut)); |
| if(WinkelOut.CalcState > 4) WinkelOut.CalcState = 6; // wird dann in SPI auf Null gesetzt |
| Kompass_Timer = SetDelay(99); |
| } |
| if(((DebugDataIntervall>0 && CheckDelay(Debug_Timer)) || DebugDataAnforderung) && UebertragungAbgeschlossen) |
| { |
| CopyDebugValues(); |
| 775,13 → 763,22 |
| SendOutData('B', FC_ADDRESS, 1, (uint8_t*)&ConfirmFrame, sizeof(ConfirmFrame)); |
| ConfirmFrame = 0; |
| } |
| if(GetPPMChannelAnforderung && UebertragungAbgeschlossen) |
| { |
| SendOutData('P', FC_ADDRESS, 1, (unsigned char *) &PPM_in, sizeof(PPM_in)); |
| GetPPMChannelAnforderung = 0; |
| } |
| if((CheckDelay(Kompass_Timer)) && UebertragungAbgeschlossen) |
| { |
| 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; |
| 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); |
| else Kompass_Timer = SetDelay(999); |
| } |
| #ifdef DEBUG // only include functions if DEBUG is defined |
| if(SendDebugOutput && UebertragungAbgeschlossen) |
| { |
| 789,7 → 786,6 |
| SendDebugOutput = 0; |
| } |
| #endif |
| } |
| /test_branches/FC2_2/uart.h |
|---|
| 85,14 → 85,24 |
| #define FC_ERROR1_RES2 0x40 |
| #define FC_ERROR1_RES3 0x80 |
| // for FlightCtrl |
| //VersionInfo.Flags |
| #define FC_VERSION_FLAG_NC_PRESENT 0x01 |
| // for NaviCtrl |
| #define NC_VERSION_FLAG_MK3MAG_PRESENT 0x01 |
| struct str_VersionInfo |
| { |
| unsigned char SWMajor; |
| unsigned char SWMinor; |
| unsigned char ProtoMajor; |
| unsigned char ProtoMinor; |
| unsigned char reserved1; |
| unsigned char SWPatch; |
| unsigned char HardwareError[5]; |
| unsigned char HardwareError[2]; |
| unsigned char HWMajor; |
| unsigned char reserved2; |
| unsigned char Flags; |
| }; |
| extern struct str_VersionInfo VersionInfo; |
| /test_branches/FC2_2/version.txt |
|---|
| 565,8 → 565,53 |
| 0.90e H.Buss 04.03.2013 |
| - Parameter_ServoRollComp jetzt auf Poti /Kompatibilität auf 93 erhöht) |
| 0.90f |
| 0.90f (26.04.2013) |
| - disable Yawing when Gas-Stick is to Zero |
| - I-Anteile bein Start auf Null halten, wenn der Kopter auf dem Boden steht (<150cm) |
| - ACC-Fusion des Höhenreglers integriert (ab FC2.2) |
| - calibration must be within 20° Tilt angle |
| - Hold I-Parts of the attitude control to zero when the MK is still on the ground |
| - ACC-Altitude sensor data fusion implemented to the altitude controller (HW-Update from FC2.1 to 2.2 needed) |
| - MK must be within 20° tilt angle when calibrating sensors |
| - Parameter Reset, if the HW-Version changes (FC2.1 to 2.2) |
| 0.90g (29.04.2013) |
| - No ACC-Z error if the MK is tilted after switching on |
| - ATMEGA644 (until FC2.0): Sensitive RC-Signal validation removed -> that was only nessecary for old 35MHz receivers |
| 0.90h (14.05.2013) |
| - Auto Start and landing for Waypoints |
| - back to old eeprom-compatiblity to remain compatible to other Tools |
| - HoTT-Bugfix: no speech while vario tone |
| - Bugfix: Wrong error speech in JetiEX ("Error calibration") |
| 0.90j (27.05.2013) |
| - Changes for better EEPROM-Safety |
| - variable ActiveParamSet instead of the direct EEPROM-Reading (faster) |
| - Checking the ACC-Z value in flight and report ACC-Z if out of range |
| - disable Altitude hold in case of ACC-Z error |
| 2.00a (after public Beta test 0.91) |
| - show SW-Version in Hot Display |
| - GPS-Parameter changed (P = 90->100; I = 90->90; D = 90->120; A = 40) |
| - Move NICK/Roll Sticks for switching on / off |
| - Move the Stick > 100 instead > 75 for switch on / off |
| - Failsafe active if ACC-Upgarde |
| - AltitudeMode, GPS_Mode & Carefree_Mode are now direct channels instead of Poti-Values (NaviGpsModeChannel,CareFreeChannel,HoeheChannel) |
| - NC-SPI communication from 25Hz to 41Hz |
| - MotorTemperature and GPS-Mode-Switch more often to NC |
| - Auto-Start/Landing |
| - JetiEX: Name set to 'MK' |
| - if(CareFree) Parameter_AchsKopplung1 += 30; removed |
| - StickNeutral setting per default 127 |
| - UART-Buffer increased from 175 to 220 Bytes |
| - show name of active parameter set in the HoTT/Jeti display |
| - fixed in 0.91L: if "ServoRelative" is used, it coud happen that the servo moves a wide range in the first second after the first calibration |
| - Servo3-5 Limit to 24-255 |
| - no. of channels increased from 12 to 16 |
| // 0 -> frei bzw. ACT rssi (or zero if unsigned) |
| // 1 - 16 -> 1-16 |
| // 17 - 28 -> 12 Serial channels |
| // 29 -> WP-Event kanal |
| // 30 Fix -> -127 |
| // 31 Fix -> 0 |
| // 32 Fix -> 128 |