Subversion Repositories FlightCtrl

Compare Revisions

Ignore whitespace Rev 1764 → Rev 1765

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