bool
AbstractTask::UpdateIdle(const AircraftState &state,
const GlidePolar &glide_polar)
{
if (TaskStarted() && task_behaviour.calc_cruise_efficiency) {
fixed val = fixed_one;
if (CalcCruiseEfficiency(state, glide_polar, val))
stats.cruise_efficiency = std::max(ce_lpf.update(val), fixed_zero);
} else {
stats.cruise_efficiency = ce_lpf.reset(fixed_one);
}
if (TaskStarted() && task_behaviour.calc_effective_mc) {
fixed val = glide_polar.GetMC();
if (CalcEffectiveMC(state, glide_polar, val))
stats.effective_mc = std::max(em_lpf.update(val), fixed_zero);
} else {
stats.effective_mc = em_lpf.reset(glide_polar.GetMC());
}
if (task_behaviour.calc_glide_required)
UpdateStatsGlide(state, glide_polar);
else
stats.glide_required = fixed_zero; // error
return false;
}
bool
AbstractTask::UpdateAutoMC(GlidePolar &glide_polar,
const AircraftState& state, fixed fallback_mc)
{
if (!task_behaviour.auto_mc) {
/* AutoMC disabled in configuration */
ResetAutoMC();
return false;
}
fixed mc_found;
if (task_behaviour.IsAutoMCFinalGlideEnabled() &&
TaskStarted(true) && stats.flight_mode_final_glide) {
/* calculate final glide MacCready */
if (CalcBestMC(state, glide_polar, mc_found)) {
/* final glide MacCready found */
if (mc_lpf_valid)
stats.mc_best = std::max(mc_lpf.Update(mc_found), fixed(0));
else {
stats.mc_best = std::max(mc_lpf.Reset(mc_found), fixed(0));
mc_lpf_valid = true;
}
} else
/* below final glide, but above margin */
stats.mc_best = fixed(0);
glide_polar.SetMC(stats.mc_best);
return true;
} else if (task_behaviour.IsAutoMCCruiseEnabled()) {
/* cruise: set MacCready to recent climb average */
if (!positive(fallback_mc)) {
/* no climb average calculated yet */
ResetAutoMC();
return false;
}
stats.mc_best = fallback_mc;
glide_polar.SetMC(stats.mc_best);
return true;
} else if (TaskStarted(true)) {
/* no solution, but forced final glide AutoMacCready - converge to
zero */
mc_found = fixed(0);
if (mc_lpf_valid)
stats.mc_best = std::max(mc_lpf.Update(mc_found), fixed(0));
else {
stats.mc_best = std::max(mc_lpf.Reset(mc_found), fixed(0));
mc_lpf_valid = true;
}
glide_polar.SetMC(stats.mc_best);
return true;
} else {
ResetAutoMC();
return false;
}
}
void
AbstractTask::UpdateStatsDistances(const GeoPoint &location,
const bool full_update)
{
stats.total.remaining.set_distance(ScanDistanceRemaining(location));
const TaskPoint *active = GetActiveTaskPoint();
if (active != NULL) {
stats.current_leg.location_remaining = active->GetLocationRemaining();
stats.current_leg.vector_remaining = active->GetVectorRemaining(location);
} else {
stats.current_leg.location_remaining = GeoPoint::Invalid();
stats.current_leg.vector_remaining = GeoVector::Invalid();
}
if (full_update)
stats.distance_nominal = ScanDistanceNominal();
ScanDistanceMinMax(location, full_update,
&stats.distance_min, &stats.distance_max);
stats.total.travelled.set_distance(ScanDistanceTravelled(location));
stats.total.planned.set_distance(ScanDistancePlanned());
if (IsScored()) {
if (!TaskStarted())
stats.distance_scored = fixed_zero;
else if (!TaskFinished())
stats.distance_scored = ScanDistanceScored(location);
} else
stats.distance_scored = fixed_zero;
}
void WmdmLoader::LoadDatabase() {
int task_id = task_manager_->StartTask(tr("Loading Windows Media device"));
emit TaskStarted(task_id);
boost::scoped_ptr<WmdmThread> thread(new WmdmThread);
// Get the device's canonical name
boost::shared_ptr<WmdmDevice> connected_device =
boost::static_pointer_cast<WmdmDevice>(device_);
WmdmLister* lister = static_cast<WmdmLister*>(connected_device->lister());
QString canonical_name = lister->DeviceCanonicalName(connected_device->unique_id());
IWMDMStorage* storage = thread->GetRootStorage(canonical_name);
QStringList path_components;
RecursiveExploreStorage(storage, &path_components);
storage->Release();
thread.reset();
// Need to remove all the existing songs in the database first
backend_->DeleteSongs(backend_->FindSongsInDirectory(1));
// Add the songs we've just loaded
backend_->AddOrUpdateSongs(songs_);
task_manager_->SetTaskFinished(task_id);
emit LoadFinished();
}
AircraftState
OrderedTask::GetStartState() const
{
if (HasStart() && TaskStarted())
return taskpoint_start->GetEnteredState();
// @todo: modify this for optional start?
AircraftState null_state;
return null_state;
}
void MtpLoader::LoadDatabase() {
int task_id = task_manager_->StartTask(tr("Loading MTP device"));
emit TaskStarted(task_id);
TryLoad();
moveToThread(original_thread_);
task_manager_->SetTaskFinished(task_id);
emit LoadFinished();
}
void GPodLoader::LoadDatabase() {
int task_id = task_manager_->StartTask(tr("Loading iPod database"));
emit TaskStarted(task_id);
// Load the iTunes database
GError* error = nullptr;
Itdb_iTunesDB* db =
itdb_parse(QDir::toNativeSeparators(mount_point_).toLocal8Bit(), &error);
// Check for errors
if (!db) {
if (error) {
qLog(Error) << "loading database failed:" << error->message;
emit Error(QString::fromUtf8(error->message));
g_error_free(error);
} else {
emit Error(tr("An error occurred loading the iTunes database"));
}
task_manager_->SetTaskFinished(task_id);
return;
}
// Convert all the tracks from libgpod structs into Song classes
const QString prefix = path_prefix_.isEmpty()
? QDir::fromNativeSeparators(mount_point_)
: path_prefix_;
SongList songs;
for (GList* tracks = db->tracks; tracks != nullptr; tracks = tracks->next) {
Itdb_Track* track = static_cast<Itdb_Track*>(tracks->data);
Song song;
song.InitFromItdb(track, prefix);
song.set_directory_id(1);
if (type_ != Song::Type_Unknown) song.set_filetype(type_);
songs << song;
}
// Need to remove all the existing songs in the database first
backend_->DeleteSongs(backend_->FindSongsInDirectory(1));
// Add the songs we've just loaded
backend_->AddOrUpdateSongs(songs);
moveToThread(original_thread_);
task_manager_->SetTaskFinished(task_id);
emit LoadFinished(db);
}
bool
AbstractTask::UpdateAutoMC(GlidePolar &glide_polar,
const AircraftState& state, fixed fallback_mc)
{
if (!positive(fallback_mc))
fallback_mc = glide_polar.GetMC();
if (!TaskStarted(true) || !task_behaviour.auto_mc) {
ResetAutoMC();
return false;
}
if (task_behaviour.auto_mc_mode == TaskBehaviour::AutoMCMode::CLIMBAVERAGE) {
stats.mc_best = mc_lpf.reset(fallback_mc);
mc_lpf_valid = true;
trigger_auto = false;
return false;
}
fixed mc_found;
if (CalcBestMC(state, glide_polar, mc_found)) {
// improved solution found, activate auto fg mode
if (mc_found > stats.mc_best)
trigger_auto = true;
} else {
// no solution even at mc=0, deactivate auto fg mode
trigger_auto = false;
}
if (!trigger_auto &&
task_behaviour.auto_mc_mode == TaskBehaviour::AutoMCMode::FINALGLIDE &&
stats.mc_best >= fixed(0.05)) {
/* no solution, but forced final glide AutoMacCready - converge to
zero */
mc_found = fixed_zero;
trigger_auto = true;
}
if (trigger_auto && mc_lpf_valid) {
// smooth out updates
stats.mc_best = std::max(mc_lpf.update(mc_found), fixed_zero);
glide_polar.SetMC(stats.mc_best);
} else {
// reset lpf so will be smooth next time it becomes active
stats.mc_best = mc_lpf.reset(fallback_mc);
mc_lpf_valid = true;
}
return trigger_auto;
}
void
AbstractTask::UpdateStatsSpeeds(const AircraftState &state,
const AircraftState &state_last)
{
if (!TaskFinished()) {
if (TaskStarted()) {
const fixed dt = state.time - state_last.time;
stats_computer.total.CalcSpeeds(stats.total, dt);
stats_computer.current_leg.CalcSpeeds(stats.current_leg, dt);
} else {
stats_computer.total.Reset(stats.total);
stats_computer.current_leg.Reset(stats.current_leg);
}
}
}
bool
OrderedTask::CheckTransitions(const AircraftState &state,
const AircraftState &state_last)
{
if (!taskpoint_start)
return false;
taskpoint_start->ScanActive(*task_points[active_task_point]);
if (!state.flying)
return false;
const int n_task = task_points.size();
if (!n_task)
return false;
FlatBoundingBox bb_last(task_projection.project(state_last.location),1);
FlatBoundingBox bb_now(task_projection.project(state.location),1);
bool last_started = TaskStarted();
const bool last_finished = TaskFinished();
const int t_min = max(0, (int)active_task_point - 1);
const int t_max = min(n_task - 1, (int)active_task_point);
bool full_update = false;
for (int i = t_min; i <= t_max; i++) {
bool transition_enter = false;
bool transition_exit = false;
if (i==0) {
full_update |= CheckTransitionOptionalStart(state, state_last,
bb_now, bb_last,
transition_enter,
transition_exit,
last_started);
}
full_update |= CheckTransitionPoint(*task_points[i],
state, state_last, bb_now, bb_last,
transition_enter, transition_exit,
last_started, i == 0);
if (i == (int)active_task_point) {
const bool last_request_armed = task_advance.NeedToArm();
if (task_advance.CheckReadyToAdvance(*task_points[i], state,
transition_enter,
transition_exit)) {
task_advance.SetArmed(false);
if (i + 1 < n_task) {
i++;
SetActiveTaskPoint(i);
taskpoint_start->ScanActive(*task_points[active_task_point]);
if (task_events != NULL)
task_events->ActiveAdvanced(*task_points[i], i);
// on sector exit, must update samples since start sector
// exit transition clears samples
full_update = true;
}
} else if (!last_request_armed && task_advance.NeedToArm()) {
if (task_events != NULL)
task_events->RequestArm(*task_points[i]);
}
}
}
taskpoint_start->ScanActive(*task_points[active_task_point]);
stats.task_finished = TaskFinished();
stats.task_started = TaskStarted();
if (stats.task_started)
taskpoint_finish->set_fai_finish_height(GetStartState().altitude - fixed(1000));
if (task_events != NULL) {
if (stats.task_started && !last_started)
task_events->TaskStart();
if (stats.task_finished && !last_finished)
task_events->TaskFinish();
}
return full_update;
}
