/trunk/analog.c |
---|
68,7 → 68,7 |
} |
DruckOffsetSetting = off; |
} |
#else |
#else |
off = GetParamByte(PID_PRESSURE_OFFSET); |
if(off > 20) off -= 10; |
OCR0A = off; |
84,7 → 84,7 |
DruckOffsetSetting = off; |
SetParamByte(PID_PRESSURE_OFFSET, off); |
#endif |
if((EE_Parameter.GlobalConfig & CFG_HOEHENREGELUNG) && (DruckOffsetSetting < 10 || DruckOffsetSetting >= 245)) VersionInfo.HardwareError[0] |= DEFEKT_PRESSURE; |
if((EE_Parameter.GlobalConfig & CFG_HOEHENREGELUNG) && (DruckOffsetSetting < 10 || DruckOffsetSetting >= 245)) VersionInfo.HardwareError[0] |= FC_ERROR0_PRESSURE; |
OCR0A = off; |
Delay_ms_Mess(300); |
} |
103,9 → 103,9 |
if(AdWertRoll < 1020) AnalogOffsetRoll--; else if(AdWertRoll > 1030) AnalogOffsetRoll++; else ready++; |
if(AdWertGier < 1020) AnalogOffsetGier--; else if(AdWertGier > 1030) AnalogOffsetGier++; else ready++; |
I2C_Start(TWI_STATE_GYRO_OFFSET_TX); |
if(AnalogOffsetNick < 10) { VersionInfo.HardwareError[0] |= DEFEKT_G_NICK; AnalogOffsetNick = 10;}; if(AnalogOffsetNick > 245) { VersionInfo.HardwareError[0] |= DEFEKT_G_NICK; AnalogOffsetNick = 245;}; |
if(AnalogOffsetRoll < 10) { VersionInfo.HardwareError[0] |= DEFEKT_G_ROLL; AnalogOffsetRoll = 10;}; if(AnalogOffsetRoll > 245) { VersionInfo.HardwareError[0] |= DEFEKT_G_ROLL; AnalogOffsetRoll = 245;}; |
if(AnalogOffsetGier < 10) { VersionInfo.HardwareError[0] |= DEFEKT_G_GIER; AnalogOffsetGier = 10;}; if(AnalogOffsetGier > 245) { VersionInfo.HardwareError[0] |= DEFEKT_G_GIER; AnalogOffsetGier = 245;}; |
if(AnalogOffsetNick < 10) { VersionInfo.HardwareError[0] |= FC_ERROR0_GYRO_NICK; AnalogOffsetNick = 10;}; if(AnalogOffsetNick > 245) { VersionInfo.HardwareError[0] |= FC_ERROR0_GYRO_NICK; AnalogOffsetNick = 245;}; |
if(AnalogOffsetRoll < 10) { VersionInfo.HardwareError[0] |= FC_ERROR0_GYRO_ROLL; AnalogOffsetRoll = 10;}; if(AnalogOffsetRoll > 245) { VersionInfo.HardwareError[0] |= FC_ERROR0_GYRO_ROLL; AnalogOffsetRoll = 245;}; |
if(AnalogOffsetGier < 10) { VersionInfo.HardwareError[0] |= FC_ERROR0_GYRO_YAW; AnalogOffsetGier = 10;}; if(AnalogOffsetGier > 245) { VersionInfo.HardwareError[0] |= FC_ERROR0_GYRO_YAW; AnalogOffsetGier = 245;}; |
while(twi_state) if(CheckDelay(timeout)) {printf("\n\r DAC or I2C ERROR! Check I2C, 3Vref, DAC and BL-Ctrl"); break;} |
AdReady = 0; |
ANALOG_ON; |
/trunk/fc.c |
---|
154,7 → 154,7 |
signed int ExternStickNick = 0,ExternStickRoll = 0,ExternStickGier = 0, ExternHoehenValue = -20; |
int MaxStickNick = 0,MaxStickRoll = 0; |
unsigned int modell_fliegt = 0; |
volatile unsigned char FCFlags = 0; |
volatile unsigned char FC_StatusFlags = 0; |
long GIER_GRAD_FAKTOR = 1291; |
signed int KopplungsteilNickRoll,KopplungsteilRollNick; |
signed int tmp_motorwert[MAX_MOTORS]; |
336,7 → 336,7 |
GierGyroFehler = 0; |
SendVersionToNavi = 1; |
LED_Init(); |
FCFlags |= FCFLAG_CALIBRATE; |
FC_StatusFlags |= FC_STATUS_CALIBRATE; |
FromNaviCtrl_Value.Kalman_K = -1; |
FromNaviCtrl_Value.Kalman_MaxDrift = 0; |
FromNaviCtrl_Value.Kalman_MaxFusion = 32; |
352,12 → 352,12 |
DDRD |=0x80; // enable J7 -> Servo signal |
} |
if((AdNeutralNick < 150 * 16) || (AdNeutralNick > 850 * 16)) { VersionInfo.HardwareError[0] |= DEFEKT_G_NICK; }; |
if((AdNeutralRoll < 150 * 16) || (AdNeutralRoll > 850 * 16)) { VersionInfo.HardwareError[0] |= DEFEKT_G_ROLL; }; |
if((AdNeutralGier < 150 * 2) || (AdNeutralGier > 850 * 2)) { VersionInfo.HardwareError[0] |= DEFEKT_G_GIER; }; |
if((NeutralAccX < 300) || (NeutralAccX > 750)) { VersionInfo.HardwareError[0] |= DEFEKT_A_NICK; }; |
if((NeutralAccY < 300) || (NeutralAccY > 750)) { VersionInfo.HardwareError[0] |= DEFEKT_A_ROLL; }; |
if((NeutralAccZ < 512) || (NeutralAccZ > 850)) { VersionInfo.HardwareError[0] |= DEFEKT_A_Z; }; |
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; }; |
if((NeutralAccX < 300) || (NeutralAccX > 750)) { VersionInfo.HardwareError[0] |= FC_ERROR0_ACC_NICK; }; |
if((NeutralAccY < 300) || (NeutralAccY > 750)) { VersionInfo.HardwareError[0] |= FC_ERROR0_ACC_ROLL; }; |
if((NeutralAccZ < 512) || (NeutralAccZ > 850)) { VersionInfo.HardwareError[0] |= FC_ERROR0_ACC_TOP; }; |
} |
528,7 → 528,7 |
unsigned char i; |
if(!MotorenEin) |
{ |
FCFlags &= ~(FCFLAG_MOTOR_RUN | FCFLAG_FLY); |
FC_StatusFlags &= ~(FC_STATUS_MOTOR_RUN | FC_STATUS_FLY); |
for(i=0;i<MAX_MOTORS;i++) |
{ |
if(!PC_MotortestActive) MotorTest[i] = 0; |
541,17 → 541,17 |
} |
if(PC_MotortestActive) PC_MotortestActive--; |
} |
else FCFlags |= FCFLAG_MOTOR_RUN; |
else FC_StatusFlags |= FC_STATUS_MOTOR_RUN; |
if(I2C_TransferActive) |
if(I2C_TransferActive) |
{ |
I2C_TransferActive = 0; // enable for the next time |
} |
else |
} |
else |
{ |
motor_write = 0; |
I2C_Start(TWI_STATE_MOTOR_TX); //Start I2C Interrupt Mode |
} |
} |
} |
612,7 → 612,7 |
#endif |
CareFree = 1; |
if(tmp >= 248 && Poti[255 - tmp] < 50) CareFree = 0; |
if(FromNaviCtrl.CompassValue < 0 && CareFree) VersionInfo.HardwareError[0] |= DEFEKT_CAREFREE_ERR; else VersionInfo.HardwareError[0] &= ~DEFEKT_CAREFREE_ERR; |
if(FromNaviCtrl.CompassValue < 0 && CareFree) VersionInfo.HardwareError[0] |= FC_ERROR0_CAREFREE; else VersionInfo.HardwareError[0] &= ~FC_ERROR0_CAREFREE; |
} |
else CareFree = 0; |
621,7 → 621,7 |
beeptime = 15000; |
BeepMuster = 0xA400; |
CareFree = 0; |
} |
} |
if(CareFree) {if(Parameter_AchsKopplung1 < 210) Parameter_AchsKopplung1 += 30;} |
} |
661,13 → 661,13 |
else |
{ |
MotorenEin = 0; |
FCFlags &= ~FCFLAG_NOTLANDUNG; |
FC_StatusFlags &= ~FC_STATUS_EMERGENCY_LANDING; |
} |
ROT_ON; |
if(modell_fliegt > 1000) // wahrscheinlich in der Luft --> langsam absenken |
{ |
GasMischanteil = EE_Parameter.NotGas; |
FCFlags |= FCFLAG_NOTLANDUNG; |
FC_StatusFlags |= FC_STATUS_EMERGENCY_LANDING; |
PPM_diff[EE_Parameter.Kanalbelegung[K_NICK]] = 0; |
PPM_diff[EE_Parameter.Kanalbelegung[K_ROLL]] = 0; |
PPM_in[EE_Parameter.Kanalbelegung[K_NICK]] = 0; |
682,7 → 682,7 |
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
if(SenderOkay > 140) |
{ |
FCFlags &= ~FCFLAG_NOTLANDUNG; |
FC_StatusFlags &= ~FC_STATUS_EMERGENCY_LANDING; |
RcLostTimer = EE_Parameter.NotGasZeit * 50; |
if(GasMischanteil > 40 && MotorenEin) |
{ |
698,7 → 698,7 |
{ |
NeueKompassRichtungMerken = 1; |
} |
} else FCFlags |= FCFLAG_FLY; |
} else FC_StatusFlags |= FC_STATUS_FLY; |
if((PPM_in[EE_Parameter.Kanalbelegung[K_GAS]] > 80) && MotorenEin == 0) |
{ |
739,7 → 739,7 |
} |
ServoActive = 0; |
SetNeutral(0); |
calibration_done = 1; |
calibration_done = 1; |
ServoActive = 1; |
DDRD |=0x80; // enable J7 -> Servo signal |
Piep(GetActiveParamSet(),120); |
793,7 → 793,7 |
Mess_IntegralRoll2 = IntegralRoll; |
SummeNick = 0; |
SummeRoll = 0; |
FCFlags |= FCFLAG_START; |
FC_StatusFlags |= FC_STATUS_START; |
ControlHeading = (((int) EE_Parameter.OrientationAngle * 15 + KompassValue) % 360) / 2; |
} |
else |
826,7 → 826,7 |
// neue Werte von der Funke |
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
if(!NewPpmData-- || (FCFlags & FCFLAG_NOTLANDUNG)) |
if(!NewPpmData-- || (FC_StatusFlags & FC_STATUS_EMERGENCY_LANDING)) |
{ |
static int stick_nick,stick_roll; |
ParameterZuordnung(); |
894,7 → 894,7 |
if(MaxStickRoll > 100) MaxStickRoll = 100; |
} |
else MaxStickRoll--; |
if(FCFlags & FCFLAG_NOTLANDUNG) {MaxStickNick = 0; MaxStickRoll = 0;} |
if(FC_StatusFlags & FC_STATUS_EMERGENCY_LANDING) {MaxStickNick = 0; MaxStickRoll = 0;} |
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
// Looping? |
946,7 → 946,7 |
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
// Bei Empfangsausfall im Flug |
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
if(FCFlags & FCFLAG_NOTLANDUNG) |
if(FC_StatusFlags & FC_STATUS_EMERGENCY_LANDING) |
{ |
StickGier = 0; |
StickNick = 0; |
1383,7 → 1383,7 |
LIMIT_MAX(CosAttitude, 60); // limit effective attitude angle |
CosAttitude = c_cos_8192(CosAttitude); // cos of actual attitude |
VarioCharacter = ' '; |
if(HoehenReglerAktiv && !(FCFlags & FCFLAG_NOTLANDUNG)) |
if(HoehenReglerAktiv && !(FC_StatusFlags & FC_STATUS_EMERGENCY_LANDING)) |
{ |
#define HEIGHT_TRIM_UP 0x01 |
#define HEIGHT_TRIM_DOWN 0x02 |
1406,7 → 1406,7 |
// PD-Control with respect to hoover point |
// the thrust loss out of horizontal attitude is compensated |
// the setpoint will be fine adjusted with the gas stick position |
if(FCFlags & FCFLAG_FLY) // trim setpoint only when flying |
if(FC_StatusFlags & FC_STATUS_FLY) // trim setpoint only when flying |
{ // gas stick is above hoover point |
if(StickGas > (StickGasHover + HEIGHT_CONTROL_STICKTHRESHOLD) && !BaroAtUpperLimit) |
{ |
1441,7 → 1441,7 |
if(!StartTrigger && HoehenWert > 50) |
{ |
StartTrigger = 1; |
} |
} |
} |
VarioCharacter = '='; |
} |
1491,11 → 1491,11 |
GasReduction = tmp_long; |
// ------------------------- D-Part 1: Vario Meter ---------------------------- |
tmp_int = VarioMeter / 8; |
LIMIT_MIN_MAX(tmp_int, -127, 128); |
LIMIT_MIN_MAX(tmp_int, -127, 128); |
tmp_int = (tmp_int * (long)Parameter_Luftdruck_D) / 4L; // scale to d-gain parameter |
LIMIT_MIN_MAX(tmp_int,-64 * STICK_GAIN, 64 * STICK_GAIN); |
if(HeightTrimmingFlag) tmp_int /= 4; // reduce d-part while trimming setpoint |
else |
else |
if(EE_Parameter.ExtraConfig & CFG2_HEIGHT_LIMIT) tmp_int /= 8; // reduce d-part in "Deckel" mode |
GasReduction += tmp_int; |
} // EOF no baro range expanding |
1505,7 → 1505,7 |
tmp_long = ((Mess_Integral_Hoch / 128L) * (int32_t) Parameter_Hoehe_ACC_Wirkung) / (128L / STICK_GAIN); |
LIMIT_MIN_MAX(tmp_long, -32 * STICK_GAIN, 64 * STICK_GAIN); |
GasReduction += tmp_long; |
} |
} |
// ------------------------ D-Part 3: GpsZ ---------------------------------- |
tmp_int = (Parameter_Hoehe_GPS_Z * (int)FromNaviCtrl_Value.GpsZ)/128L; |
LIMIT_MIN_MAX(tmp_int, -32 * STICK_GAIN, 64 * STICK_GAIN); |
1516,7 → 1516,7 |
// limit deviation from hoover point within the target region |
if(!HeightTrimming && HoverGas > 0) // height setpoint is not changed and hoover gas not zero |
{ |
unsigned int tmp; |
unsigned int tmp; |
tmp = abs(HeightDeviation); |
if(tmp <= 60) |
{ |
1523,7 → 1523,7 |
LIMIT_MIN_MAX(HCGas, HoverGasMin, HoverGasMax); // limit gas around the hoover point |
} |
else |
{ |
{ |
tmp = (tmp - 60) / 32; |
if(tmp > 15) tmp = 15; |
if(HeightDeviation > 0) |
1553,7 → 1553,7 |
{ // old version |
LIMIT_MAX(FilterHCGas, GasMischanteil); // nicht mehr als Gas |
GasMischanteil = FilterHCGas; |
} |
} |
else GasMischanteil = FilterHCGas + (GasMischanteil - HoverGas) / 4; // only in Vario-Mode |
} |
}// EOF height control active |
1572,7 → 1572,7 |
// Hover gas estimation by averaging gas control output on small z-velocities |
// this is done only if height contol option is selected in global config and aircraft is flying |
if((FCFlags & FCFLAG_FLY))// && !(FCFlags & FCFLAG_NOTLANDUNG)) |
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(StartTrigger == 1) StartTrigger = 2; |
1609,13 → 1609,13 |
HoverGasMin = 0; |
HoverGasMax = 1023; |
} |
} |
else |
} |
else |
{ |
StartTrigger = 0; |
HoverGasFilter = 0; |
HoverGas = 0; |
} |
} |
}// EOF ParamSet.GlobalConfig & CFG_HEIGHT_CONTROL |
// limit gas to parameter setting |
LIMIT_MIN(GasMischanteil, (MIN_GAS + 10) * STICK_GAIN); |
/trunk/fc.h |
---|
10,29 → 10,18 |
#define STICK_GAIN 4 |
#define ACC_AMPLIFY 6 |
#define FCFLAG_MOTOR_RUN 0x01 |
#define FCFLAG_FLY 0x02 |
#define FCFLAG_CALIBRATE 0x04 |
#define FCFLAG_START 0x08 |
#define FCFLAG_NOTLANDUNG 0x10 |
#define FCFLAG_LOWBAT 0x20 |
#define FCFLAG_SPI_RX_ERR 0x40 |
#define FCFLAG_I2CERR 0x80 |
// FC STATUS FLAGS |
#define FC_STATUS_MOTOR_RUN 0x01 |
#define FC_STATUS_FLY 0x02 |
#define FC_STATUS_CALIBRATE 0x04 |
#define FC_STATUS_START 0x08 |
#define FC_STATUS_EMERGENCY_LANDING 0x10 |
#define FC_STATUS_LOWBAT 0x20 |
#define FC_STATUS_RES1 0x40 |
#define FC_STATUS_RES2 0x80 |
#define DEFEKT_G_NICK 0x01 |
#define DEFEKT_G_ROLL 0x02 |
#define DEFEKT_G_GIER 0x04 |
#define DEFEKT_A_NICK 0x08 |
#define DEFEKT_A_ROLL 0x10 |
#define DEFEKT_A_Z 0x20 |
#define DEFEKT_PRESSURE 0x40 |
#define DEFEKT_CAREFREE_ERR 0x80 |
extern volatile unsigned char FC_StatusFlags; |
#define DEFEKT_I2C 0x01 |
#define DEFEKT_BL_MISSING 0x02 |
#define DEFEKT_SPI_RX_ERR 0x04 |
#define DEFEKT_PPM_ERR 0x08 |
#define DEFEKT_MIXER_ERR 0x10 |
#define Poti1 Poti[0] |
#define Poti2 Poti[1] |
43,7 → 32,6 |
#define Poti7 Poti[6] |
#define Poti8 Poti[7] |
extern volatile unsigned char FCFlags; |
extern unsigned char Sekunde,Minute; |
extern unsigned int BaroExpandActive; |
extern long IntegralNick,IntegralNick2; |
/trunk/led.c |
---|
28,18 → 28,18 |
{ |
delay = 4; |
if(FCFlags & (FCFLAG_LOWBAT | FCFLAG_NOTLANDUNG | FCFLAG_I2CERR)) |
if(FC_StatusFlags & (FC_STATUS_LOWBAT | FC_STATUS_EMERGENCY_LANDING) || (VersionInfo.HardwareError[1] | FC_ERROR1_I2C)) |
{ |
if(EE_Parameter.WARN_J16_Bitmask) |
if(EE_Parameter.WARN_J16_Bitmask) |
{ |
if(!J16Warn) J16Blinkcount = 4; |
J16Warn = 1; |
} |
if(EE_Parameter.WARN_J17_Bitmask) |
} |
if(EE_Parameter.WARN_J17_Bitmask) |
{ |
if(!J17Warn) J17Blinkcount = 4; |
J17Warn = 1; |
} |
} |
} |
else |
{ |
64,7 → 64,7 |
if(J16Mask & J16Bitmask) J16_ON; else J16_OFF; |
} |
} |
else |
else |
if(!J16Blinkcount--) |
{ |
J16Blinkcount = 10-1; |
87,7 → 87,7 |
if(J17Mask & J17Bitmask) J17_ON; else J17_OFF; |
} |
} |
else |
else |
if(!J17Blinkcount--) |
{ |
J17Blinkcount = 10-1; |
/trunk/libfc644.a |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
/trunk/main.c |
---|
202,7 → 202,7 |
} |
printf("\n\r==================================="); |
if(RequiredMotors < FoundMotors) VersionInfo.HardwareError[1] |= DEFEKT_MIXER_ERR; |
if(RequiredMotors < FoundMotors) VersionInfo.HardwareError[1] |= FC_ERROR1_MIXER; |
//if(EE_Parameter.GlobalConfig & CFG_HOEHENREGELUNG) |
{ |
264,12 → 264,12 |
else MotorRegler(); |
SendMotorData(); |
ROT_OFF; |
if(SenderOkay) { SenderOkay--; VersionInfo.HardwareError[1] &= ~DEFEKT_PPM_ERR; } |
if(SenderOkay) { SenderOkay--; VersionInfo.HardwareError[1] &= ~FC_ERROR1_PPM; } |
else |
{ |
TIMSK1 |= _BV(ICIE1); // enable PPM-Input |
PPM_in[0] = 0; // set RSSI to zero on data timeout |
VersionInfo.HardwareError[1] |= DEFEKT_PPM_ERR; |
VersionInfo.HardwareError[1] |= FC_ERROR1_PPM; |
} |
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
//if(HoehenReglerAktiv && NaviDataOkay && SenderOkay < 160 && SenderOkay > 10 && FromNaviCtrl_Value.SerialDataOkay > 220) SenderOkay = 160; |
282,8 → 282,7 |
I2C_Reset(); |
I2CTimeout = 5; |
DebugOut.Analog[28]++; // I2C-Error |
FCFlags |= FCFLAG_I2CERR; |
VersionInfo.HardwareError[1] |= DEFEKT_I2C; |
VersionInfo.HardwareError[1] |= FC_ERROR1_I2C; |
DebugOut.Status[1] |= 0x02; // BL-Error-Status |
} |
if((BeepMuster == 0xffff) && MotorenEin) |
295,10 → 294,10 |
else |
{ |
ROT_OFF; |
if(!beeptime) |
if(!beeptime) |
{ |
FCFlags &= ~FCFLAG_I2CERR; |
} |
VersionInfo.HardwareError[1] &= ~FC_ERROR1_I2C; |
} |
} |
if(!UpdateMotor) |
{ |
311,17 → 310,17 |
timer += 20; // 20 ms interval |
if(MissingMotor) |
{ |
VersionInfo.HardwareError[1] |= DEFEKT_BL_MISSING; |
VersionInfo.HardwareError[1] |= FC_ERROR1_BL_MISSING; |
DebugOut.Status[1] |= 0x02; // BL-Error-Status |
} |
else |
} |
else |
{ |
VersionInfo.HardwareError[1] &= ~DEFEKT_BL_MISSING; |
VersionInfo.HardwareError[1] &= ~FC_ERROR1_BL_MISSING; |
if(I2CTimeout > 6) DebugOut.Status[1] &= ~0x02; // BL-Error-Status |
} |
if(I2CTimeout > 6) VersionInfo.HardwareError[1] &= ~DEFEKT_I2C; |
} |
if(I2CTimeout > 6) VersionInfo.HardwareError[1] &= ~FC_ERROR1_I2C; |
if(PcZugriff) PcZugriff--; |
else |
{ |
338,21 → 337,19 |
if(NaviDataOkay > 200) |
{ |
NaviDataOkay--; |
FCFlags &= ~FCFLAG_SPI_RX_ERR; |
VersionInfo.HardwareError[1] &= ~DEFEKT_SPI_RX_ERR; |
VersionInfo.HardwareError[1] &= ~FC_ERROR1_SPI_RX; |
} |
else |
{ |
if(NC_Version.Compatible) |
{ |
FCFlags |= FCFLAG_SPI_RX_ERR; |
VersionInfo.HardwareError[1] |= DEFEKT_SPI_RX_ERR; |
VersionInfo.HardwareError[1] |= FC_ERROR1_SPI_RX; |
if(BeepMuster == 0xffff && MotorenEin) |
{ |
beeptime = 15000; |
BeepMuster = 0xA800; |
} |
} |
} |
GPS_Nick = 0; |
GPS_Roll = 0; |
//if(!beeptime) |
361,7 → 358,7 |
} |
if(UBat < BattLowVoltageWarning) |
{ |
FCFlags |= FCFLAG_LOWBAT; |
FC_StatusFlags |= FC_STATUS_LOWBAT; |
if(BeepMuster == 0xffff) |
{ |
beeptime = 6000; |
368,7 → 365,7 |
BeepMuster = 0x0300; |
} |
} |
else if(!beeptime) FCFlags &= ~FCFLAG_LOWBAT; |
else if(!beeptime) FC_StatusFlags &= ~FC_STATUS_LOWBAT; |
SPI_StartTransmitPacket(); |
SendSPI = 4; |
/trunk/makefile |
---|
9,7 → 9,7 |
VERSION_PATCH = 0 |
VERSION_SERIAL_MAJOR = 11 # Serial Protocol |
VERSION_SERIAL_MINOR = 0 # Serial Protocol |
NC_SPI_COMPATIBLE = 14 # Navi-Kompatibilität |
NC_SPI_COMPATIBLE = 15 # Navi-Kompatibilität |
#------------------------------------------------------------------- |
# get SVN revision |
/trunk/menu.c |
---|
51,7 → 51,7 |
else |
if(MissingMotor) LCD_printfxy(0,3,"Missing BL-Ctrl:%d!!",MissingMotor) |
else |
if(VersionInfo.HardwareError[1] & DEFEKT_MIXER_ERR) LCD_printfxy(0,3,"Mixer Error!") |
if(VersionInfo.HardwareError[1] & FC_ERROR1_MIXER) LCD_printfxy(0,3,"Mixer Error!") |
else |
// if(VersionInfo.HardwareError[1]) LCD_printfxy(0,3,"Error 2:%d !!",VersionInfo.HardwareError[1]) |
// else |
/trunk/spi.c |
---|
177,8 → 177,8 |
ToNaviCtrl.Param.Byte[5] = Parameter_UserParam6; |
ToNaviCtrl.Param.Byte[6] = Parameter_UserParam7; |
ToNaviCtrl.Param.Byte[7] = Parameter_UserParam8; |
ToNaviCtrl.Param.Byte[8] = (unsigned char) FCFlags; |
FCFlags &= ~(FCFLAG_CALIBRATE | FCFLAG_START); |
ToNaviCtrl.Param.Byte[8] = FC_StatusFlags; |
FC_StatusFlags &= ~(FC_STATUS_CALIBRATE | FC_STATUS_START); |
ToNaviCtrl.Param.Byte[9] = GetActiveParamSet(); |
ToNaviCtrl.Param.Byte[10] = ControlHeading; |
break; |
251,6 → 251,8 |
ToNaviCtrl.Param.Byte[5] = VersionInfo.HardwareError[0]; |
ToNaviCtrl.Param.Byte[6] = VersionInfo.HardwareError[1]; |
ToNaviCtrl.Param.Byte[7] = VersionInfo.HardwareError[2]; |
ToNaviCtrl.Param.Byte[8] = VersionInfo.HardwareError[3]; |
ToNaviCtrl.Param.Byte[9] = VersionInfo.HardwareError[4]; |
break; |
case SPI_FCCMD_SERVOS: |
ToNaviCtrl.Param.Byte[0] = EE_Parameter.ServoNickRefresh; // Parameters for the Servo Control |
/trunk/twimaster.c |
---|
142,7 → 142,7 |
TWDR = 0; |
TWSR = 0; |
TWBR = 0; |
I2C_TransferActive = 0; |
I2C_TransferActive = 0; |
I2C_Init(0); |
I2C_WriteByte(0); |
BLFlags |= BLFLAG_READ_VERSION; |
297,7 → 297,7 |
{ |
if(BLFlags & BLFLAG_READ_VERSION) |
{ |
if(!(FCFlags & FCFLAG_MOTOR_RUN) && (Motor[motor_read].MaxPWM == 250) ) Motor[motor_read].Version |= MOTOR_STATE_NEW_PROTOCOL_MASK; |
if(!(FC_StatusFlags & FC_STATUS_MOTOR_RUN) && (Motor[motor_read].MaxPWM == 250) ) Motor[motor_read].Version |= MOTOR_STATE_NEW_PROTOCOL_MASK; |
else Motor[motor_read].Version = 0; |
} |
if(++motor_read >= MAX_MOTORS) |
/trunk/uart.c |
---|
355,7 → 355,7 |
memcpy(&Mixer, (unsigned char *)pRxData, sizeof(Mixer) - 1); |
MixerTable_WriteToEEProm(); |
tempchar1 = 1; |
VersionInfo.HardwareError[1] &= ~DEFEKT_MIXER_ERR; |
VersionInfo.HardwareError[1] &= ~FC_ERROR1_MIXER; |
} |
else |
{ |
/trunk/uart.h |
---|
63,6 → 63,27 |
}; |
extern struct str_ExternControl ExternControl; |
// FC hardware errors |
// bitmask for UART_VersionInfo_t.HardwareError[0] |
#define FC_ERROR0_GYRO_NICK 0x01 |
#define FC_ERROR0_GYRO_ROLL 0x02 |
#define FC_ERROR0_GYRO_YAW 0x04 |
#define FC_ERROR0_ACC_NICK 0x08 |
#define FC_ERROR0_ACC_ROLL 0x10 |
#define FC_ERROR0_ACC_TOP 0x20 |
#define FC_ERROR0_PRESSURE 0x40 |
#define FC_ERROR0_CAREFREE 0x80 |
// bitmask for UART_VersionInfo_t.HardwareError[1] |
#define FC_ERROR1_I2C 0x01 |
#define FC_ERROR1_BL_MISSING 0x02 |
#define FC_ERROR1_SPI_RX 0x04 |
#define FC_ERROR1_PPM 0x08 |
#define FC_ERROR1_MIXER 0x10 |
#define FC_ERROR1_RES1 0x20 |
#define FC_ERROR1_RES2 0x40 |
#define FC_ERROR1_RES3 0x80 |
struct str_VersionInfo |
{ |
unsigned char SWMajor; |