• MikroKopter.de
• Wiki
• SHOP
• Datenschutz
• Impressum

FlightCtrlBL-CtrlMK3MagNaviCtrlProjects

Català-Valencià – Catalan中文 – Chinese (Simplified)中文 – Chinese (Traditional)Česky – CzechDansk – DanishNederlands – DutchEnglish – EnglishSuomi – FinnishFrançais – FrenchDeutsch – Germanעברית – Hebrewहिंदी – HindiMagyar – HungarianBahasa Indonesia – IndonesianItaliano – Italian日本語 – Japanese한국어 – KoreanМакедонски – Macedonianमराठी – MarathiNorsk – NorwegianPolski – PolishPortuguês – PortuguesePortuguês – Portuguese (Brazil)Русский – RussianSlovenčina – SlovakSlovenščina – SlovenianEspañol – SpanishSvenska – SwedishTürkçe – TurkishУкраїнська – UkrainianOëzbekcha – Uzbek

Compare Revisions

• This comparison shows the changes necessary to convert path

  → / @ 2346

  → / @ 2347

  ↔ Reverse comparison

• Compare Path:	Rev

  With Path:	Rev

Ignore whitespace Rev 2346 → Rev 2347

/beta/Code Redesign killagreg/eeprom.c
72,6 → 72,7
#include "main.h"
#include "fc.h"
#include "twimaster.h"
#include "libfc.h"
paramset_t ParamSet;
MixerTable_t Mixer;
144,16 → 145,16
ParamSet.Config0 = CFG0_AXIS_COUPLING_ACTIVE | CFG0_COMPASS_ACTIVE | CFG0_GPS_ACTIVE | CFG0_HEIGHT_SWITCH;//CFG0_HEIGHT_CONTROL | CFG0_COMPASS_FIX;
ParamSet.Config1 = 0;
ParamSet.Config2 = /*CFG2_HEIGHT_LIMIT |*/ CFG2_VARIO_BEEP;//|CFG2_SENSITIVE_RC;
ParamSet.Config2 = CFG2_GPS_AID | CFG2_VARIO_BEEP;
ParamSet.HeightMinGas = 30;
ParamSet.MaxHeight = 255;
ParamSet.HeightP = 15;
ParamSet.HeightSwitch = 255;
ParamSet.HeightP = 15; //Wert 0-50: (15 -> ca. +/- 5m/sek bei Stick-Voll-Ausschlag)
ParamSet.HeightD = 30;
ParamSet.Height_ACC_Effect = 0;
ParamSet.Height_HoverBand = 8;
ParamSet.Height_GPS_Z = 64;
ParamSet.Height_StickNeutralPoint = 0; // Value : 0-250 (0 = Hoover-Estimation)
ParamSet.Height_Gain = 20;
ParamSet.Height_Gain = 15; // Value : 0-50 (15 -> ca. +/- 5m/sek bei Stick-Voll-Ausschlag)
ParamSet.GasMin = 8;
ParamSet.GasMax = 230;
ParamSet.CompassYawEffect = 64;
199,20 → 200,24
ParamSet.NaviGpsI = 90;
ParamSet.NaviGpsD = 90;
ParamSet.NaviGpsPLimit = 75;
ParamSet.NaviGpsILimit = 75;
ParamSet.NaviGpsILimit = 85;
ParamSet.NaviGpsDLimit = 75;
ParamSet.NaviGpsACC = 0;
ParamSet.NaviGpsMinSat = 6;
ParamSet.NaviStickThreshold = 8;
ParamSet.NaviWindCorrection = 90;
ParamSet.NaviSpeedCompensation = 30;
ParamSet.NaviAccCompensation = 42;
ParamSet.NaviOperatingRadius = 245;
ParamSet.NaviAngleLimitation = 100;
ParamSet.NaviPHLoginTime = 2;
ParamSet.NaviAngleLimitation = 140;
ParamSet.NaviPHLoginTime = 5;
ParamSet.ExternalControl = 0;
ParamSet.OrientationAngle = 0;
ParamSet.OrientationModeControl = 0;
ParamSet.CareFreeModeControl = 0;
ParamSet.MotorSafetySwitch = 0;
ParamSet.MotorSmooth = 0;
ParamSet.ComingHomeAltitude = 0; // 0 = don't change
ParamSet.FailSafeTime = 0; // 0 = off
ParamSet.MaxAltitude = 150; // 0 = off
}
/***************************************************/
351,6 → 356,9
// read paramset from eeprom
eeprom_read_block((void *) &ParamSet, (void*)(EEPROM_ADR_PARAMSET + PARAMSET_STRUCT_LEN * (setnumber - 1)), PARAMSET_STRUCT_LEN);
LED_Init();
#if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__))
LIBFC_HoTT_Clear();
#endif
return 1;
}
367,6 → 375,8
if(setnumber > 5) setnumber = 5;
if(setnumber < 1) return 0;
LIBFC_CheckSettings();
// update checksum
ParamSet.crc = RAM_Checksum((uint8_t*)(&ParamSet), sizeof(ParamSet)-1);
383,6 → 393,9
// update active settings number
SetActiveParamSet(setnumber);
LED_Init();
#if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__))
LIBFC_HoTT_Clear();
#endif
return 1;
}
// wrong revision
528,7 → 541,6
if(EEPARAM_REVISION != GetParamByte(PID_EE_REVISION) )
{
ee_default = 1; // software update or forced by mktool
SetParamByte(PID_EE_REVISION, EEPARAM_REVISION);
}
585,12 → 597,14
printf("\n\rUsing Parameter Set %d", i);
// load mixer table
if(ee_default || !MixerTable_ReadFromEEProm() )
if(GetParamByte(PID_EE_REVISION) == 0xFF || !MixerTable_ReadFromEEProm() )
{
printf("\n\rGenerating default Mixer Table");
MixerTable_Default(); // Quadro
MixerTable_WriteToEEProm();
}
if(ee_default) SetParamByte(PID_EE_REVISION, EEPARAM_REVISION);
// determine motornumber
RequiredMotors = 0;
for(i = 0; i < 16; i++)

/beta/Code Redesign killagreg/eeprom.h
5,7 → 5,7
#include "twimaster.h"
#define EEPARAM_REVISION 85 // is count up, if paramater stucture has changed (compatibility)
#define EEPARAM_REVISION 87 // is count up, if paramater stucture has changed (compatibility)
#define EEMIXER_REVISION 1 // is count up, if mixer stucture has changed (compatibility)
#define EEBLCONFIG_REVISON 35 // is count up, if blconfig stucture has changed (compatibility to BLs!)
57,10 → 57,10
#define CFG1_LOOP_DOWN 0x02
#define CFG1_LOOP_LEFT 0x04
#define CFG1_LOOP_RIGHT 0x08
#define CFG1_MOTOR_BLINK 0x10
#define CFG1_MOTOR_BLINK1 0x10
#define CFG1_MOTOR_OFF_LED1 0x20
#define CFG1_MOTOR_OFF_LED2 0x40
#define CFG1_RES4 0x80
#define CFG1_MOTOR_BLINK2 0x80
// bit mask for ParamSet.Config2
#define CFG2_HEIGHT_LIMIT 0x01
67,9 → 67,9
#define CFG2_VARIO_BEEP 0x02
#define CFG2_SENSITIVE_RC 0x04
#define CFG2_3V3_REFERENCE 0x08
#define CFG2_RES2 0x10
#define CFG2_RES3 0x20
#define CFG2_RES4 0x40
#define CFG2_NO_RCOFF_BEEPING 0x10
#define CFG2_GPS_AID 0x20
#define CFG2_LEARNABLE_CAREFREE 0x40
#define CFG2_RES5 0x80
// defines for the receiver selection
115,7 → 115,7
uint8_t Config0; // see upper defines for bitcoding
uint8_t HeightMinGas; // Value : 0-100
uint8_t HeightD; // Value : 0-247
uint8_t MaxHeight; // Value : 0-32
uint8_t HeightSwitch; // Value : 0-247
uint8_t HeightP; // Value : 0-32
uint8_t Height_Gain; // Value : 0-50
uint8_t Height_ACC_Effect; // Value : 0-247
194,7 → 194,7
uint8_t NaviGpsMinSat; // number of sattelites neccesary for GPS functions
uint8_t NaviStickThreshold; // activation threshild for detection of manual stick movements
uint8_t NaviWindCorrection; // streng of wind course correction
uint8_t NaviSpeedCompensation; // D gain fefore position hold login
uint8_t NaviAccCompensation; // D gain before position hold login
uint8_t NaviOperatingRadius; // Radius limit in m around start position for GPS flights
uint8_t NaviAngleLimitation; // limitation of attitude angle controlled by the gps algorithm
uint8_t NaviPHLoginTime; // position hold logintimeout
202,8 → 202,12
uint8_t ExternalControl; // for serial control
//---CareFree---------------------------------------------
uint8_t OrientationAngle; // Where is the front-direction in steps of 15°?
uint8_t OrientationModeControl; // switch for CareFre
uint8_t CareFreeModeControl; // switch for CareFre
uint8_t MotorSafetySwitch;
uint8_t MotorSmooth; // motor smoothing
uint8_t ComingHomeAltitude;
uint8_t FailSafeTime;
uint8_t MaxAltitude;
// config
uint8_t Config1; // see upper defines for bitcoding
uint8_t ServoCompInvert; // Bitfield: 0x01 = Nick invert, 0x02 = Roll invert // WICHTIG!!! am Ende lassen

