/**
* Is called by the CalculationThread and processes the received GPS data in Basic()
*/
bool
GlideComputer::ProcessGPS(bool force)
{
const MoreData &basic = Basic();
DerivedInfo &calculated = SetCalculated();
const ComputerSettings &settings = GetComputerSettings();
const bool last_flying = calculated.flight.flying;
calculated.date_time_local = basic.date_time_utc + settings.utc_offset;
calculated.Expire(basic.clock);
// Process basic information
air_data_computer.ProcessBasic(Basic(), SetCalculated(),
GetComputerSettings());
// Process basic task information
task_computer.ProcessBasicTask(basic, LastBasic(),
calculated,
GetComputerSettings(),
force);
task_computer.ProcessMoreTask(basic, calculated, GetComputerSettings());
// Check if everything is okay with the gps time and process it
if (!air_data_computer.FlightTimes(Basic(), LastBasic(), SetCalculated(),
GetComputerSettings()))
return false;
TakeoffLanding(last_flying);
if (!time_retreated())
task_computer.ProcessAutoTask(basic, calculated);
// Process extended information
air_data_computer.ProcessVertical(Basic(), LastBasic(),
SetCalculated(),
GetComputerSettings());
if (!time_retreated())
stats_computer.ProcessClimbEvents(calculated);
// Calculate the team code
CalculateOwnTeamCode();
// Calculate the bearing and range of the teammate
CalculateTeammateBearingRange();
vegavoice.Update(basic, Calculated(), GetComputerSettings().voice);
// update basic trace history
if (time_advanced())
calculated.trace_history.append(basic);
// Update the ConditionMonitors
ConditionMonitorsUpdate(Basic(), Calculated(), settings);
return idle_clock.CheckUpdate(500);
}
/**
* Is called by the CalculationThread and processes the received GPS data in Basic()
*/
bool
GlideComputer::ProcessGPS()
{
PeriodClock clock;
clock.update();
// Process basic information
ProcessBasic();
// Process basic task information
ProcessBasicTask();
ProcessMoreTask();
// Check if everything is okay with the gps time and process it
if (!FlightTimes()) {
return false;
}
// Process extended information
ProcessVertical();
// Calculate the team code
CalculateOwnTeamCode();
// Calculate the bearing and range of the teammate
CalculateTeammateBearingRange();
// Calculate the bearing and range of the teammate
// (if teammate is a FLARM target)
FLARM_ScanTraffic();
vegavoice.Update(&Basic(), &Calculated(), SettingsComputer());
// Update the ConditionMonitors
ConditionMonitorsUpdate(*this);
SetCalculated().time_process_gps = clock.elapsed();
return true;
}
/**
* Is called by the CalculationThread and processes the received GPS data in Basic()
*/
bool
GlideComputer::ProcessGPS(bool force)
{
const MoreData &basic = Basic();
DerivedInfo &calculated = SetCalculated();
const ComputerSettings &settings = GetComputerSettings();
const bool last_flying = calculated.flight.flying;
if (basic.time_available) {
/* use UTC offset to calculate local time */
const int utc_offset_s = settings.utc_offset.AsSeconds();
calculated.date_time_local = basic.date_time_utc.IsDatePlausible()
/* known date: apply UTC offset to BrokenDateTime, which may
increment/decrement date */
? basic.date_time_utc + utc_offset_s
/* unknown date: apply UTC offset only to BrokenTime, leave the
BrokenDate part invalid as it was */
: BrokenDateTime(BrokenDate::Invalid(),
((const BrokenTime &)basic.date_time_utc) + utc_offset_s);
} else
calculated.date_time_local = BrokenDateTime::Invalid();
calculated.Expire(basic.clock);
// Process basic information
air_data_computer.ProcessBasic(Basic(), SetCalculated(),
GetComputerSettings());
// Process basic task information
const bool last_finished = calculated.ordered_task_stats.task_finished;
task_computer.ProcessBasicTask(basic,
calculated,
GetComputerSettings(),
force);
task_computer.ProcessMoreTask(basic, calculated, GetComputerSettings());
if (!last_finished && calculated.ordered_task_stats.task_finished)
OnFinishTask();
// Check if everything is okay with the gps time and process it
air_data_computer.FlightTimes(Basic(), SetCalculated(),
GetComputerSettings());
TakeoffLanding(last_flying);
task_computer.ProcessAutoTask(basic, calculated);
// Process extended information
air_data_computer.ProcessVertical(Basic(),
SetCalculated(),
GetComputerSettings());
stats_computer.ProcessClimbEvents(calculated);
// Calculate the team code
CalculateOwnTeamCode();
// Calculate the bearing and range of the teammate
CalculateTeammateBearingRange();
vegavoice.Update(basic, Calculated(), GetComputerSettings().voice);
// update basic trace history
if (basic.time_available) {
const auto dt = trace_history_time.Update(basic.time, 0.5, 30);
if (dt > 0)
calculated.trace_history.append(basic);
else if (dt < 0)
/* time warp */
calculated.trace_history.clear();
}
// Update the ConditionMonitors
ConditionMonitorsUpdate(Basic(), Calculated(), settings);
return idle_clock.CheckUpdate(500);
}
bool DoCalculations(NMEA_INFO *Basic, DERIVED_INFO *Calculated)
{
// first thing: assign navaltitude!
EnergyHeightNavAltitude(Basic, Calculated);
// second thing: if available, get external wind precalculated!
if ( (Basic->ExternalWindAvailable==TRUE) && (AutoWindMode==D_AUTOWIND_EXTERNAL)) {
if (Basic->ExternalWindSpeed>0 && Basic->ExternalWindSpeed<35) {
Calculated->WindSpeed = Basic->ExternalWindSpeed;
Calculated->WindBearing = Basic->ExternalWindDirection;
}
}
Heading(Basic, Calculated);
DistanceToNext(Basic, Calculated);
DistanceToHome(Basic, Calculated);
DetectFreeFlying(Basic,Calculated); // check ongoing powerless flight
DoLogging(Basic, Calculated);
TerrainHeight(Basic, Calculated);
AltitudeRequired(Basic, Calculated, MACCREADY);
DoAlternates(Basic,Calculated,TASKINDEX);
if (IsMultiMapShared()) {
DoAlternates(Basic,Calculated,RESWP_LASTTHERMAL);
DoAlternates(Basic,Calculated,RESWP_TEAMMATE);
DoAlternates(Basic,Calculated,RESWP_FLARMTARGET);
DoAlternates(Basic,Calculated,HomeWaypoint);
if (DoOptimizeRoute() || ACTIVE_WP_IS_AAT_AREA) {
DoAlternates(Basic, Calculated, RESWP_OPTIMIZED);
}
for (int i=RESWP_FIRST_MARKER; i<=RESWP_LAST_MARKER; i++) {
if (WayPointList[i].Latitude==RESWP_INVALIDNUMBER) continue;
DoAlternates(Basic,Calculated,i);
}
} else {
// The following is needed only for the next-WP glide terrain line,
// not for the main/primary glide terrain line.
if ((FinalGlideTerrain > 2) && (DoOptimizeRoute() || ACTIVE_WP_IS_AAT_AREA))
DoAlternates(Basic, Calculated, RESWP_OPTIMIZED);
}
if (!TargetDialogOpen) {
// don't calculate these if optimise function being invoked or
// target is being adjusted
TaskStatistics(Basic, Calculated, MACCREADY);
AATStats(Basic, Calculated);
TaskSpeed(Basic, Calculated, MACCREADY);
}
if (!FlightTimes(Basic, Calculated)) {
// time hasn't advanced, so don't do calculations requiring an advance
// or movement
return false;
}
Turning(Basic, Calculated);
LD(Basic,Calculated);
CruiseLD(Basic,Calculated);
// We calculate flaps settings only if the polar is extended.
// We do assume that GA planes will NOT use extended polars
if (GlidePolar::FlapsPosCount >0) Flaps(Basic,Calculated);
Calculated->AverageLD=CalculateLDRotary(&rotaryLD,Basic,Calculated);
Average30s(Basic,Calculated);
AverageThermal(Basic,Calculated);
AverageClimbRate(Basic,Calculated);
ThermalGain(Basic,Calculated);
LastThermalStats(Basic, Calculated);
// ThermalBand(Basic, Calculated); moved to % circling function
MaxHeightGain(Basic,Calculated);
PredictNextPosition(Basic, Calculated);
if (Orbiter) CalculateOrbiter(Basic,Calculated);
CalculateOwnTeamCode(Basic, Calculated);
CalculateTeammateBearingRange(Basic, Calculated);
BallastDump();
// reminder: Paragliders have AAT always on
CalculateOptimizedTargetPos(Basic,Calculated);
if (ValidTaskPoint(ActiveTaskPoint)) {
// only if running a real task
if (ValidTaskPoint(1)) InSector(Basic, Calculated);
DoAutoMacCready(Basic, Calculated);
#ifdef DEBUGTASKSPEED
DebugTaskCalculations(Basic, Calculated);
#endif
} else { // 101002
DoAutoMacCready(Basic, Calculated); // will set only EqMC
}
DoAlternates(Basic, Calculated,Alternate1);
DoAlternates(Basic, Calculated,Alternate2);
DoAlternates(Basic, Calculated,BestAlternate);
// Calculate nearest waypoints when needed
if ( !MapWindow::mode.AnyPan() && DrawBottom && (MapSpaceMode>MSM_MAP) ) {
switch(MapSpaceMode) {
case MSM_LANDABLE:
case MSM_AIRPORTS:
case MSM_NEARTPS: // 101222
DoNearest(Basic,Calculated);
break;
case MSM_COMMON:
DoCommon(Basic,Calculated);
break;
case MSM_RECENT:
DoRecent(Basic,Calculated);
break;
case MSM_VISUALGLIDE:
// Only if visualglide is really painted: topview is not fullscreen.
if (Current_Multimap_SizeY<SIZE4) {
DoNearest(Basic,Calculated);
}
break;
}
}
CalculateHeadWind(Basic,Calculated);
ConditionMonitorsUpdate(Basic, Calculated);
return true;
}
