/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 |