/beta/Code Redesign killagreg/fc.c
120,7 → 120,7
// compass course
int16_t CompassHeading = -1; // negative angle indicates invalid data.
int16_t CompassCourse = -1; // compass course setpoint
int16_t CompassOffCourse = 0;
//int16_t CompassOffCourse = 0;
uint8_t CompassCalState = 0;
int8_t CalculateCompassTimer = 100;
uint8_t CompassFusion = 32;
129,12 → 129,12
uint16_t BadCompassHeading = 50;
uint8_t FunnelCourse = 0;
int32_t YawGyroHeading; // Yaw Gyro Integral supported by compass
int16_t YawGyroHeadingDeg;
int16_t YawGyroDrift;
int16_t NaviAccNick = 0, NaviAccRoll = 0, NaviCntAcc = 0;
// MK flags
uint16_t ModelIsFlying = 0;
165,6 → 165,9
// stick values derived by rc channels readings
int16_t StickNick = 0, StickRoll = 0, StickYaw = 0, StickGas = 0;
// height control hover gas value;
int16_t StickGasHover = RC_GAS_OFFSET;
// gps control signals
int16_t GPSStickNick = 0, GPSStickRoll = 0;
int16_t MaxStickNick = 0, MaxStickRoll = 0;
173,6 → 176,8
int16_t ExternStickNick = 0, ExternStickRoll = 0, ExternStickYaw = 0, ExternHeightValue = -20;
int32_t SetPointHeight = 0;
int16_t AltitudeSetpointTrimming = 0;
int8_t WaypointTrimming = 0;
int16_t ControlHeading = 0; // roll/nick rotation angle in steps of 2°
int16_t AttitudeCorrectionRoll = 0, AttitudeCorrectionNick = 0;
181,7 → 186,7
uint8_t LoopingLeft = 0, LoopingRight = 0, LoopingDown = 0, LoopingTop = 0;
fc_param_t FCParam = {48,251,16,58,64,64,8,150,150,150,150,2,10,0,0,0,0,0,0,0,0,100,100,70,90,65,64,100,0,0,0};
fc_param_t FCParam = {48,251,16,58,64,64,8,150,150,150,150,2,10,0,0,0,0,0,0,0,0,100,100,70,90,65,64,100,0,0,0,0,0,0};
200,7 → 205,7
DebugOut.Analog[8] = CompassHeading;
DebugOut.Analog[9] = UBat;
DebugOut.Analog[10] = RC_Quality;
DebugOut.Analog[11] = YawGyroHeading / GYRO_DEG_FACTOR;
DebugOut.Analog[11] = YawGyroHeadingDeg;
DebugOut.Analog[12] = Motor[0].SetPoint;
DebugOut.Analog[13] = Motor[1].SetPoint;
DebugOut.Analog[14] = Motor[2].SetPoint;
244,7 → 249,7
uint8_t i;
int32_t Sum_1, Sum_2 = 0, Sum_3;
//Servo_Off(); // disable servo output
Servo_Off(); // disable servo output
UART_VersionInfo.HardwareError[0] = 0;
368,8 → 373,8
ExternHeightValue = 0;
GPSStickNick = 0;
GPSStickRoll = 0;
//GPSStickNick = 0;
//GPSStickRoll = 0;
FC_StatusFlags |= FC_STATUS_CALIBRATE;
382,7 → 387,7
Poti[i] = PPM_in[ParamSet.ChannelAssignment[CH_POTI1+i]] + RC_POTI_OFFSET;
}
//Servo_On(); //enable servo output
Servo_On(); //enable servo output
RC_Quality = 100;
if((BiasHiResGyroNick < 150 * 16) || (BiasHiResGyroNick > 850 * 16)) { UART_VersionInfo.HardwareError[0] |= FC_ERROR0_GYRO_NICK; };
391,6 → 396,10
if((AdBiasAccNick < 300 * 2) || (AdBiasAccNick > 750 * 2)) { UART_VersionInfo.HardwareError[0] |= FC_ERROR0_ACC_NICK; };
if((AdBiasAccRoll < 300 * 2) || (AdBiasAccRoll > 750 * 2)) { UART_VersionInfo.HardwareError[0] |= FC_ERROR0_ACC_ROLL; };
if((AdBiasAccTop < 512) || (AdBiasAccTop > 850 )) { UART_VersionInfo.HardwareError[0] |= FC_ERROR0_ACC_TOP; };
#if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__))
LIBFC_HoTT_Clear();
#endif
}
/************************************************************************/
477,7 → 486,7
// Coupling fraction
if(! LoopingNick && !LoopingRoll && (ParamSet.Config0 & CFG0_AXIS_COUPLING_ACTIVE))
if(! LoopingNick && !LoopingRoll && (FCParam.Config0 & CFG0_AXIS_COUPLING_ACTIVE))
{
tmp13 = (FilterGyroRoll * AngleNick) / 2048L;
tmp13 *= FCParam.AxisCoupling2;
583,7 → 592,7
else TrimRoll -= ((int32_t)abs(CouplingNickRoll) * FCParam.AxisCouplingYawCorrection) / 64L;
// increase the nick/roll rates virtually from the threshold of 245 to slow down higher rotation rates
if((ParamSet.Config0 & CFG0_ROTARY_RATE_LIMITER) && ! LoopingNick && !LoopingRoll)
if((FCParam.Config0 & CFG0_ROTARY_RATE_LIMITER) && ! LoopingNick && !LoopingRoll)
{
if(FilterGyroNick > 256) GyroNick += 1 * (FilterGyroNick - 256);
else if(FilterGyroNick < -256) GyroNick += 1 * (FilterGyroNick + 256);
651,13 → 660,15
#define POTI_MAX 255
for(i=0; i<8; i++)
{
int tmp;
tmp = PPM_in[ParamSet.ChannelAssignment[CH_POTI1+i]] + RC_POTI_OFFSET;
LIMIT_MIN_MAX(tmp, POTI_MIN, POTI_MAX);
if(tmp != Poti[i])
int16_t tmp2;
tmp = ParamSet.ChannelAssignment[CH_POTI1+i];
tmp2 = PPM_in[tmp] + RC_POTI_OFFSET;
LIMIT_MIN_MAX(tmp2, POTI_MIN, POTI_MAX);
if(tmp == 25) Poti[i] = tmp2; // 25 = WaypointEvent channel -> no filter
else if(tmp2 != Poti[i])
{
Poti[i] += (tmp - Poti[i]) / 8;
if(Poti[i] > tmp) Poti[i]--;
Poti[i] += (tmp2 - Poti[i]) / 4;
if(Poti[i] > tmp2) Poti[i]--;
else Poti[i]++;
}
}
666,9 → 677,9
CHK_POTI_MM(FCParam.HeightP,ParamSet.HeightP,0,100);
CHK_POTI_MM(FCParam.GyroP,ParamSet.GyroP,10,255);
CHK_POTI_MM(FCParam.GyroYawP,ParamSet.GyroYawP,10,255);
CHK_POTI_MM(FCParam.J16Timing,ParamSet.J16Timing,1,255);
CHK_POTI_MM(FCParam.J17Timing,ParamSet.J17Timing,1,255);
CHK_POTI(FCParam.MaxHeight,ParamSet.MaxHeight);
CHK_POTI_MM(FCParam.J16Timing,ParamSet.J16Timing,5,255);
CHK_POTI_MM(FCParam.J17Timing,ParamSet.J17Timing,5,255);
CHK_POTI(FCParam.HeightSwitch,ParamSet.HeightSwitch);
CHK_POTI(FCParam.Height_ACC_Effect,ParamSet.Height_ACC_Effect);
CHK_POTI(FCParam.Height_GPS_Z,ParamSet.Height_GPS_Z);
CHK_POTI(FCParam.CompassYawEffect,ParamSet.CompassYawEffect);
695,9 → 706,12
CHK_POTI(FCParam.AxisCouplingYawCorrection,ParamSet.AxisCouplingYawCorrection);
CHK_POTI(FCParam.DynamicStability,ParamSet.DynamicStability);
CHK_POTI(FCParam.ExternalControl,ParamSet.ExternalControl);
CHK_POTI(FCParam.MaxAltitude,ParamSet.MaxAltitude);
FCParam.Config0 = ParamSet.Config0;
FCParam.Config2 = ParamSet.Config2;
Ki = 10300 / ( FCParam.IFactor + 1 );
CHK_POTI(tmp,ParamSet.OrientationModeControl);
CHK_POTI(tmp, ParamSet.CareFreeModeControl);
if(tmp > 50) // care free should be set on
{
// check dependencies like valid compass heading
716,9 → 730,6
}
else // everthing ok
{
#ifdef SWITCH_LEARNS_CAREFREE
if(!CareFree) ControlHeading = (((int16_t) ParamSet.OrientationAngle * 15 + CompassHeading) % 360) / 2;
#endif
CareFree = 1;
if(FCParam.AxisCoupling1 < 210) FCParam.AxisCoupling1 += 30;
FC_StatusFlags2 |= FC_STATUS2_CAREFREE;
729,7 → 740,7
{
CareFree = 0;
FC_StatusFlags2 &= ~FC_STATUS2_CAREFREE;
UART_VersionInfo.HardwareError[0] &= ~FC_ERROR0_CAREFREE; // reset error flag
//UART_VersionInfo.HardwareError[0] &= ~FC_ERROR0_CAREFREE; // reset error flag
}
// accoustic signal when CareFree state transition
if(CareFree != CareFreeOld)
738,6 → 749,15
else BeepTime = 200; // has been disabled
CareFreeOld = CareFree; // resync
}
// Limit the maximum altitude
if(FCParam.MaxAltitude)
{
if( (SetPointHeight/100) > FCParam.MaxAltitude)
{
SetPointHeight = (int32_t) FCParam.MaxAltitude * 100L;
}
}
}
}
788,7 → 808,6
static int16_t MotorValue[MAX_MOTORS];
Mean();
GRN_ON;
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// RC-signal is bad
886,7 → 905,7
// update active parameter set in eeprom
SetActiveParamSet(setting);
ParamSet_ReadFromEEProm(GetActiveParamSet());
if(ParamSet.Config0 & CFG0_AIRPRESS_SENSOR)
if(FCParam.Config0 & CFG0_AIRPRESS_SENSOR)
{
if((AdAirPressure > AIR_PRESSURE_SEARCH_MAX) || (AdAirPressure < AIR_PRESSURE_SEARCH_MIN)) SearchAirPressureOffset();
}
1003,7 → 1022,7
ReadingIntegralGyroRoll2 = IntegralGyroRoll;
IPartNick = 0;
IPartRoll = 0;
ControlHeading = (((int16_t)ParamSet.OrientationAngle * 15 + CompassHeading) % 360) / 2;
//ControlHeading = (((int16_t)ParamSet.OrientationAngle * 15 + CompassHeading) % 360) / 2;
UpdateCompassCourse = 100; // 2 seconds
}
else
1080,6 → 1099,12
StickRoll = ((cos_h * stick_roll) - (sin_h * stick_nick)) / 8;
}
if(NCGPSAidMode) // reduce rc stick effect in that case
{
StickNick /= 2;
StickRoll /= 2;
}
StickNick -= GPSStickNick;
StickRoll -= GPSStickRoll;
1121,7 → 1146,7
if(StickGas < 0) StickGas = 0;
// disable I part of gyro control feedback
if(ParamSet.Config0 & CFG0_HEADING_HOLD) GyroIFactor = 0;
if(FCParam.Config0 & CFG0_HEADING_HOLD) GyroIFactor = 0;
// update max stick positions for nick and roll
if(abs(StickNick / STICK_GAIN) > MaxStickNick)
1189,6 → 1214,18
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// in case of emergency landing
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
if(FC_StatusFlags2 & FC_STATUS2_RC_FAILSAVE_ACTIVE)
{
StickNick = -GPSStickNick;
StickRoll = -GPSStickRoll;
StickYaw = 0;
StickGas = StickGasHover; // set to hover point
FCParam.Config0 &= ~(CFG0_HEADING_HOLD | CFG0_ROTARY_RATE_LIMITER);
FCParam.Config0 |= CFG0_AIRPRESS_SENSOR | CFG0_AXIS_COUPLING_ACTIVE | CFG0_COMPASS_ACTIVE | CFG0_GPS_ACTIVE | CFG0_HEIGHT_SWITCH;
FCParam.Config2 &= ~(CFG2_HEIGHT_LIMIT | CFG2_LEARNABLE_CAREFREE | CFG2_VARIO_BEEP);
FCParam.HeightSwitch = 200; // switch on
}
else
// set all inputs to save values
if(FC_StatusFlags & FC_STATUS_EMERGENCY_LANDING)
{
1239,9 → 1276,9
if( FCParam.KalmanK > 0)
{
// determine the deviation of gyro integral from averaged acceleration sensor
tmp_long1 = (int32_t)(IntegralGyroNick / ParamSet.GyroAccFactor - (int32_t)AccNick);
tmp_long1 = (int32_t)(IntegralGyroNick / ParamSet.GyroAccFactor - (int32_t)(AccNick - FromNaviCtrl.AccErrorN));
tmp_long1 = (tmp_long1 * FCParam.KalmanK) / (32 * 16);
tmp_long2 = (int32_t)(IntegralGyroRoll / ParamSet.GyroAccFactor - (int32_t)AccRoll);
tmp_long2 = (int32_t)(IntegralGyroRoll / ParamSet.GyroAccFactor - (int32_t)(AccRoll - FromNaviCtrl.AccErrorR));
tmp_long2 = (tmp_long2 * FCParam.KalmanK) / (32 * 16);
CompassFusion = FCParam.KalmanK;
if((MaxStickNick > 64) || (MaxStickRoll > 64)) // reduce effect during stick commands
1459,7 → 1496,7
if(abs(StickYaw) > 3 ) // yaw stick is activated
{
//BadCompassHeading = 1000;
if(!(ParamSet.Config0 & CFG0_COMPASS_FIX))
if(!(FCParam.Config0 & CFG0_COMPASS_FIX))
{
UpdateCompassCourse = 50; // one second for login
}
1478,7 → 1515,7
// Compass
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// compass code is used only if compass option is selected
if( (CompassHeading >= 0) && (ParamSet.Config0 & (CFG0_COMPASS_ACTIVE|CFG0_GPS_ACTIVE)))
if( (CompassHeading >= 0) && (FCParam.Config0 & (CFG0_COMPASS_ACTIVE|CFG0_GPS_ACTIVE)))
{
if(CalculateCompassTimer-- == 1)
{
1497,7 → 1534,8
if(v > w) w = v;
correction = w / 4 + 1;
// calculate the deviation of the yaw gyro heading and the compass heading
error = ((540 + CompassHeading - (YawGyroHeading / GYRO_DEG_FACTOR)) % 360) - 180;
YawGyroHeadingDeg = YawGyroHeading / GYRO_DEG_FACTOR;
error = ((540 + CompassHeading - YawGyroHeadingDeg) % 360) - 180;
// log in compass value
if(BadCompassHeading) BadCompassHeading--;
else if(w < 25)
1507,8 → 1545,8
{
if(--UpdateCompassCourse == 0)
{
YawGyroHeading = (int32_t)CompassHeading * GYRO_DEG_FACTOR;
CompassCourse = (int16_t)(YawGyroHeading / GYRO_DEG_FACTOR);
//YawGyroHeading = (int32_t)CompassHeading * GYRO_DEG_FACTOR;
CompassCourse = YawGyroHeadingDeg;
}
}
}
1517,7 → 1555,7
// yawing MK
if(!UpdateCompassCourse)
{
r = ((540 + CompassCourse - (YawGyroHeading / GYRO_DEG_FACTOR)) % 360) - 180;
r = ((540 + CompassCourse - YawGyroHeadingDeg) % 360) - 180;
v = r * (FCParam.CompassYawEffect/2);
CompassYawSetPoint = v / 16;
}
1593,7 → 1631,7
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Airpressure sensor is enabled
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
if((ParamSet.Config0 & CFG0_AIRPRESS_SENSOR) && !(LoopingRoll || LoopingNick) )
if((FCParam.Config0 & CFG0_AIRPRESS_SENSOR) && !(LoopingRoll || LoopingNick) )
{
int16_t CosAttitude; // for projection of hoover gas
int16_t HCGas, HeightDeviation = 0;
1602,7 → 1640,7
static int16_t FilterHCGas = 0;
static int16_t HeightTrimming = 0; // rate for change of height setpoint
static int8_t WaypointTrimming = 0;
//static int8_t WaypointTrimming = 0;
static uint8_t HCActive = 0;
// the states for the hover gas filter
#define HOVER_GAS_STATE_NONE 0
1612,7 → 1650,7
#define HOVER_GAS_AVERAGE 16384L // 16384 * 2ms = 32.8s averaging
static uint32_t HoverGasFilter = 0; // for averaging of GasMixFraction
static int16_t StickGasHover = RC_GAS_OFFSET, HoverGas = 0, HoverGasMin = 0, HoverGasMax = 1023;
static int16_t HoverGas = 0, HoverGasMin = 0, HoverGasMax = 1023;
static uint8_t delay = 100;
1673,9 → 1711,9
// if height control is activated by an rc channel
if(ParamSet.Config0 & CFG0_HEIGHT_SWITCH)
if(FCParam.Config0 & CFG0_HEIGHT_SWITCH)
{ // check if parameter is less than activation threshold
if( FCParam.MaxHeight < 50 ) // for 3 or 2-state switch height control is disabled in lowest position
if( FCParam.HeightSwitch < 50 ) // for 3 or 2-state switch height control is disabled in lowest position
{ //height control not active
if(!delay--)
{
1694,7 → 1732,7
{ // the height control is always active and the set point is defined by the parameter
if( !(BaroFlags & (BARO_LIMIT_MIN|BARO_LIMIT_MAX)) )
{
SetPointHeight = ((int16_t) ExternHeightValue + (int16_t) FCParam.MaxHeight) * (int16_t)ParamSet.Height_Gain;
SetPointHeight = ((int16_t) ExternHeightValue + (int16_t) FCParam.HeightSwitch) * (int16_t)ParamSet.Height_Gain;
}
HCActive = 1;
}
1706,12 → 1744,13
LIMIT_MAX(CosAttitude, 60); // limit effective attitude angle
CosAttitude = c_cos_8192(CosAttitude); // cos of actual attitude
VarioCharacter = ' ';
AltitudeSetpointTrimming = 0;
if(HCActive && !(FC_StatusFlags & FC_STATUS_EMERGENCY_LANDING))
{
FC_StatusFlags2 |= FC_STATUS2_ALTITUDE_CONTROL;
if((ParamSet.Config2 & CFG2_HEIGHT_LIMIT) || !(ParamSet.Config0 & CFG0_HEIGHT_SWITCH))
if((FCParam.Config2 & CFG2_HEIGHT_LIMIT) || !(FCParam.Config0 & CFG0_HEIGHT_SWITCH))
{
// Holgers original version
// start of height control algorithm
1721,6 → 1760,7
HCGas = GasMixFraction; // take current stick gas as neutral point for the height control
HeightTrimming = 0;
AltitudeSetpointTrimming = 0;
// set undefined state to indicate vario off
FC_StatusFlags |= (FC_STATUS_VARIO_TRIM_UP|FC_STATUS_VARIO_TRIM_DOWN);
}
1740,7 → 1780,8
SetPointHeight = ReadingHeight; // update setpoint to current height
}
FC_StatusFlags |= FC_STATUS_VARIO_TRIM_UP;
HeightTrimming += abs(StickGas - (StickGasHover + HC_STICKTHRESHOLD));
AltitudeSetpointTrimming = abs(StickGas - (StickGasHover + HC_STICKTHRESHOLD));
//HeightTrimming += abs(StickGas - (StickGasHover + HC_STICKTHRESHOLD));
VarioCharacter = '+';
WaypointTrimming= 0;
} // gas stick is below hover point
1752,7 → 1793,8
SetPointHeight = ReadingHeight; // update setpoint to current heigth
}
FC_StatusFlags |= FC_STATUS_VARIO_TRIM_DOWN;
HeightTrimming -= abs(StickGas - (StickGasHover - HC_STICKTHRESHOLD));
AltitudeSetpointTrimming = -abs(StickGas - (StickGasHover - HC_STICKTHRESHOLD));
//HeightTrimming -= abs(StickGas - (StickGasHover - HC_STICKTHRESHOLD));
VarioCharacter = '-';
WaypointTrimming= 0;
}
1762,7 → 1804,8
if(NCAltitudeSpeed && (NCSetPointHeight > SetPointHeight))
{
FC_StatusFlags |= FC_STATUS_VARIO_TRIM_UP;
HeightTrimming += NCAltitudeSpeed;
AltitudeSetpointTrimming = NCAltitudeSpeed;
//HeightTrimming += NCAltitudeSpeed;
WaypointTrimming = 10;
VarioCharacter = '^';
if(FC_StatusFlags & FC_STATUS_VARIO_TRIM_DOWN) // changed from sinking to rising
1774,7 → 1817,8
else if(NCAltitudeSpeed && (NCSetPointHeight < SetPointHeight))
{
FC_StatusFlags |= FC_STATUS_VARIO_TRIM_DOWN;
HeightTrimming -= NCAltitudeSpeed;
AltitudeSetpointTrimming = -NCAltitudeSpeed;
//HeightTrimming -= NCAltitudeSpeed;
WaypointTrimming = -10;
VarioCharacter = 'v';
if(FC_StatusFlags & FC_STATUS_VARIO_TRIM_UP) // changed from rising to sinking
1787,9 → 1831,9
{
FC_StatusFlags &= ~(FC_STATUS_VARIO_TRIM_UP|FC_STATUS_VARIO_TRIM_DOWN);
HeightTrimming = 0;
if(!WaypointTrimming) SetPointHeight = ReadingHeight; // update setpoint to current height
if(!WaypointTrimming) LIMIT_MIN_MAX( SetPointHeight, (ReadingHeight - 128), (ReadingHeight + 128)) // limit setpoint to current height +/- 1m
else WaypointTrimming = 0;
if(ParamSet.Config2 & CFG2_VARIO_BEEP) BeepTime = 500;
if(FCParam.Config2 & CFG2_VARIO_BEEP) BeepTime = 500;
if((HoverGasState == HOVER_GAS_STATE_NONE) && (ReadingHeight > 50) )
{
HoverGasState = HOVER_GAS_STATE_START; // initiate long term filter
1797,7 → 1841,8
}
}
// trim height set point if needed
if(abs(HeightTrimming) > 512)
HeightTrimming += AltitudeSetpointTrimming;
if(abs(HeightTrimming) > 500)
{
if(WaypointTrimming)
{
1806,11 → 1851,12
}
else
{
SetPointHeight += (HeightTrimming * ParamSet.Height_Gain)/((5 * 512) / 2); // move setpoint
if(HeightTrimming > 0) SetPointHeight += ParamSet.Height_Gain / 3;
else SetPointHeight -= ParamSet.Height_Gain / 3;
}
HeightTrimming = 0;
LIMIT_MIN_MAX(SetPointHeight, (ReadingHeight - 1024), (ReadingHeight + 1024)); // max. 10m deviation
if(ParamSet.Config2 & CFG2_VARIO_BEEP) BeepTime = 100;
if(FCParam.Config2 & CFG2_VARIO_BEEP) BeepTime = 100;
//update hover gas stick value when setpoint is shifted
if(!ParamSet.Height_StickNeutralPoint && (NCAltitudeSpeed == 0))
{
1833,7 → 1879,7
} //EOF alternative height control
if((ReadingHeight > SetPointHeight) || !(ParamSet.Config2 & CFG2_HEIGHT_LIMIT) )
if((ReadingHeight > SetPointHeight) || !(FCParam.Config2 & CFG2_HEIGHT_LIMIT) )
{
int16_t GasReduction = 0;
// from this point the Heigth Control Algorithm is identical for both versions
1858,7 → 1904,7
LIMIT_MIN_MAX(tmp_int1,-64 * STICK_GAIN, 64 * STICK_GAIN);
// reduce d-part when setvalue is changing
if((FC_StatusFlags & (FC_STATUS_VARIO_TRIM_UP|FC_STATUS_VARIO_TRIM_DOWN)) || (abs(HeightDeviation) > 200) ) tmp_int1 /= 4;
else if(ParamSet.Config2 & CFG2_HEIGHT_LIMIT) tmp_int1 /= 8; // reduce d-part in "Deckel" mode
else if(FCParam.Config2 & CFG2_HEIGHT_LIMIT) tmp_int1 /= 8; // reduce d-part in "Deckel" mode
GasReduction += tmp_int1;
} // EOF no baro range expanding
1878,7 → 1924,7
HCGas -= GasReduction; // apply gas reduction
// limit control output around the hover point
if( (!HeightTrimming) && (HoverGas > 0) ) // height setpoint is not changed and hover gas not zero
if( (!AltitudeSetpointTrimming) && (HoverGas > 0) ) // height setpoint is not changed and hover gas not zero
{
#define DEVIATION_THRESHOLD 60
int16_t tmp;
1916,7 → 1962,7
// limit height control gas pd-control output
LIMIT_MIN_MAX(FilterHCGas, ParamSet.HeightMinGas * STICK_GAIN, (ParamSet.GasMax - 20) * STICK_GAIN);
// set GasMixFraction to HeightControlGasFilter
if(ParamSet.Config2 & CFG2_HEIGHT_LIMIT)
if(FCParam.Config2 & CFG2_HEIGHT_LIMIT)
{ // limit gas to stick position when limiting height control version active
LIMIT_MAX(FilterHCGas, GasMixFraction);
GasMixFraction = FilterHCGas;
1925,7 → 1971,7
{
GasMixFraction = FilterHCGas + (GasMixFraction - HoverGas) / 4;
}
} // EOF if((ReadingHeight > SetPointHeight) || !(ParamSet.Config2 & CFG2_HEIGHT_LIMIT))
} // EOF if((ReadingHeight > SetPointHeight) || !(FCParam.Config2 & CFG2_HEIGHT_LIMIT))
}// EOF height control active
else // HC not active
{
1994,11 → 2040,11
HoverGasFilter = 0;
HoverGas = 0;
} // EOF not flying yet
}// EOF ParamSet.Config0 & CFG0_AIRPRESS_SENSOR
}// EOF FCParam.Config0 & CFG0_AIRPRESS_SENSOR
else
{ // set undefined state to indicate vario off
FC_StatusFlags |= (FC_STATUS_VARIO_TRIM_UP|FC_STATUS_VARIO_TRIM_DOWN);
} // EOF not (ParamSet.Config0 & CFG0_AIRPRESS_SENSOR)
} // EOF not (FCParam.Config0 & CFG0_AIRPRESS_SENSOR)
// limit gas to parameter setting
LIMIT_MIN_MAX(GasMixFraction, (int16_t)(ParamSet.GasMin + 10) * STICK_GAIN, (int16_t)(ParamSet.GasMax - 20) * STICK_GAIN);
2006,7 → 2052,7
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// all BL-Ctrl connected?
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
if(MissingMotor || Capacity.MinOfMaxPWM != 255)
if(MissingMotor || Capacity.MinOfMaxPWM != 255) // wait until all BL-Ctrls are started
{
// if we are in the lift off condition
if( (ModelIsFlying > 1) && (ModelIsFlying < 50) && (GasMixFraction > 0) )
2104,9 → 2150,25
else tmp += ((int32_t)YawMixFraction * Mixer.Motor[i][MIX_YAW] ) / 64L;
// Smoothing
if(tmp > MotorValue[i]) tmp = (MotorValue[i] + tmp) / 2;
else tmp = 2 * tmp - MotorValue[i];
//if(tmp > MotorValue[i]) tmp = (MotorValue[i] + tmp) / 2;
//else tmp = 2 * tmp - MotorValue[i];
if(tmp > MotorValue[i]) tmp = (MotorValue[i] + tmp) / 2; // increasing motor value
else // decresing motor value
{
if(ParamSet.MotorSmooth == 0)
{
tmp = 2 * tmp - MotorValue[i]; // original motor smoothing
}
else // 1 means tmp = tmp;
if(ParamSet.MotorSmooth > 1)
{
// If >= 2 then allow >= 50% of the intended step down to rapidly reach the intended value.
tmp = tmp + ((MotorValue[i] - tmp)/ParamSet.MotorSmooth);
}
}
LIMIT_MIN_MAX(tmp, 4 * (int16_t)ParamSet.GasMin, 4 * (int16_t)ParamSet.GasMax);
Motor[i].SetPoint = tmp / 4;
Motor[i].SetPointLowerBits = (tmp % 4)<<1; // remaining bits (3 bits total)

/beta/Code Redesign killagreg/fc.h
27,12 → 27,12
// shift for zero centered rc channel data to Poty and thrust values
#define RC_POTI_OFFSET 127
#define RC_GAS_OFFSET 120
#define RC_GAS_OFFSET 127
typedef struct
{
uint8_t HeightD;
uint8_t MaxHeight;
uint8_t HeightSwitch;
uint8_t HeightP;
uint8_t Height_ACC_Effect;
uint8_t Height_GPS_Z;
68,6 → 68,9
int8_t KalmanK;
int8_t KalmanMaxDrift;
int8_t KalmanMaxFusion;
uint8_t Config0;
uint8_t Config2;
uint8_t MaxAltitude;
} fc_param_t;
extern fc_param_t FCParam;
90,15 → 93,18
// compass navigation
extern int16_t CompassHeading;
extern int16_t CompassCourse;
extern int16_t CompassOffCourse;
//extern int16_t CompassOffCourse;
extern uint8_t CompassCalState;
extern int8_t CalculateCompassTimer;
extern uint8_t CompassFusion;
extern int32_t YawGyroHeading;
extern int16_t YawGyroHeadingDeg;
extern uint8_t CareFree;
// height control
extern int32_t SetPointHeight;
extern int16_t AltitudeSetpointTrimming;
extern int8_t WaypointTrimming;
extern int16_t ControlHeading;
// accelerations
129,6 → 135,7
extern int16_t StickNick;
extern int16_t StickRoll;
extern int16_t StickYaw;
extern int16_t StickGas;
// current GPS-stick values
extern int16_t GPSStickNick;
extern int16_t GPSStickRoll;
159,6 → 166,7
// FC STATUS FLAGS2
#define FC_STATUS2_CAREFREE 0x01
#define FC_STATUS2_ALTITUDE_CONTROL 0x02
#define FC_STATUS2_RC_FAILSAVE_ACTIVE 0x04
#endif //_FC_H

/beta/Code Redesign killagreg/hottmenu.c
4,123 → 4,616
#include "analog.h"
#include "spi.h"
#include "fc.h"
#include "rc.h"
#include "eeprom.h"
#include "capacity.h"
#include "hottmenu.h"
#define HoTT_printfxy(x,y,format, args...) { LIBFC_HoTT_SetPos(y * 21 + x); _printf_P(&LIBFC_HoTT_Putchar, PSTR(format) , ## args);}
#define HoTT_printf(format, args...) { _printf_P(&LIBFC_HoTT_Putchar, PSTR(format) , ## args);}
#if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__))
#define HoTT_printfxy_INV(x,y,format, args...) { LIBFC_HoTT_SetPos(y * 21 + x); _printf_P(&LIBFC_HoTT_Putchar_INV, PSTR(format) , ## args);}
#define HoTT_printf_INV(format, args...) { _printf_P(&LIBFC_HoTT_Putchar_INV, PSTR(format) , ## args);}
#define HoTT_printf(format, args...) { _printf_P(&LIBFC_HoTT_Putchar, PSTR(format) , ## args);}
#define HoTT_printfxy(x,y,format, args...) { LIBFC_HoTT_SetPos(y * 21 + x); _printf_P(&LIBFC_HoTT_Putchar, PSTR(format) , ## args);}
#define HoTT_printfxy_INV(x,y,format, args...) { LIBFC_HoTT_SetPos(y * 21 + x); _printf_P(&LIBFC_HoTT_Putchar_INV, PSTR(format) , ## args);}
#define HoTT_printfxy_BLINK(x,y,format, args...) { LIBFC_HoTT_SetPos(y * 21 + x); _printf_P(&LIBFC_HoTT_Putchar_BLINK, PSTR(format) , ## args);}
#define HoTT_printf_BLINK(format, args...) { _printf_P(&LIBFC_HoTT_Putchar_BLINK, PSTR(format) , ## args);}
#define HoTT_printf_INV(format, args...) { _printf_P(&LIBFC_HoTT_Putchar_INV, PSTR(format) , ## args);}
#define VOICE_MINIMALE_EINGANSSPANNUNG 16
#define VOICE_BEEP 5
#define HoTT_GRAD 96
#define HoTT_LINKS 123
#define HoTT_RECHTS 124
#define HoTT_OBEN 125
#define HoTT_UNTEN 126
GPSPacket_t GPSPacket;
VarioPacket_t VarioPacket;
ASCIIPacket_t ASCIIPacket;
ElectricAirPacket_t ElectricAirPacket;
HoTTGeneral_t HoTTGeneral;
uint8_t MaxBlTempertaure = 0;
uint8_t MinBlTempertaure = 0;
uint8_t HottestBl = 0;
void GetHottestBl(void)
{
static uint8_t search = 0, tmp_max = 0, tmp_min = 0, who;
if(Motor[search].Temperature > tmp_max)
{
tmp_max = Motor[search].Temperature;
who = search;
}
else if(Motor[search].Temperature)
{
if(Motor[search].Temperature < tmp_min)
{
tmp_min = Motor[search].Temperature;
}
}
if(++search > MAX_MOTORS)
{
search = 0;
if(tmp_min != 255) MinBlTempertaure = tmp_min; else MinBlTempertaure = 0;
MaxBlTempertaure = tmp_max;
HottestBl = who;
tmp_min = 255;
tmp_max = 0;
who = 0;
}
}
void Hott_ClearLine(uint8_t line)
{
HoTT_printfxy(0,line," ");
}
void HoTTMenu_Update(void)
uint8_t HoTT_Waring(void)
{
static uint8_t what;
switch(what++)
if(FC_StatusFlags & FC_STATUS_LOWBAT) return(VOICE_MINIMALE_EINGANSSPANNUNG);
if((FC_StatusFlags & FC_STATUS_MOTOR_RUN) && NCErrorCode) return(VOICE_BEEP);
return(0);
}
void NC_Fills_HoTT_Telemety(void)
{
uint8_t *ptr = 0;
uint8_t max = 0, i, z;
switch(FromNaviCtrl.Param.Byte[11])
{
case 0:
HoTT_printfxy(0,0,"%2i.%1iV ",UBat/10, UBat%10);
HoTT_printfxy(8,0,"%4imAh %2i:%02i",Capacity.UsedCapacity,FlightSeconds/60,FlightSeconds%60);
case HOTT_VARIO_PACKET_ID:
ptr = (uint8_t *) &VarioPacket;
max = sizeof(VarioPacket);
break;
case 1:
HoTT_printfxy(0,1,"Dir:%3d%c",(int16_t)(YawGyroHeading / GYRO_DEG_FACTOR), 0x60);
if(ParamSet.Config0 & CFG0_AIRPRESS_SENSOR)
{
HoTT_printfxy_INV(10,1,"Alt:%4im %c", (int16_t)(ReadingHeight/100),VarioCharacter)
}
else
{
HoTT_printfxy(10,1,"Alt: ---- ");
}
break;
case 2:
HoTT_printfxy(0,2,"I=%3i.%1iA %4iW ",Capacity.ActualCurrent/10, Capacity.ActualCurrent%10,Capacity.ActualPower);
case HOTT_GPS_PACKET_ID:
ptr = (uint8_t *) &GPSPacket;
max = sizeof(GPSPacket);
break;
case 3:
if(NCDataOkay)
{
HoTT_printfxy(0,3,"Home:%3dm %3d%c", GPSInfo.HomeDistance/10, GPSInfo.HomeBearing, 0x60);
}
else
{
Hott_ClearLine(3);
}
case HOTT_ELECTRIC_AIR_PACKET_ID:
ptr = (uint8_t *) &ElectricAirPacket;
max = sizeof(ElectricAirPacket);
break;
case 4:
if(NCDataOkay)
{
HoTT_printfxy(0,4,"GPS:%2um/s Sat:%d ",GPSInfo.Speed, GPSInfo.NumOfSats);
switch (GPSInfo.SatFix)
case HOTT_GENERAL_PACKET_ID:
ptr = (uint8_t *) &HoTTGeneral;
max = sizeof(HoTTGeneral);
break;
default:
ptr = 0;
max = 0;
break;
}
if(ptr)
{
z = FromNaviCtrl.Param.Byte[0]; // Data allocation
for(i=0; i < FromNaviCtrl.Param.Byte[1]; i++)
{
if(z >= max) break;
ptr[z] = FromNaviCtrl.Param.Byte[2+i];
z++;
}
}
}
uint16_t BuildHoTT_Vario(void)
{
uint16_t tmp;
if(WaypointTrimming == 0)
{
tmp = 30000 + (AltitudeSetpointTrimming * ParamSet.Height_Gain) / 3;
if(tmp < 30000 && tmp > 30000 - 50) tmp = 30000 - 50; // weil es erst bei < 0,5m/sek piept
}
else
if(WaypointTrimming > 0) tmp = 30000 + NCAltitudeSpeed * 10;
else tmp = 30000 - NCAltitudeSpeed * 10;
return(tmp);
}
uint8_t HoTT_Telemety(uint8_t packet_request)
{
switch(packet_request)
{
case HOTT_VARIO_PACKET_ID:
VarioPacket.Altitude = ReadingHeight/100 + 500;
VarioPacket.m_sec = BuildHoTT_Vario();
VarioPacket.m_3sec = VarioPacket.m_sec;
VarioPacket.m_10sec = VarioPacket.m_sec;
if (VarioPacket.Altitude < VarioPacket.MinAltitude) VarioPacket.MinAltitude = VarioPacket.Altitude;
if (VarioPacket.Altitude > VarioPacket.MaxAltitude) VarioPacket.MaxAltitude = VarioPacket.Altitude;
VarioPacket.WarnBeep = HoTT_Waring();
HoTT_DataPointer = (uint8_t *) &VarioPacket;
return(sizeof(VarioPacket));
break;
case HOTT_GPS_PACKET_ID:
GPSPacket.Altitude = ReadingHeight/100 + 500;
//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.m_3sec = 120;
GPSPacket.m_10sec = 0;
GPSPacket.WarnBeep = HoTT_Waring();
HoTT_DataPointer = (uint8_t *) &GPSPacket;
return(sizeof(GPSPacket));
break;
case HOTT_ELECTRIC_AIR_PACKET_ID:
GetHottestBl();
ElectricAirPacket.Altitude = ReadingHeight/100 + 500;
ElectricAirPacket.Battery1 = UBat;
ElectricAirPacket.Battery2 = UBat;
ElectricAirPacket.VoltageCell1 = YawGyroHeadingDeg / 2;
ElectricAirPacket.VoltageCell8 = ElectricAirPacket.VoltageCell1;
ElectricAirPacket.VoltageCell7 = GPSInfo.HomeDistance/20;
ElectricAirPacket.VoltageCell14 = ElectricAirPacket.VoltageCell7;
ElectricAirPacket.m_sec = BuildHoTT_Vario();
ElectricAirPacket.m_3sec = 120;
ElectricAirPacket.InputVoltage = UBat;
ElectricAirPacket.Temperature1 = MinBlTempertaure + 20;
ElectricAirPacket.Temperature2 = MaxBlTempertaure + 20;
ElectricAirPacket.Capacity = Capacity.UsedCapacity/10;
ElectricAirPacket.WarnBeep = HoTT_Waring();
ElectricAirPacket.Current = Capacity.ActualCurrent;
HoTT_DataPointer = (uint8_t *) &ElectricAirPacket;
return(sizeof(ElectricAirPacket));
break;
case HOTT_GENERAL_PACKET_ID:
GetHottestBl();
HoTTGeneral.Rpm = GPSInfo.HomeDistance/100;
HoTTGeneral.VoltageCell1 = YawGyroHeadingDeg / 2;
HoTTGeneral.VoltageCell5 = GPSInfo.HomeDistance/20;
if(UBat > LowVoltageWarning + 5) HoTTGeneral.FuelPercent = (UBat - (LowVoltageWarning + 6)) * 3;
else HoTTGeneral.FuelPercent = 0;
HoTTGeneral.FuelCapacity = ReadingHeight/100; ;
HoTTGeneral.Altitude = ReadingHeight/100 + 500;
HoTTGeneral.Battery1 = UBat;
HoTTGeneral.Battery2 = UBat;
HoTTGeneral.m_sec = BuildHoTT_Vario();
HoTTGeneral.m_3sec = 120;
HoTTGeneral.InputVoltage = UBat;
HoTTGeneral.Temperature1 = MinBlTempertaure + 20;
HoTTGeneral.Temperature2 = MaxBlTempertaure + 20;
HoTTGeneral.Capacity = Capacity.UsedCapacity/10;
HoTTGeneral.WarnBeep = HoTT_Waring();
HoTTGeneral.Current = Capacity.ActualCurrent;
HoTT_DataPointer = (uint8_t *) &HoTTGeneral;
return(sizeof(HoTTGeneral));
break;
default: return(0);
}
}
void HoTT_Menu(void)
{
static uint8_t line = 0, page = 0;
if(page == 0)
{
switch(line++)
{
case 0:
if(FC_StatusFlags & FC_STATUS_LOWBAT)
{
case SATFIX_3D:
HoTT_printfxy(16,4," 3D ");
break;
HoTT_printfxy_BLINK(0,0," %2i.%1iV ",UBat/10, UBat%10);
}
else
{
HoTT_printfxy(0,0," %2i.%1iV ",UBat/10, UBat%10);
}
if(ParamSet.Config0 & CFG0_AIRPRESS_SENSOR)
{
if(FC_StatusFlags2 & FC_STATUS2_ALTITUDE_CONTROL)
{
HoTT_printfxy_INV(10,0,"ALT:%4im %c", (int16_t)(ReadingHeight/100), VarioCharacter);
}
else
{
HoTT_printfxy(10,0,"ALT:%4im ", (int16_t)(ReadingHeight/100));
}
}
else
{
HoTT_printfxy(10,0,"ALT:---- ");
}
break;
case SATFIX_2D:
case SATFIX_NONE:
default:
HoTT_printfxy(16,4,"NoFix");
break;
case 1:
if(FC_StatusFlags & FC_STATUS_LOWBAT)
{
HoTT_printfxy_BLINK(0,1," %2i:%02i ",FlightSeconds/60,FlightSeconds%60);
}
if(GPSInfo.Flags & FLAG_DIFFSOLN)
else
{
HoTT_printfxy(0,1," %2i:%02i ",FlightSeconds/60,FlightSeconds%60);
}
HoTT_printfxy(10,1,"DIR: %3d%c",YawGyroHeadingDeg, HoTT_GRAD);
if(FC_StatusFlags2 & FC_STATUS2_CAREFREE)
{
HoTT_printfxy(16,4,"DGPS ");
HoTT_printfxy(20,1,"C");
}
}
else
{ //012345678901234567890
HoTT_printfxy(0,4,"No NaviCtrl! ");
}
break;
case 5:
HoTT_printfxy(0,5,"%3i %3i %3i %3i%cC ", Motor[0].Temperature, Motor[1].Temperature, Motor[2].Temperature, Motor[3].Temperature,0x60);
break;
case 6:
if(RequiredMotors == 4) Hott_ClearLine(6);
else
if(RequiredMotors == 6) HoTT_printfxy(0,6,"%3i %3i%cC ", Motor[4].Temperature, Motor[5].Temperature,0x60)
{
HoTT_printfxy(20,1," ");
}
break;
case 2:
if(FC_StatusFlags & FC_STATUS_LOWBAT)
{
HoTT_printfxy_BLINK(0,2," %5i ",Capacity.UsedCapacity);
}
else
{
HoTT_printfxy(0,2," %5i ",Capacity.UsedCapacity);
}
HoTT_printfxy(12,2,"I:%2i.%1iA ",Capacity.ActualCurrent/10, Capacity.ActualCurrent%10);
break;
case 3:
HoTT_printfxy(9,0,"I");
HoTT_printfxy(9,1,"I");
HoTT_printfxy(9,2,"I");
HoTT_printfxy(0,3,"---------+-----------");
HoTT_printfxy(0,6,"---------------------");
break;
case 4:
if(NCDataOkay)
{
HoTT_printfxy(9,4,"I");
HoTT_printfxy(0,4,"SAT:%2d ",GPSInfo.NumOfSats);
HoTT_printfxy(10,4,"DIST:%3dm",GPSInfo.HomeDistance/10);
switch (GPSInfo.SatFix)
{
case SATFIX_3D:
if(GPSInfo.Flags & FLAG_DIFFSOLN) HoTT_printfxy(7,4,"D ")
else HoTT_printfxy(7,4,"3D");
break;
default:
HoTT_printfxy_BLINK(7,4,"!!");
break;
}
}
else
if(RequiredMotors > 6) HoTT_printfxy(0,6,"%3i %3i %3i %3i%cC ", Motor[4].Temperature, Motor[5].Temperature, Motor[6].Temperature, Motor[7].Temperature,0x6D);
{ //012345678901234567890
Hott_ClearLine(4);
}
break;
case 5:
if(NCDataOkay)
{
HoTT_printfxy(9,5,"I");
HoTT_printfxy(4,5,"%2um/s",GPSInfo.Speed);
HoTT_printfxy(12,5,"HM:%3d%c %c", GPSInfo.HomeBearing, HoTT_GRAD, NCGPSModeCharacter);
}
else Hott_ClearLine(5);
break;
case 6:
/*
if(RequiredMotors == 4) Hott_ClearLine(6);
else
if(RequiredMotors == 6) HoTT_printfxy(0,6,"%3i %3i%cC ", Motor[4].Temperature, Motor[5].Temperature, HoTT_GRAD)
else
if(RequiredMotors > 6) HoTT_printfxy(0,6,"%3i %3i %3i %3i%cC ", Motor[4].Temperature, Motor[5].Temperature, Motor[6].Temperature, Motor[7].Temperature, HoTT_GRAD);
*/
break;
case 7:
if(NCErrorCode)
{
if(HoTTBlink && NCErrorCode < MAX_ERR_NUMBER)
{
Hott_ClearLine(7);
HoTT_printfxy_INV(0,7,"ERR: %2d !",NCErrorCode);
}
else
{
HoTT_printfxy(0,7,"ERR: "); _printf_P(&LIBFC_HoTT_Putchar, NC_ERROR_TEXT[NCErrorCode], 0);
}
}
else HoTT_printfxy(0,7," www.MikroKopter.de ");
break;
case 8:
ASCIIPacket.WarnBeep = HoTT_Waring();
case 9:
case 10:
case 11:
case 12:
case 13:
case 14:
case 15:
case 16:
if(HottKeyboard == 8)
{
LIBFC_HoTT_Clear();
page = 1;
line = 0;
};
HottKeyboard = 0;
break;
default:
line = 0;
break;
} // EOF switch(line++)
} // EOF if(page == 0)
else if(page == 1)
{
switch(line++)
{
case 0:
if(FC_StatusFlags & FC_STATUS_LOWBAT)
{
HoTT_printfxy_BLINK(0,0," %2i:%02i %2i.%1iV %4imAh",FlightSeconds/60,FlightSeconds%60,UBat/10, UBat%10,Capacity.UsedCapacity);
}
else
{
HoTT_printfxy(0,0," %2i:%02i %2i.%1iV %4imAh",FlightSeconds/60,FlightSeconds%60,UBat/10, UBat%10,Capacity.UsedCapacity);
}
break;
case 1:
HoTT_printfxy(0,1,"DIR:%3d%c",CompassHeading, HoTT_GRAD);
if(ParamSet.Config0 & CFG0_AIRPRESS_SENSOR)
{
if(FC_StatusFlags2 & FC_STATUS2_ALTITUDE_CONTROL) HoTT_printfxy_INV(10,1,"ALT:%4im", (int16_t)(ReadingHeight/100))
else HoTT_printfxy(10,1,"ALT:%4im", (int16_t)(ReadingHeight/100))
}
else
{
HoTT_printfxy(10,1,"Alt: ---- ");
}
HoTT_printfxy(20,1,"%c",VarioCharacter);
break;
case 2:
if(NCDataOkay)
{
HoTT_printfxy(1,2,"HM:%3d%c DIST:%3dm %c", GPSInfo.HomeBearing, HoTT_GRAD, GPSInfo.HomeDistance/10, NCGPSModeCharacter);
}
else
{
Hott_ClearLine(2);
}
break;
case 7: if(NCErrorCode) HoTT_printfxy(0,7,"ERROR: %2d ",NCErrorCode)
else HoTT_printfxy(0,7," www.MikroKopter.de ");
break;
case 8:
case 9:
case 10:
case 11:
case 12:
case 13:
case 14:
case 15:
case 16:
break;
/*
012345678901234567890
+++++++++++++++++++++
13,8V 1234mAh 12:30 0
Dir:180° Alt: 123m + 1
GPS: 10Sat DGPS PH CF 2
Home: 280° 123m 3
I=23A P=123W Max=123 4
BL1-4: 11 22 33 44°C 5
BL5-8: 55 66 77 88°C 6
No Error 7
+++++++++++++++++++++
*/
default: what = 0;
break;
case 3:
HoTT_printfxy(0,3,"PWR:%2i.%1iA (%iW) ",Capacity.ActualCurrent/10, Capacity.ActualCurrent%10,Capacity.ActualPower);
break;
case 4:
if(NCDataOkay)
{
HoTT_printfxy(0,4,"GPS:%2um/s SAT:%d ",GPSInfo.Speed,GPSInfo.NumOfSats);
switch (GPSInfo.SatFix)
{
case SATFIX_3D:
HoTT_printfxy(16,4," 3D ");
break;
//case SATFIX_2D:
//case SATFIX_NONE:
default:
HoTT_printfxy_BLINK(16,4,"NOFIX");
break;
}
if(GPSInfo.Flags & FLAG_DIFFSOLN)
{
HoTT_printfxy(16,4,"DGPS ");
}
}
else
{ //012345678901234567890
HoTT_printfxy(0,4," No NaviCtrl ");
}
break;
case 5:
HoTT_printfxy(0,5,"%3i %3i %3i %3i%cC ", Motor[0].Temperature, Motor[1].Temperature, Motor[2].Temperature, Motor[3].Temperature, HoTT_GRAD);
if(FC_StatusFlags2 & FC_STATUS2_CAREFREE) HoTT_printfxy_INV(18,5,"CF") else HoTT_printfxy(18,5," ");
break;
case 6:
if(RequiredMotors == 4) Hott_ClearLine(6);
else
if(RequiredMotors == 6) HoTT_printfxy(0,6,"%3i %3i%cC ", Motor[4].Temperature, Motor[5].Temperature, HoTT_GRAD)
else
if(RequiredMotors > 6) HoTT_printfxy(0,6,"%3i %3i %3i %3i%cC ", Motor[4].Temperature, Motor[5].Temperature, Motor[6].Temperature, Motor[7].Temperature, HoTT_GRAD);
break;
case 7:
if(NCErrorCode)
{
if(HoTTBlink && NCErrorCode < MAX_ERR_NUMBER)
{
Hott_ClearLine(7);
HoTT_printfxy_INV(0,7,"ERR: %2d !",NCErrorCode);
}
else
{
HoTT_printfxy(0,7,"ERR: "); _printf_P(&LIBFC_HoTT_Putchar, NC_ERROR_TEXT[NCErrorCode], 0);
}
}
else HoTT_printfxy(0,7," www.MikroKopter.de ");
break;
case 8:
ASCIIPacket.WarnBeep = HoTT_Waring();
case 9:
case 10:
case 11:
case 12:
case 13:
case 14:
case 15:
case 16:
if(HottKeyboard == 8)
{
LIBFC_HoTT_Clear();
page = 2;
line = 0;
}
if(HottKeyboard == 1)
{
LIBFC_HoTT_Clear();
page = 0;
line = 0;
}
HottKeyboard = 0;
break;
default:
line = 0;
break;
} // EOF switch(line++)
} // EOF if(page == 1)
else if(page == 2)
{
switch(line++)
{
case 0:
HoTT_printfxy_INV(0,0,"Setting:%u %s ",GetActiveParamSet(), ParamSet.Name);
break;
case 1:
HoTT_printfxy(0,1,"Min:%2i.%1iV %s ",LowVoltageWarning/10, LowVoltageWarning%10, Mixer.Name);
break;
case 2:
HoTT_printfxy(0,2,"ALT:");
if(ParamSet.Config0 & CFG0_AIRPRESS_SENSOR)
{
if(!(ParamSet.Config0 & CFG0_HEIGHT_SWITCH))
{
HoTT_printf("POTI:%3u ", FCParam.HeightSwitch);
}
else
{
if(FCParam.HeightSwitch > 50) HoTT_printf("(ON) ")
else HoTT_printf("(OFF) ");
if((ParamSet.Config2 & CFG2_HEIGHT_LIMIT)) HoTT_printf("LIMIT", FCParam.HeightSwitch)
else HoTT_printf("VARIO");
}
}
else
{
HoTT_printf("DISABLED");
}
break;
case 3:
HoTT_printfxy(0,3,"CF:");
if(!ParamSet.CareFreeModeControl) HoTT_printf("DISABLED")
else
{
if(CareFree) HoTT_printf(" (ON) ")
else HoTT_printf(" (OFF)");
if(ParamSet.Config2 & CFG2_LEARNABLE_CAREFREE) HoTT_printf(" TEACH");
}
break;
case 4:
HoTT_printfxy(0,4,"GPS:");
if(!(ParamSet.Config0 & CFG0_GPS_ACTIVE))
{
HoTT_printf("DISABLED");
}
else
{
HoTT_printf("(%c)", NCGPSModeCharacter);
}
if(ParamSet.FailSafeTime) HoTT_printfxy(10,4," FS:%usek ",ParamSet.FailSafeTime);
break;
case 5:
HoTT_printfxy(0,5,"HOME ALT:");
if(ParamSet.ComingHomeAltitude) HoTT_printf("%um",ParamSet.ComingHomeAltitude)
else HoTT_printf("HOLD ");
break;
case 6:
HoTT_printfxy(0,6,"Ni:%4i Ro:%4i C:%3i",PPM_in[ParamSet.ChannelAssignment[CH_NICK]], PPM_in[ParamSet.ChannelAssignment[CH_ROLL]], FCParam.ServoNickControl);
HoTT_printfxy(0,7,"Gs:%4i Ya:%4i ",PPM_in[ParamSet.ChannelAssignment[CH_GAS]] + RC_GAS_OFFSET, PPM_in[ParamSet.ChannelAssignment[CH_YAW]]);
break;
case 7: //HoTT_printfxy(0,6,"WARNINGS:");
if(HoTTBlink)
{
LIBFC_HoTT_SetPos(6 * 21);
if(!(ParamSet.Config0 & CFG0_AXIS_COUPLING_ACTIVE)) HoTT_printf_BLINK("COUPLING OFF! ");
if(ParamSet.Config1 & (CFG1_LOOP_LEFT | CFG1_LOOP_RIGHT | CFG1_LOOP_DOWN | CFG1_LOOP_UP)) HoTT_printf_BLINK("LOOPING! ");
if(ParamSet.Config0 & CFG0_HEADING_HOLD) HoTT_printf_BLINK("HH! ");
if(!(ParamSet.Config0 & CFG0_COMPASS_ACTIVE)) HoTT_printf_BLINK("COMPASS OFF! ");
}
break;
case 8:
ASCIIPacket.WarnBeep = HoTT_Waring();
break;
case 9:
case 10:
case 11:
case 12:
case 13:
case 14:
case 15:
case 16:
if(HottKeyboard == 1)
{
LIBFC_HoTT_Clear();
page = 1;
line = 0;
}
HottKeyboard = 0;
break;
default:
line = 0;
break;
}
}
else page = 0;
}
#endif

/beta/Code Redesign killagreg/hottmenu.h
1,99 → 1,142
#ifndef _HOTTMENU_H
#define _HOTTMENU_H
extern void HoTTMenu_Update(void);
#if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__))
extern uint8_t HottKeyboard;
extern volatile uint8_t HoTTBlink;
extern volatile uint8_t *HoTT_DataPointer;
extern void HoTT_Menu(void);
extern uint8_t HoTT_Telemety(uint8_t);
extern uint8_t HoTT_Waring(void);
typedef struct
{
uint8_t StartByte; // 0x7C
uint8_t Packet_ID; // HOTT_ELECTRIC_AIR_PACKET_ID
uint8_t WarnBeep; // Anzahl der Töne 0..36
uint8_t VoltageCell1; // 208 = 4,16V (Voltage * 50 = Wert)
uint8_t VoltageCell2; // 209 = 4,18V
uint8_t VoltageCell3; //
uint8_t VoltageCell4; //
uint8_t VoltageCell5; //
uint8_t VoltageCell6; //
uint8_t VoltageCell7; //
uint8_t VoltageCell8; //
uint8_t VoltageCell9; //
uint8_t VoltageCell10; //
uint8_t VoltageCell11; //
uint8_t VoltageCell12; //
uint8_t VoltageCell13; //
uint8_t VoltageCell14; //
uint16_t Battery1; // 51 = 5,1V
uint16_t Battery2; // 51 = 5,1V
uint8_t Temperature1; // 44 = 24°C, 0 = -20°C
uint8_t Temperature2; // 44 = 24°C, 0 = -20°C
uint16_t Altitude;
uint16_t Current; // 1 = 0.1A
uint16_t InputVoltage; // 66 = 6,6V
uint16_t Capacity; // 1 = 10mAh
uint16_t m_sec; // 3000 = 0
uint16_t m_3sec; // 3000 = 0
uint8_t NullByte1; // 0x00
uint8_t NullByte2; // 0x00
uint8_t EndByte; // 0x7D
uint8_t StartByte; // 0x7C
uint8_t Packet_ID; // HOTT_GENERAL_PACKET_ID
uint8_t WarnBeep; // Anzahl der Töne 0..36
uint8_t VoltageCell1; // 208 = 4,16V (Voltage * 50 = Wert)
uint8_t VoltageCell2; // 209 = 4,18V
uint8_t VoltageCell3; //
uint8_t VoltageCell4; //
uint8_t VoltageCell5; //
uint8_t VoltageCell6; //
uint16_t Battery1; // 51 = 5,1V
uint16_t Battery2; // 51 = 5,1V
uint8_t Temperature1; // 44 = 24°C, 0 = -20°C
uint8_t Temperature2; // 44 = 24°C, 0 = -20°C
uint8_t FuelPercent;
uint16_t FuelCapacity;
uint16_t Rpm;
uint16_t Altitude;
uint16_t m_sec; // 30000 = 0
uint8_t m_3sec; // 120 = 0
uint16_t Current; // 1 = 0.1A
uint16_t InputVoltage; // 66 = 6,6V
uint16_t Capacity; // 1 = 10mAh
uint8_t NullByte1; // 0x00
uint8_t NullByte2; // 0x00
uint8_t EndByte; // 0x7D
} HoTTGeneral_t;
typedef struct
{
uint8_t StartByte; // 0x7C
uint8_t Packet_ID; // HOTT_ELECTRIC_AIR_PACKET_ID
uint8_t WarnBeep; // Anzahl der Töne 0..36
uint8_t VoltageCell1; // 208 = 4,16V (Voltage * 50 = Wert)
uint8_t VoltageCell2; // 209 = 4,18V
uint8_t VoltageCell3; //
uint8_t VoltageCell4; //
uint8_t VoltageCell5; //
uint8_t VoltageCell6; //
uint8_t VoltageCell7; //
uint8_t VoltageCell8; //
uint8_t VoltageCell9; //
uint8_t VoltageCell10; //
uint8_t VoltageCell11; //
uint8_t VoltageCell12; //
uint8_t VoltageCell13; //
uint8_t VoltageCell14; //
uint16_t Battery1; // 51 = 5,1V
uint16_t Battery2; // 51 = 5,1V
uint8_t Temperature1; // 44 = 24°C, 0 = -20°C
uint8_t Temperature2; // 44 = 24°C, 0 = -20°C
uint16_t Altitude; // 500 = 0m
uint16_t Current; // 1 = 0.1A
uint16_t InputVoltage; // 66 = 6,6V
uint16_t Capacity; // 1 = 10mAh
uint16_t m_sec; // 30000 = 0
uint16_t m_3sec; // 120 = 0
uint8_t NullByte1; // 0x00
uint8_t NullByte2; // 0x00
uint8_t EndByte; // 0x7D
} ElectricAirPacket_t;
typedef struct
{
uint8_t StartByte; // 0x7C
uint8_t Packet_ID; // 0x89 - Vario ID
uint8_t WarnBeep; // Anzahl der Töne 0..36
uint16_t Altitude; // 500 = 0m
uint16_t MaxAltitude; // 500 = 0m
uint16_t MinAltitude; // 500 = 0m
uint16_t m_sec; // 3000 = 0
uint16_t m_3sec; // 3000 = 0
uint16_t m_10sec; // 3000 = 0
uint8_t NullByte; // 0x00
uint8_t EndByte; // 0x7D
uint8_t StartByte; // 0x7C
uint8_t Packet_ID; // HOTT_VARIO_PACKET_ID
uint8_t WarnBeep; // Anzahl der Töne 0..36
uint16_t Altitude; // 500 = 0m
uint16_t MaxAltitude; // 500 = 0m
uint16_t MinAltitude; // 500 = 0m
uint16_t m_sec; // 30000 = 0
uint16_t m_3sec; // 120 = 0
uint16_t m_10sec; //
uint8_t NullByte; // 0x00
uint8_t EndByte; // 0x7D
} VarioPacket_t;
typedef struct
{
uint8_t StartByte; // 0x7C
uint8_t Packet_ID; // 0x89 - Vario ID
uint8_t WarnBeep; // Anzahl der Töne 0..36
uint8_t Heading; // 1 = 2°
uint16_t Speed; // in km/h
uint8_t Lat_G;
uint8_t Lat_M;
uint8_t Lat_Sek1;
uint8_t Lat_Sek2;
uint8_t Lon_G;
uint8_t Lon_M;
uint8_t Lon_Sek1;
uint8_t Lon_Sek2;
uint16_t Distance; // 9000 = 0m
uint16_t Hoehe; // 500 = 0m
uint16_t Altitude; // 500 = 0m
uint16_t m_sec; // 3000 = 0
uint16_t m_3sec; // 3000 = 0
uint16_t m_10sec; // 3000 = 0
uint8_t NullByte; // 0x00
uint8_t NullByte1; // 0x00
uint8_t EndByte; // 0x7D
uint8_t StartByte; // 0 // 0x7C
uint8_t Packet_ID; // 1 // HOTT_GPS_PACKET_ID
uint8_t WarnBeep; // 2 // Anzahl der Töne 0..36
uint8_t Heading; // 3 // 1 = 2°
uint16_t Speed; // 4+5 // in km/h
uint8_t Lat_North; // 6
uint8_t Lat_G; // 7
uint8_t Lat_M; // 8
uint8_t Lat_Sek1; // 9
uint8_t Lat_Sek2; // 10
uint8_t Lon_East; // 11
uint8_t Lon_G; // 12
uint8_t Lon_M; // 13
uint8_t Lon_Sek1; // 14
uint8_t Lon_Sek2; // 15
uint16_t Distance; // 16+17 // 9000 = 0m
uint16_t Altitude; // 18+19 // 500 = 0m
uint16_t m_sec; // 20+21 // 30000 = 0
uint16_t m_3sec; // 22+23 // 120 = 0
uint16_t m_10sec; // 24+25 //
uint8_t NullByte; // 0x00
uint8_t NullByte1; // 0x00
uint8_t EndByte; // 0x7D
} GPSPacket_t;
typedef struct
{
uint8_t StartByte; // 0x7B
uint8_t Packet_ID; // 0x00
uint8_t WarnBeep; // Anzahl der Töne 0..36
uint8_t Text[8*21];
uint8_t EndByte; // 0x7D
uint8_t StartByte; // 0x7B
uint8_t Packet_ID; //
uint8_t WarnBeep; // Anzahl der Töne 0..36
int8_t Text[8*21];
uint8_t EndByte; // 0x7D
} ASCIIPacket_t;
#define HOTT_VARIO_PACKET_ID 0x89
#define HOTT_GPS_PACKET_ID 0x8A
#define HOTT_ELECTRIC_AIR_PACKET_ID 0x8E
#define HOTT_GENERAL_PACKET_ID 0x8D
extern GPSPacket_t GPSPacket;
extern VarioPacket_t VarioPacket;
extern ASCIIPacket_t ASCIIPacket;
extern ElectricAirPacket_t ElectricAirPacket;
extern HoTTGeneral_t HoTTGeneral;
#define HOTT_VARIO_PACKET_ID 0x89
#define HOTT_GPS_PACKET_ID 0x8A
#define HOTT_ELECTRIC_AIR_PACKET_ID 0x8E
#endif
#endif

/beta/Code Redesign killagreg/jetimenu.c
7,6 → 7,7
#include "eeprom.h"
#include "main.h"
#include "capacity.h"
#include "timer0.h"
#ifdef USE_NAVICTRL
#include "spi.h"
#endif
31,22 → 32,44
JetiBox_printfxy(0,0,"%2i.%1iV",UBat/10, UBat%10);
if(NCDataOkay)
{
JetiBox_printfxy(6,0,"%3d%c %03dm",(int16_t)(YawGyroHeading / GYRO_DEG_FACTOR), 0xDF, GPSInfo.HomeDistance/10);
//JetiBox_printfxy(6,0,"%03dm %03d%c", GPSInfo.HomeDistance/10,GPSInfo.HomeBearing, 0xDF);
JetiBox_printfxy(6,0,"%3d%c %03dm%c",YawGyroHeadingDeg, 0xDF, GPSInfo.HomeDistance/10, NCGPSModeCharacter);
}
else
{
if(NCErrorCode)
JetiBox_printfxy(6,0,"Status")
}
if(NCErrorCode)
{
#if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__))
{
JetiBox_printfxy(6,0,"ERROR: %2d", NCErrorCode);
static uint16_t timer = 0;
static uint8_t toggle = 1;
// toggle each 1.5 seconds errot number and text
if(CheckDelay(timer))
{
if(toggle) toggle = 0;
else toggle = 1;
timer = SetDelay(1500);
}
if(toggle)
{
LIBFC_JetiBox_SetPos(0);
_printf_P(&LIBFC_JetiBox_Putchar, NC_ERROR_TEXT[NCErrorCode], 0);
}
else
{
JetiBox_printfxy(6,0,"ERROR: %2d ",NCErrorCode);
if(FC_StatusFlags & FC_STATUS_MOTOR_RUN) JetiBeep = 'O';
}
}
else
{
JetiBox_printfxy(6,0,"Status")
};
#else
JetiBox_printfxy(6,0,"ERROR: %2d ", NCErrorCode);
#endif
}
JetiBox_printfxy(0,1,"%4i %2i:%02i",Capacity.UsedCapacity,FlightSeconds/60,FlightSeconds%60);
if(ParamSet.Config0 & CFG0_AIRPRESS_SENSOR)
if(FCParam.Config0 & CFG0_AIRPRESS_SENSOR)
{
JetiBox_printfxy(10,1,"%4im%c", (int16_t)(ReadingHeight/100),VarioCharacter);
}
84,7 → 107,6
if(NCDataOkay)
{
JetiBox_printfxy(0,0,"%2um/s Sat:%2u",GPSInfo.Speed,GPSInfo.NumOfSats)
//JetiBox_printfxy(0,0,"Sat:%02d", GPSInfo.NumOfSats);
switch (GPSInfo.SatFix)
{
case SATFIX_3D:
102,7 → 124,7
{
JetiBox_printfxy(12,0,"DGPS");
}
JetiBox_printfxy(0,1,"Home:%3dm %3d%c", GPSInfo.HomeDistance/10, GPSInfo.HomeBearing, 0xDF); // 0xDF = °
JetiBox_printfxy(0,1,"Home:%3dm %3d%c %c", GPSInfo.HomeDistance/10, GPSInfo.HomeBearing, 0xDF, NCGPSModeCharacter); // 0xDF = °
}
else
{ //0123456789ABCDEF

/beta/Code Redesign killagreg/led.c
79,9 → 79,9
if(!delay--) // 10 ms intervall
if(!delay--) // 20 ms intervall
{
delay = 4;
delay = 9;
if( (FC_StatusFlags & (FC_STATUS_LOWBAT|FC_STATUS_EMERGENCY_LANDING)) || (UART_VersionInfo.HardwareError[1] & FC_ERROR1_I2C) )
{
if(ParamSet.J16Bitmask_Warning)
106,7 → 106,7
if(!J16Warn)
{
if( (ParamSet.Config1 & CFG1_MOTOR_BLINK) && !(FC_StatusFlags & FC_STATUS_MOTOR_RUN))
if( (ParamSet.Config1 & CFG1_MOTOR_BLINK1) && !(FC_StatusFlags & FC_STATUS_MOTOR_RUN))
{
if(ParamSet.Config1 & CFG1_MOTOR_OFF_LED1) J16_ON;
else J16_OFF;
116,7 → 116,7
if(J16Bitmask & 128) J16_ON;
else J16_OFF;
}
else if ((ParamSet.J16Timing > 247) && (FCParam.J16Timing < 10))
else if ((ParamSet.J16Timing > 247) && (FCParam.J16Timing == 5))
{
if(J16Bitmask & 128) J16_OFF;
else J16_ON;
123,7 → 123,7
}
else if(!J16Blinkcount--)
{
J16Blinkcount = FCParam.J16Timing - 1;
J16Blinkcount = FCParam.J16Timing / 2;
if(J16Mask == 1) J16Mask = 128; else J16Mask /= 2;
if(J16Mask & J16Bitmask) J16_ON; else J16_OFF;
}
137,7 → 137,7
if(!J17Warn)
{
if( (ParamSet.Config1 & CFG1_MOTOR_BLINK) && !(FC_StatusFlags & FC_STATUS_MOTOR_RUN))
if( (ParamSet.Config1 & CFG1_MOTOR_BLINK2) && !(FC_StatusFlags & FC_STATUS_MOTOR_RUN))
{
if(ParamSet.Config1 & CFG1_MOTOR_OFF_LED2) J17_ON;
else J17_OFF;
147,7 → 147,7
if(J17Bitmask & 128) J17_ON;
else J17_OFF;
}
else if ((ParamSet.J17Timing > 247) && (FCParam.J17Timing < 10))
else if ((ParamSet.J17Timing > 247) && (FCParam.J17Timing == 5))
{
if(J17Bitmask & 128) J17_OFF;
else J17_ON;
154,7 → 154,7
}
else if(!J17Blinkcount--)
{
J17Blinkcount = FCParam.J17Timing - 1;
J17Blinkcount = FCParam.J17Timing / 2;
if(J17Mask == 1) J17Mask = 128; else J17Mask /= 2;
if(J17Mask & J17Bitmask) J17_ON; else J17_OFF;
}

/beta/Code Redesign killagreg/libfc.h
17,8 → 17,11
extern void LIBFC_JetiBox_SetPos(uint8_t index);
extern void LIBFC_JetiBox_Clear(void);
extern void LIBFC_CheckSettings(void);
extern void LIBFC_HoTT_Putchar(char c);
extern void LIBFC_HoTT_Putchar_INV(char c); // print Invers
extern void LIBFC_HoTT_Putchar_BLINK(char c);
extern void LIBFC_HoTT_SetPos(uint8_t index);
extern void LIBFC_HoTT_Clear(void);

/beta/Code Redesign killagreg/libfc1284.a
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

/beta/Code Redesign killagreg/main.c
62,6 → 62,7
#include "uart0.h"
#include "led.h"
#include "menu.h"
#include "hottmenu.h"
#include "fc.h"
#include "rc.h"
#include "analog.h"
156,6 → 157,7
{
uint16_t timer, pollingtimer;
uint8_t i, FoundMotors = 0;
uint8_t DisableRcOffBeeping = 0;
// disable interrupts global
cli();
300,19 → 302,16
DebugOut.Status[0] = 0x01 | 0x02;
JetiBeep = 0;
if(ParamSet.Config2 & CFG2_NO_RCOFF_BEEPING) DisableRcOffBeeping = 1;
// begin of main loop
while (1)
{
if(JetiUpdateModeActive) while (1);
if(ReceiverUpdateModeActive) while (1);
if(CheckDelay(pollingtimer))
{
pollingtimer = SetDelay(1);
LIBFC_Polling();
}
//GRN_ON;
if(UpdateMotor && ADReady) // control interval
{
//GRN_OFF;
UpdateMotor = 0; // reset Flag, is enabled every 2 ms by ISR of timer0
//J4HIGH;
325,7 → 324,7
if(RC_Quality)
{
RC_Quality--;
UART_VersionInfo.HardwareError[1] &= ~FC_ERROR1_PPM;
//UART_VersionInfo.HardwareError[1] &= ~FC_ERROR1_PPM;
}
else
{
347,7 → 346,7
}
if((BeepModulation == 0xFFFF) && (FC_StatusFlags & FC_STATUS_MOTOR_RUN) )
{
BeepTime = 10000; // 1 second
BeepTime = 25000; // 2.5 seconds
BeepModulation = 0x0080;
}
}
354,9 → 353,11
else
{
RED_OFF;
if(!BeepTime) UART_VersionInfo.HardwareError[1] &= ~FC_ERROR1_I2C;
// if(!BeepTime) UART_VersionInfo.HardwareError[1] &= ~FC_ERROR1_I2C;
}
LIBFC_Polling();
// allow Serial Data Transmit if motors must not updated at this time
if( !UpdateMotor )
{
370,7 → 371,9
static uint16_t counter_minute = 0;
timer += 20; // every 20 ms
#if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__))
if(ParamSet.Receiver == RECEIVER_HOTT) HoTT_Menu();
#endif
if(MissingMotor)
{
UART_VersionInfo.HardwareError[1] |= FC_ERROR1_BL_MISSING;
378,12 → 381,22
}
else
{
UART_VersionInfo.HardwareError[1] &= ~FC_ERROR1_BL_MISSING;
if(I2CTimeout > 6) DebugOut.Status[1] &= ~0x02; // BL-Error-Status
if(!BeepTime)
{
//UART_VersionInfo.HardwareError[1] &= ~FC_ERROR1_BL_MISSING;
if(I2CTimeout > 6) DebugOut.Status[1] &= ~0x02; // BL-Error-Status
}
}
if(I2CTimeout > 6) UART_VersionInfo.HardwareError[1] &= ~FC_ERROR1_I2C;
//if(I2CTimeout > 6) if(!BeepTime) UART_VersionInfo.HardwareError[1] &= ~FC_ERROR1_I2C;
// if RC signal is ok and RCOff beeping is disabled
if(RC_Quality && DisableRcOffBeeping)
{ // enable RCOff beeping again
DisableRcOffBeeping = 0;
BeepTime = 5000;
}
if(PcAccess) PcAccess--;
else
{
391,10 → 404,14
ExternStickNick= 0;
ExternStickRoll = 0;
ExternStickYaw = 0;
if((BeepModulation == 0xFFFF) && (RC_Quality == 0))
if(!RC_Quality)
{
BeepTime = 15000; // 1.5 seconds
BeepModulation = 0x0C00;
if( (BeepModulation == 0xFFFF) && (DisableRcOffBeeping != 2) ) // do not beep when feature is disabled
{
BeepTime = 15000; // 1.5 seconds
BeepModulation = 0x0C00;
if(DisableRcOffBeeping) DisableRcOffBeeping = 2;
}
}
}
#ifdef USE_NAVICTRL
402,6 → 419,7
{
NCDataOkay--;
UART_VersionInfo.HardwareError[1] &= ~FC_ERROR1_SPI_RX;
NCErrorCode = 9; // "ERR: no NC communication"
}
else // no data from NC
{
417,6 → 435,10
// set gps control sticks neutral
GPSStickNick = 0;
GPSStickNick = 0;
NCGPSAidMode = 0;
GPSInfo.Flags = 0;
FromNaviCtrl.AccErrorN = 0;
FromNaviCtrl.AccErrorR = 0;
FromNaviCtrl.CompassHeading = -1;
NCDataOkay = 0;
}
465,6 → 487,7
LED_Update();
Capacity_Update();
} // EOF !UpdateMotor
//else DebugOut.Analog[26]++;
} // EOF Update Motor && ADReady
#ifdef USE_NAVICTRL

/beta/Code Redesign killagreg/main.h
3,7 → 3,9
#include <avr/io.h>
//#define ACT_S3D_SUMMENSIGNAL
//#define ACT_S3D_SUMSIGNAL
//#define RECEIVER_SPEKTRUM_DX7EXP
//#define RECEIVER_SPEKTRUM_DX8EXP
// neue Hardware
#define RED_OFF {if((BoardRelease == 10)||(BoardRelease >= 20)) PORTB &=~(1<<PORTB0); else PORTB |= (1<<PORTB0);}

/beta/Code Redesign killagreg/makefile
6,11 → 6,11
#-------------------------------------------------------------------
VERSION_MAJOR = 0
VERSION_MINOR = 85
VERSION_PATCH = 0
VERSION_PATCH = 18
VERSION_SERIAL_MAJOR = 11 # Serial Protocol Major Version
VERSION_SERIAL_MINOR = 0 # Serial Protocol Minor Version
NC_SPI_COMPATIBLE = 20 # SPI Protocol Version
NC_SPI_COMPATIBLE = 23 # SPI Protocol Version
#-------------------------------------------------------------------
#OPTIONS

/beta/Code Redesign killagreg/menu.c
56,6 → 56,7
#include "timer2.h"
#include "fc.h"
#include "rc.h"
#include "spi.h"
#include "uart0.h"
#include "printf_P.h"
#include "analog.h"
63,7 → 64,7
#include "capacity.h"
#include "menu.h"
uint8_t MaxMenuItem = 17;
uint8_t MaxMenuItem = 16;
uint8_t MenuItem = 0;
113,6 → 114,20
LCD_printfxy(0,0,"++ Flight-Ctrl ++");
LCD_printfxy(0,1,"HW:V%d.%d SW:%d.%d%c",BoardRelease/10,BoardRelease%10,VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH+'a');
LCD_printfxy(0,2,"Setting: %d %s", GetActiveParamSet(), Mixer.Name);
if(NCErrorCode)
{
#if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__))
LCD_printfxy(0,3,"ERR%2d:",NCErrorCode);
_printf_P(&Menu_Putchar, NC_ERROR_TEXT[NCErrorCode] , 0);
#else
LCD_printfxy(0,3,"! NC-ERR: %2d ! ",NCErrorCode);
#endif
}
else
if(UART_VersionInfo.HardwareError[0]) LCD_printfxy(0,3,"Hardware Error 1:%d !!",UART_VersionInfo.HardwareError[0])
else
if (MissingMotor)
127,7 → 142,7
if(I2CTimeout < 6) LCD_printfxy(0,3,"I2C ERROR!!!")
break;
case 1:// Height Control Menu Item
if(ParamSet.Config0 & CFG0_AIRPRESS_SENSOR)
if(FCParam.Config0 & CFG0_AIRPRESS_SENSOR)
{
LCD_printfxy(0,0,"Height: %5i",(int16_t)(ReadingHeight/5));
LCD_printfxy(0,1,"Setpoint: %5i",(int16_t)(SetPointHeight/5));
144,13 → 159,14
LCD_printfxy(0,0,"Attitude");
LCD_printfxy(0,1,"Nick: %5i",IntegralGyroNick/1024);
LCD_printfxy(0,2,"Roll: %5i",IntegralGyroRoll/1024);
LCD_printfxy(0,3,"Hdg: %5i",CompassHeading);
LCD_printfxy(0,3,"Hdg: %5i",YawGyroHeadingDeg);
break;
case 3:// Remote Control Channel Menu Item
LCD_printfxy(0,0,"C1:%4i C2:%4i",PPM_in[1],PPM_in[2]);
for(i=0;i<8;i+=2) LCD_printfxy(0,i/2,"C%i:%4i C%i:%4i ",i+1, PPM_in[i+1], i+2, PPM_in[i+2]);
/*LCD_printfxy(0,0,"C1:%4i C2:%4i",PPM_in[1],PPM_in[2]);
LCD_printfxy(0,1,"C3:%4i C4:%4i",PPM_in[3],PPM_in[4]);
LCD_printfxy(0,2,"C5:%4i C6:%4i",PPM_in[5],PPM_in[6]);
LCD_printfxy(0,3,"C7:%4i C8:%4i",PPM_in[7],PPM_in[8]);
LCD_printfxy(0,3,"C7:%4i C8:%4i",PPM_in[7],PPM_in[8]);*/
break;
case 4:// Remote Control Mapping Menu Item
LCD_printfxy(0,0,"Ni:%4i Ro:%4i",PPM_in[ParamSet.ChannelAssignment[CH_NICK]],PPM_in[ParamSet.ChannelAssignment[CH_ROLL]]);
208,21 → 224,27
break;
case 9:// Compass Menu Item
LCD_printfxy(0,0,"Compass");
LCD_printfxy(0,1,"Course: %5i",CompassCourse);
LCD_printfxy(0,2,"Heading: %5i",CompassHeading);
LCD_printfxy(0,3,"OffCourse: %5i",CompassOffCourse);
LCD_printfxy(0,1,"MagHead.: %5i",CompassHeading);
LCD_printfxy(0,2,"GyroHead.: %5i",YawGyroHeadingDeg);
LCD_printfxy(0,3,"Setpoint: %5i",CompassCourse);
break;
case 10:// Poti Menu Item
for(i=0;i<4;i++) LCD_printfxy(0,i,"Poti%i: %3i",i+1, Poti[i]);
/*
LCD_printfxy(0,0,"Poti1: %3i" ,Poti[0]);
LCD_printfxy(0,1,"Poti2: %3i" ,Poti[1]);
LCD_printfxy(0,2,"Poti3: %3i" ,Poti[2]);
LCD_printfxy(0,3,"Poti4: %3i" ,Poti[3]);
*/
break;
case 11:// Poti Menu Item
for(i=0;i<4;i++) LCD_printfxy(0,i,"Poti%i: %3i",i+5,Poti[i+4]);
/*
LCD_printfxy(0,0,"Poti5: %3i" ,Poti[4]);
LCD_printfxy(0,1,"Poti6: %3i" ,Poti[5]);
LCD_printfxy(0,2,"Poti7: %3i" ,Poti[6]);
LCD_printfxy(0,3,"Poti8: %3i" ,Poti[7]);
*/
break;
case 12:// Servo Menu Item
LCD_printfxy(0,0,"Servo" );
230,22 → 252,22
LCD_printfxy(0,2,"Position: %3i",ServoNickValue/4);
LCD_printfxy(0,3,"Range:%3i-%3i",ParamSet.ServoNickMin, ParamSet.ServoNickMax);
break;
case 13://Extern Control
LCD_printfxy(0,0,"ExternControl" );
LCD_printfxy(0,1,"Ni:%4i Ro:%4i",ExternControl.Nick, ExternControl.Roll);
LCD_printfxy(0,2,"Gs:%4i Ya:%4i",ExternControl.Gas, ExternControl.Yaw);
LCD_printfxy(0,3,"Hi:%4i Cf:%4i",ExternControl.Height, ExternControl.Config);
break;
case 14://BL Communication errors
case 13://BL Communication errors
LCD_printfxy(0,0,"BL-Ctrl Errors" );
for(i = 0; i < 3; i++)
{
j=i<<2;
LCD_printfxy(0,1+i," %3d %3d %3d %3d ",Motor[j].State & MOTOR_STATE_ERROR_MASK,Motor[1+j].State & MOTOR_STATE_ERROR_MASK,Motor[2+j].State & MOTOR_STATE_ERROR_MASK,Motor[3+j].State & MOTOR_STATE_ERROR_MASK);
LCD_printfxy(0,i+1," %3d %3d %3d %3d ",Motor[i*4].State & MOTOR_STATE_ERROR_MASK,Motor[i*4+1].State & MOTOR_STATE_ERROR_MASK,Motor[i*4+2].State & MOTOR_STATE_ERROR_MASK,Motor[i*4+3].State & MOTOR_STATE_ERROR_MASK);
//if(i*4 > RequiredMotors) break;
}
break;
case 14:// new BL infos
LCD_printfxy(0,0,"BL Temperature" );
for(i = 0; i < 3; i++)
{
LCD_printfxy(0,i+1,"%3i %3i %3i %3i ",Motor[i*4].Temperature, Motor[i*4+1].Temperature, Motor[i*4+2].Temperature, Motor[i*4+3].Temperature);
//if(4 + i*4 >= RequiredMotors) break;
}
break;
case 15://BL Overview
LCD_printfxy(0,0,"BL-Ctrl found" );
for(i = 0; i < 2; i++)
258,17 → 280,7
if(Motor[10].State>>7) LCD_printfxy(8,3,"11");
if(Motor[11].State>>7) LCD_printfxy(12,3,"12");
break;
case 16:// new BL infos
LCD_printfxy(0,0,"BL Temperature", Capacity.MinOfMaxPWM);
for(i = 0; i < 3; i++)
{
j=i<<2;
LCD_printfxy(0,i+1,"%3i %3i %3i %3i ",Motor[j].Temperature, Motor[j+1].Temperature, Motor[j+2].Temperature, Motor[j+3].Temperature);
}
break;
case 17:// flight time counter
case 16:// flight time counter
LCD_printfxy(0,0,"Flight-Time");
LCD_printfxy(0,1,"Total:%5u min",FlightMinutesTotal);
LCD_printfxy(0,2,"Trip: %5u min",FlightMinutes);
279,7 → 291,6
SetParamWord(PID_FLIGHT_MINUTES, FlightMinutes);
}
break;
default:
if(MenuItem == MaxMenuItem) MaxMenuItem--;
MenuItem = 0;

/beta/Code Redesign killagreg/menu.h
6,7 → 6,7
#define DISPLAYBUFFSIZE 80
#define LCD_printfxy(x,y,format, args...) { DispPtr = (y) * 20 + x; _printf_P(&Menu_Putchar, PSTR(format) , ## args);}
#define LCD_printfxy(x,y,format, args...) { DispPtr = (y) * 20 + (x); _printf_P(&Menu_Putchar, PSTR(format) , ## args);}
#define LCD_printf(format, args...) { _printf_P(&Menu_Putchar, PSTR(format) , ## args);}
#define KEY1 0x01

/beta/Code Redesign killagreg/mk3mag.c
112,7 → 112,7
{
if(PWMCount <10) CompassHeading = 0;
else CompassHeading = ((uint32_t)(PWMCount - 10) * 1049L)/1024; // correct timebase and offset
CompassOffCourse = ((540 + CompassHeading - CompassCourse) % 360) - 180;
//CompassOffCourse = ((540 + CompassHeading - CompassCourse) % 360) - 180;
PWMTimeout = 12; // if 12 periodes long no valid PWM was detected the data are invalid
// 12 * 362 counts * 102.4 us
}

/beta/Code Redesign killagreg/rc.c
63,6 → 63,7
volatile uint8_t RC_Channels; // number of received remote control channels
volatile int16_t PPM_in[MAX_CHANNELS];
volatile int16_t PPM_diff[MAX_CHANNELS];
uint16_t PPM_Neutral = 466;
volatile uint8_t NewPpmData = 1;
volatile uint8_t RC_Quality = 0;
81,7 → 82,8
for(i=0; i<MAX_CHANNELS; i++)
{
PPM_in[i] = 0;
if(i < 5) PPM_in[i] = 0;
else PPM_in[i] = -126;
PPM_diff[i] = 0;
}
230,7 → 232,7
if((signal > 250) && (signal < 687))
{
// shift signal to zero symmetric range -154 to 159
signal -= 466; // offset of 1.4912 ms ??? (469 * 3.2µs = 1.5008 ms)
signal -= PPM_Neutral; // offset of 1.4912 ms ??? (469 * 3.2µs = 1.5008 ms)
// check for stable signal
if(abs(signal - ppm_in[index]) < 6)
{
300,7 → 302,7
if((signal > 250) && (signal < 687))
{
// shift signal to zero symmetric range -154 to 159
signal -= 466; // offset of 1.4912 ms ??? (469 * 3.2µs = 1.5008 ms)
signal -= PPM_Neutral; // offset of 1.4912 ms ??? (469 * 3.2µs = 1.5008 ms)
// check for stable signal
if(abs(signal - PPM_in[index]) < 6)
{

/beta/Code Redesign killagreg/rc.h
25,6 → 25,7
extern void RC_Init (void);
extern volatile int16_t PPM_in[MAX_CHANNELS]; // the RC-Signal
extern volatile int16_t PPM_diff[MAX_CHANNELS]; // the RC-Signal change per 22.5 ms
extern uint16_t PPM_Neutral; // the neutral ppm offset
extern volatile uint8_t NewPpmData; // 0 indicates a new recieved PPM Frame
extern volatile uint8_t RC_Quality; // rc signal quality indicator (0 to 200)
extern volatile uint8_t RC_Channels; // number of received channels

/beta/Code Redesign killagreg/spektrum.c
2,13 → 2,15
#include <stdlib.h>
#include <avr/interrupt.h>
#include "spektrum.h"
#include "main.h"
#include "rc.h"
#include "eeprom.h"
#include "timer0.h"
//#define RECEIVER_SPEKTRUM_EXP
// define RECEIVER_SPEKTRUM_DX7EXP or RECEIVER_SPEKTRUM_DX8EXP is set in main.h
/*
Code derived from:
270,7 → 272,7
{
if(RC_Channels < index) RC_Channels = index;
// Stable Signal
#ifdef RECEIVER_SPEKTRUM_EXP
#if defined (RECEIVER_SPEKTRUM_DX7EXP) || defined (RECEIVER_SPEKTRUM_DX8EXP)
if (index == 2) index = 4; // Analog channel reassigment (2 <-> 4) for logical numbering (1,2,3,4)
else if (index == 4) index = 2;
#endif
291,7 → 293,7
if(tmp > signal+1) tmp--;
else if(tmp < signal-1) tmp++;
#ifdef RECEIVER_SPEKTRUM_EXP
#ifdef RECEIVER_SPEKTRUM_DX7EXP
if(index == 6) // FLIGHT-MODE - The channel used for our data uplink
{
if (signal > 100) // SYNC received
328,6 → 330,44
s_exparity = ~s_exparity; // Bit = 1 -> Invert parity bit
}
}
#elif defined RECEIVER_SPEKTRUM_DX8EXP
if(index == 6) // FLIGHT-MODE - The channel used for our data uplink
{
if (signal > 100) // SYNC received
{
if (s_exdata[s_excnt] == 125) s_exparity = ~s_exparity; // Bit = 1 -> Re-Invert parity bit
if (s_excnt == 9 && ((s_exparity == 0 && s_exdata[s_excnt] == -125) || (s_exparity != 0 && s_exdata[s_excnt] == 125))) // Parity check
{
if (s_exdata[1] == 125 && s_exdata[2] == -125) PPM_in[5] = -125; // Reconstruct tripole Flight-Mode value (CH5)
else if (s_exdata[1] == -125 && s_exdata[2] == -125) PPM_in[5] = 0; // Reconstruct tripole Flight-Mode value (CH5)
else if (s_exdata[1] == -125 && s_exdata[2] == 125) PPM_in[5] = 125; // Reconstruct tripole Flight-Mode value (CH5)
if (s_exdata[3] == 125 && s_exdata[6] == -125) PPM_in[6] = 125; // Reconstruct tripole Elev D/R value (CH6)
else if (s_exdata[3] == -125 && s_exdata[6] == -125) PPM_in[6] = 0; // Reconstruct tripole Elev D/R value (CH6)
else if (s_exdata[3] == -125 && s_exdata[6] == 125) PPM_in[6] = -125; // Reconstruct tripole Elev D/R value (CH6)
if (s_exdata[7] == 125 && s_exdata[8] == -125) PPM_in[9] = -125; // Reconstruct tripole AIL D/R value (CH9)
else if (s_exdata[7] == -125 && s_exdata[8] == -125) PPM_in[9] = 0; // Reconstruct tripole AIL D/R value (CH9)
else if (s_exdata[7] == -125 && s_exdata[8] == 125) PPM_in[9] = 125; // Reconstruct tripole AIL D/R value (CH9)
PPM_in[10] = s_exdata[5]; // Gear (CH10)
PPM_in[12] = s_exdata[4]; // Mix (CH12)
}
s_excnt = 0; // Reset bitcounter
s_exparity = 0; // Reset parity bit
}
if (signal < 10) s_exdata[++s_excnt] = -125; // Bit = 0 -> value = -125 (min)
if (s_excnt == 10) s_excnt = 0; // Overflow protection
if (signal < -100)
{
s_exdata[s_excnt] = 125; // Bit = 1 -> value = 125 (max)
s_exparity = ~s_exparity; // Bit = 1 -> Invert parity bit
}
}
#endif
// calculate signal difference on good signal level
334,10 → 374,15
if(RC_Quality >= 180) PPM_diff[index] = ((tmp - PPM_in[index]) / 3) * 3;
else PPM_diff[index] = 0;
#ifdef RECEIVER_SPEKTRUM_EXP
#ifdef RECEIVER_SPEKTRUM_DX7EXP
if (index < 5 ) PPM_in[index] = tmp; // Update normal potis (CH1-4)
else if (index == 5) PPM_in[7] = signal; // Gear (CH7)
else if (index == 7) PPM_in[9] = signal; // Hover Throttle (CH9)
#elif defined RECEIVER_SPEKTRUM_DX8EXP
if (index < 5 ) PPM_in[index] = tmp; // Update normal potis (CH1-4)
else if (index == 7) PPM_in[7] = signal; // R Trim (CH7)
else if (index == 5) PPM_in[8] = signal; // AUX2 (CH8)
else if (index == 8) PPM_in[11] = signal;
#else
PPM_in[index] = tmp;
#endif

/beta/Code Redesign killagreg/spi.c
172,7 → 172,39
int16_t NCCamNick = 0; // in 0.1°
int32_t NCSetPointHeight = 0;
int8_t NCAltitudeSpeed = 0;
uint8_t NCGPSModeCharacter = ' ';
uint8_t NCGPSAidMode = 0;
// NC error codes
uint8_t NCErrorCode = 0;
#if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__))
const int8_t PROGMEM NC_ERROR_TEXT[MAX_ERR_NUMBER][17] =
{
//0123456789123456
"No Error \0", // 0
"Not compatible \0", // 1
"MK3Mag not compa\0", // 2
"No FC communicat\0", // 3
"MK3Mag communica\0", // 4
"GPS communicatio\0", // 5
"compass value \0", // 6
"RC Signal lost \0", // 7
"FC spi rx error \0", // 8
"No NC communicat\0", // 9
"FC Nick Gyro \0", // 10
"FC Roll Gyro \0", // 11
"FC Yaw Gyro \0", // 12
"FC Nick ACC \0", // 13
"FC Roll ACC \0", // 14
"FC Z-ACC \0", // 15
"Pressure sensor \0", // 16
"FC FC->BL_Ctrl \0", // 17
"Bl Missing \0", // 18
"Mixer Error \0", // 19
"Carefree Error \0", // 20
"GPS Fix list \0" // 21
};
#endif
vector16_t MagVec = {0,0,0};
240,7 → 272,7
ToNaviCtrl.Param.Byte[8] = FC_StatusFlags;
FC_StatusFlags &= ~(FC_STATUS_CALIBRATE | FC_STATUS_START); // calibrate and start are temporal states that are cleared immediately after transmitting
ToNaviCtrl.Param.Byte[9] = GetActiveParamSet();
ToNaviCtrl.Param.Byte[10] = ControlHeading; // 0 to 180 in stepsof 2°
ToNaviCtrl.Param.Byte[10] = ParamSet.ComingHomeAltitude;
ToNaviCtrl.Param.Byte[11] = FC_StatusFlags2;
break;
255,7 → 287,7
ToNaviCtrl.Param.Byte[7] = ParamSet.NaviStickThreshold;
ToNaviCtrl.Param.Byte[8] = ParamSet.NaviOperatingRadius;
ToNaviCtrl.Param.Byte[9] = ParamSet.NaviWindCorrection;
ToNaviCtrl.Param.Byte[10] = ParamSet.NaviSpeedCompensation;
ToNaviCtrl.Param.Byte[10] = ParamSet.NaviAccCompensation;
ToNaviCtrl.Param.Byte[11] = ParamSet.NaviAngleLimitation;
break;
265,6 → 297,8
ToNaviCtrl.Param.Byte[4] = UBat; // 0.1V
ToNaviCtrl.Param.Byte[5] = ParamSet.LowVoltageWarning; //0.1V
ToNaviCtrl.Param.Byte[6] = VarioCharacter;
ToNaviCtrl.Param.Byte[7] = FCParam.Config0;
ToNaviCtrl.Param.Byte[8] = FCParam.Config2;
break;
case SPI_FCCMD_STICK:
312,10 → 346,13
ToNaviCtrl.Param.Byte[3] = NC_SPI_COMPATIBLE;
ToNaviCtrl.Param.Byte[4] = BoardRelease;
ToNaviCtrl.Param.Byte[5] = UART_VersionInfo.HardwareError[0];
UART_VersionInfo.HardwareError[0] = 0; // clear all errors after submission
ToNaviCtrl.Param.Byte[6] = UART_VersionInfo.HardwareError[1];
UART_VersionInfo.HardwareError[1] &= FC_ERROR1_MIXER; // clear all except MIXER error
ToNaviCtrl.Param.Byte[7] = UART_VersionInfo.HardwareError[2];
ToNaviCtrl.Param.Byte[8] = UART_VersionInfo.HardwareError[3];
ToNaviCtrl.Param.Byte[9] = UART_VersionInfo.HardwareError[4];
ToNaviCtrl.Param.Byte[10] = ParamSet.OrientationAngle;
break;
case SPI_FCCMD_SERVOS:
347,9 → 384,9
GPSStickRoll = FromNaviCtrl.GPSStickRoll;
}
// update compass readings
MagVec.x = FromNaviCtrl.MagVecX;
MagVec.y = FromNaviCtrl.MagVecY;
MagVec.z = FromNaviCtrl.MagVecZ;
//MagVec.x = FromNaviCtrl.MagVecX;
//MagVec.y = FromNaviCtrl.MagVecY;
//MagVec.z = FromNaviCtrl.MagVecZ;
// update compass readings
if(FromNaviCtrl.CompassHeading <= 360)
356,12 → 393,14
{
CompassHeading = FromNaviCtrl.CompassHeading;
}
if(CompassHeading < 0) CompassOffCourse = 0;
else CompassOffCourse = ((540 + CompassHeading - CompassCourse) % 360) - 180;
//if(CompassHeading < 0) CompassOffCourse = 0;
//else CompassOffCourse = ((540 + CompassHeading - CompassCourse) % 360) - 180;
// NaviCtrl wants to beep?
if (FromNaviCtrl.BeepTime > BeepTime /*&& !CompassCalState*/) BeepTime = FromNaviCtrl.BeepTime;
#define FLAG_GPS_AID 0x01
switch (FromNaviCtrl.Command)
{
373,6 → 412,7
NCGpsZ = FromNaviCtrl.Param.sByte[4];
NCRotate_C = FromNaviCtrl.Param.sByte[5];
NCRotate_S = FromNaviCtrl.Param.sByte[6];
if(FromNaviCtrl.Param.Byte[7] & FLAG_GPS_AID) NCGPSAidMode = 1; else NCGPSAidMode = 0;
if(CareFree && FromNaviCtrl.Param.sInt[4] >= 0)
{ // if CareFree then NC can set compass course and nick offset
CompassCourse = FromNaviCtrl.Param.sInt[4];
392,8 → 432,9
NC_Version.Compatible = FromNaviCtrl.Param.Byte[3];
NC_Version.Hardware = FromNaviCtrl.Param.Byte[4];
DebugOut.Status[0] |= FromNaviCtrl.Param.Byte[5];
NCErrorCode = FromNaviCtrl.Param.Byte[6];
DebugOut.Status[1] = (DebugOut.Status[1] & (0x01|0x02)) | (FromNaviCtrl.Param.Byte[6] & (0x04 | 0x08));
NCErrorCode = FromNaviCtrl.Param.Byte[7];
NCGPSModeCharacter = FromNaviCtrl.Param.Byte[8];
break;
case SPI_NCCMD_GPSINFO:
408,6 → 449,12
NCSetPointHeight = (int32_t)FromNaviCtrl.Param.sInt[5] * 10; // in steps of 1cm
break;
#if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__))
case SPI_NCCMD_HOTT_DATA:
if(ParamSet.Receiver == RECEIVER_HOTT) NC_Fills_HoTT_Telemety();
break;
#endif
default:
break;
}

/beta/Code Redesign killagreg/spi.h
2,8 → 2,8
#ifndef _SPI_H
#define _SPI_H
//#include <util/delay.h>
#include <inttypes.h>
#include <avr/pgmspace.h>
#include "vector.h"
44,12 → 44,10
#define SPI_NCCMD_OSD_DATA 100
#define SPI_NCCMD_GPS_POS 101
#define SPI_NCCMD_GPS_TARGET 102
#define SPI_NCCMD_KALMAN 103
#define SPI_NCCMD_VERSION 104
#define SPI_NCCMD_GPSINFO 105
#define SPI_NCCMD_HOTT_DATA 106
typedef struct
{
58,8 → 56,10
int16_t GPSStickRoll;
int16_t GPS_Yaw;
int16_t CompassHeading;
int16_t MagVecX;
int16_t MagVecY;
// int16_t MagVecX;
// int16_t MagVecY;
int16_t AccErrorN;
int16_t AccErrorR;
int16_t MagVecZ;
int16_t NCStatus;
uint16_t BeepTime;
105,7 → 105,12
#define FLAG_DIFFSOLN 0x02 // (is DGPS used)
#define FLAG_WKNSET 0x04 // (is Week Number valid)
#define FLAG_TOWSET 0x08 // (is Time of Week valid)
#define FLAG_GPS_NAVIGATION_ACT 0x10 // gps navigation active
#define FLAG_RES1 0x20
#define FLAG_RES2 0x40
#define FLAG_RES3 0x80
typedef struct
{
uint8_t Flags; // Status Flags
125,10 → 130,18
extern int16_t NCCamNick;
extern int32_t NCSetPointHeight;
extern int8_t NCAltitudeSpeed;
extern uint8_t NCErrorCode;
extern uint8_t NCGPSModeCharacter;
extern uint8_t NCGPSAidMode;
extern vector16_t MagVec;
// NC error codes
extern uint8_t NCErrorCode;
#if (defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__))
#define MAX_ERR_NUMBER 22
extern const int8_t PROGMEM NC_ERROR_TEXT[MAX_ERR_NUMBER][17];
#endif
void SPI_MasterInit(void);
void SPI_StartTransmitPacket(void);
void SPI_TransmitByte(void);

/beta/Code Redesign killagreg/timer0.c
196,7 → 196,7
#ifndef USE_NAVICTRL
// update compass value if this option is enabled in the settings
if(ParamSet.Config0 & (CFG0_COMPASS_ACTIVE|CFG0_GPS_ACTIVE))
if(FCParam.Config0 & (CFG0_COMPASS_ACTIVE|CFG0_GPS_ACTIVE))
{
#ifdef USE_MK3MAG
MK3MAG_Update(); // read out mk3mag pwm

/beta/Code Redesign killagreg/timer2.c
330,7 → 330,7
RemainingPulse = PPM_STOPPULSE;
// accumulate time for correct sync gap
ServoFrameTime += RemainingPulse;
if(ServoActive && RC_Quality > 180) HEF4017R_OFF; // disable HEF4017 reset
if(ServoActive && RC_Quality) HEF4017R_OFF; // disable HEF4017 reset
else HEF4017R_ON; // enable reset
ServoIndex++; // change to next servo channel
if(ServoIndex > ParamSet.ServoRefresh)

/beta/Code Redesign killagreg/uart0.c
71,6 → 71,10
#include "libfc.h"
#include "debug.h"
//Baud rate of the USART
#define USART0_BAUD 57600L
#define USART0_BAUD_HOTT 19700L
#define USART0_BAUD_JETI 38400L
#define FC_ADDRESS 1
#define NC_ADDRESS 2
102,7 → 106,7
volatile uint8_t ReceivedBytes = 0;
volatile uint8_t *pRxData = 0;
volatile uint8_t RxDataLen = 0;
volatile uint8_t JetiUpdateModeActive = 0;
volatile uint8_t ReceiverUpdateModeActive = 0; // 1 = Update 2 = JetiBox-Simulation
volatile uint8_t JetiByteBuffer = 0;
uint8_t PcAccess = 100;
164,7 → 168,7
"Capacity [mAh] ",
"Height Setpoint ",
"25 ", //25
"26 ",
"26 ", //CPU Overload
"CompassSetPoint ",
"I2C-Error ",
"BL Limit ",
291,13 → 295,13
c = UDR0; // catch the received byte
if(JetiUpdateModeActive == 1)
{ // forward byte direct to UART1
if(ReceiverUpdateModeActive == 1)
{ // forward byte direct to UART1 (update)
UDR1 = c;
return;
}
if(JetiUpdateModeActive == 2)
{ // buffer input byte for later forwarding
if(ReceiverUpdateModeActive == 2)
{ // buffer input byte for later forwarding (JetiBox-Simulation)
JetiByteBuffer = c;
return;
}
502,7 → 506,7
#ifdef USE_MK3MAG
case 'K':// compass value
CompassHeading = ((Heading_t *)pRxData)->Heading;
CompassOffCourse = ((540 + CompassHeading - CompassCourse) % 360) - 180;
//CompassOffCourse = ((540 + CompassHeading - CompassCourse) % 360) - 180;
break;
#endif
656,11 → 660,10
break;
case 'j':
if(FC_StatusFlags & FC_STATUS_MOTOR_RUN) break; // ignore receiver update when motors are running
tempchar1 = LIBFC_GetCPUType();
if((tempchar1 == CPU_ATMEGA644P) || (tempchar1 == CPU_ATMEGA1284P))
{
uint16_t ubrr = (uint16_t) ((uint32_t) F_CPU/ (8 * 38400L) - 1);
// disable all interrupts before configuration
cli();
676,10 → 679,20
while ( UCSR1A & (1<<RXC1) ) UDR1;
while ( UCSR0A & (1<<RXC0) ) UDR0;
if (pRxData[0] == 0)
if (pRxData[0] == 1)
{
JetiUpdateModeActive = 1;
ReceiverUpdateModeActive = 2;
}
else
{ // Jeti or HOTT update
ReceiverUpdateModeActive = 1;
// calculate baudrate register
uint16_t ubrr;
if(pRxData[0] == 100) ubrr = (uint16_t) ((uint32_t) F_CPU/(8 * USART0_BAUD_HOTT) - 1); // HoTT
else ubrr = (uint16_t) ((uint32_t) F_CPU/(8 * USART0_BAUD_JETI) - 1); // Jeti
// UART0 & UART1 set baudrate
UBRR1H = (uint8_t)(ubrr>>8);
UBRR1L = (uint8_t)ubrr;
693,7 → 706,6
UCSR1C |= (1 << UCSZ11);
UCSR1C |= (1 << UCSZ10);
}
else JetiUpdateModeActive = 2;
// UART1 clear 9th bit
UCSR1B &= ~(1<<TXB81);

/beta/Code Redesign killagreg/uart0.h
9,10 → 9,6
#include <inttypes.h>
//Baud rate of the USART
#define USART0_BAUD 57600
extern void USART0_Init (void);
extern void USART0_TransmitTxData(void);
extern void USART0_ProcessRxData(void);
28,7 → 24,7
extern uint8_t MotorTest_Active;
extern uint8_t MotorTest[16];
extern volatile uint8_t JetiUpdateModeActive;
extern volatile uint8_t ReceiverUpdateModeActive;
extern volatile uint8_t JetiByteBuffer;
typedef struct

/beta/Code Redesign killagreg/version.txt
448,12 → 448,48
- Kanaloffset für Potis von 110 auf 127 erhöht, damit es gleich ist mit allen anderen Kanälen
- POI-Richtung (Soll-Himmelsrichtung) bezieht sich auf den Kamera-Winkel
0.85 H.Buss
- Variable "JetiBeep" wird gelöscht, wenn an den Empfänger gesendet wurde
- wenn GPS deaktiviert ist, keinen Fehler bringen, wenn GPS fehlt. Auch dann nicht piepsen
- GPS-Sollwertverschiebung
- Empfangs-Piepen unterdrücken -> einstellbar
- MotorSmooth einstellbar
- Höhenregler: keine 'harte' IstWert-Übernahme bei Bewegen des Sticks in die Hoover-Position
- Coming Home mit Höhenvorgabe
- Coming Home als Failsafe
- Einführung des GPS-Characters (- / W H D P)
- neue Fehlermeldung: NC_ErrorCode = 9 "ERR: no NC communication"
- Klartext bei den Jeti-Fehlermeldungen
- Jeti-Beep "3*kurz" bei NC-Errors
- Jeti-LCD-Aufruf nur noch alle 300ms, weil die Werte zu unruhig waren
- Mixer-Settings werden nicht gelöscht, wenn sich die Parameter-Revision ändert
- GPS-Angle limit von 100 auf 140
- GPS-I-Limit von 75 auf 85
- GAS-Offset von 120 auf 127 erhöht, damit es für alle Kanäle gleich ist
- EE_Parameter.Hoehe_StickNeutralPoint auf Werte zwischen 80 und 180 begrenzt (70/150?)
- PPM_Neutral eingeführt, um den Offset bei HoTT auszugleichen;
- LED_Update() nun nur noch alle 20ms, weil die schnellste Ausgabe (bei Potivorgabe) ohnehin nur 40ms sind
- Jeti & HoTT: Nur beim Fehler auch JetiBeep, wenn die Motoren laufen -> sonst nervt das bei der Fehlerbehebung (Compass-Kalibrieren usw.)
- Error-Text auch im virtuellen Display des Koptertools
- virtuelles LCD-Menü:
- "ExternControl" aus Platzgründen aus dem virtuellen LCD-Menü entfernt.
- keine BL-Temperaturen und I2C-Fehler anzeigen, wenn die BL-Regler nicht verwendet werden
- nach dem Gieren nicht den Ersatzkompass auf den Kompasswert stellen, die Umschaltung war zu hart
- ACC Correction eingeführt
- I2C Fehler kamen nicht bei der NC an, weil die zu kurz waren
- Fehlermeldungen stehen jetzt mind. so lange an, bis sie an die Nc gesendet wurden
- neue Fehlermeldung: "GPS Fix lost"
- LED: Schaltfläche "nur bei Motor start" bei beiden getrennt
- Ausbau der HoTT-Telemetrie
- Variable "KompassRichtung" entfernt
- ErsatzKompassInGrad sinvoll genutzt
- HoTT-Update per Uart-Durchschleifen
- AltitudeSetpointTrimming eingeführt
- Vario-Anzeige für HoT
Anpassungen bzgl. V0.85h
G.Stobrawa 31.08.2011 (trunk SVN 1943, private SVN 551)
Anpassungen bzgl. V0.83
G.Stobrawa 22.03.2011
- Code stärker modularisiert und restrukturiert
- viele Kommentare zur Erklärug eingefügt
- konsequent englische Variablennamen