mirror of
https://github.com/f4exb/sdrangel.git
synced 2024-10-05 11:16:40 -04:00
a398381aaf
Add ATC callsigns. Add ATC mode, displaying basic info for all aircraft. Add airport range rings. Change Device setting to be an AM Demod setting, so AM demod isn't at DC. Add basic aircraft data to ADSB Web API report.
6099 lines
255 KiB
C++
6099 lines
255 KiB
C++
///////////////////////////////////////////////////////////////////////////////////
|
|
// Copyright (C) 2020 Edouard Griffiths, F4EXB //
|
|
// Copyright (C) 2020 Jon Beniston, M7RCE //
|
|
// //
|
|
// This program is free software; you can redistribute it and/or modify //
|
|
// it under the terms of the GNU General Public License as published by //
|
|
// the Free Software Foundation as version 3 of the License, or //
|
|
// (at your option) any later version. //
|
|
// //
|
|
// This program is distributed in the hope that it will be useful, //
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of //
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
|
|
// GNU General Public License V3 for more details. //
|
|
// //
|
|
// You should have received a copy of the GNU General Public License //
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>. //
|
|
///////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#include <cmath>
|
|
|
|
#include "device/deviceuiset.h"
|
|
#include <QDockWidget>
|
|
#include <QMainWindow>
|
|
#include <QQuickItem>
|
|
#include <QGeoLocation>
|
|
#include <QQmlContext>
|
|
#include <QDesktopServices>
|
|
#include <QUrl>
|
|
#include <QMessageBox>
|
|
#include <QDebug>
|
|
#include <QProcess>
|
|
#include <QClipboard>
|
|
#include <QFileDialog>
|
|
#include <QQmlProperty>
|
|
#include <QJsonDocument>
|
|
#include <QJsonObject>
|
|
|
|
#include "ui_adsbdemodgui.h"
|
|
#include "device/deviceapi.h"
|
|
#include "channel/channelwebapiutils.h"
|
|
#include "feature/featurewebapiutils.h"
|
|
#include "plugin/pluginapi.h"
|
|
#include "util/airlines.h"
|
|
#include "util/crc.h"
|
|
#include "util/simpleserializer.h"
|
|
#include "util/db.h"
|
|
#include "util/units.h"
|
|
#include "util/morse.h"
|
|
#include "gui/basicchannelsettingsdialog.h"
|
|
#include "gui/devicestreamselectiondialog.h"
|
|
#include "gui/crightclickenabler.h"
|
|
#include "gui/clickablelabel.h"
|
|
#include "gui/tabletapandhold.h"
|
|
#include "gui/dialpopup.h"
|
|
#include "gui/dialogpositioner.h"
|
|
#include "dsp/dspengine.h"
|
|
#include "dsp/dspcommands.h"
|
|
#include "mainwindow.h"
|
|
|
|
#include "adsbdemodreport.h"
|
|
#include "adsbdemod.h"
|
|
#include "adsbdemodgui.h"
|
|
#include "adsbdemodfeeddialog.h"
|
|
#include "adsbdemoddisplaydialog.h"
|
|
#include "adsbdemodnotificationdialog.h"
|
|
#include "adsb.h"
|
|
#include "adsbosmtemplateserver.h"
|
|
|
|
const char ADSBDemodGUI::m_idMap[] = "#ABCDEFGHIJKLMNOPQRSTUVWXYZ##### ############-##0123456789######";
|
|
|
|
const QString ADSBDemodGUI::m_categorySetA[] = {
|
|
QStringLiteral("None"),
|
|
QStringLiteral("Light"),
|
|
QStringLiteral("Small"),
|
|
QStringLiteral("Large"),
|
|
QStringLiteral("High vortex"),
|
|
QStringLiteral("Heavy"),
|
|
QStringLiteral("High performance"),
|
|
QStringLiteral("Rotorcraft")
|
|
};
|
|
|
|
const QString ADSBDemodGUI::m_categorySetB[] = {
|
|
QStringLiteral("None"),
|
|
QStringLiteral("Glider/sailplane"),
|
|
QStringLiteral("Lighter-than-air"),
|
|
QStringLiteral("Parachutist"),
|
|
QStringLiteral("Ultralight"),
|
|
QStringLiteral("Reserved"),
|
|
QStringLiteral("UAV"),
|
|
QStringLiteral("Space vehicle")
|
|
};
|
|
|
|
const QString ADSBDemodGUI::m_categorySetC[] = {
|
|
QStringLiteral("None"),
|
|
QStringLiteral("Emergency vehicle"),
|
|
QStringLiteral("Service vehicle"),
|
|
QStringLiteral("Ground obstruction"),
|
|
QStringLiteral("Cluster obstacle"),
|
|
QStringLiteral("Line obstacle"),
|
|
QStringLiteral("Reserved"),
|
|
QStringLiteral("Reserved")
|
|
};
|
|
|
|
const QString ADSBDemodGUI::m_emergencyStatus[] = {
|
|
QStringLiteral("No emergency"),
|
|
QStringLiteral("General emergency"),
|
|
QStringLiteral("Lifeguard/Medical"),
|
|
QStringLiteral("Minimum fuel"),
|
|
QStringLiteral("No communications"),
|
|
QStringLiteral("Unlawful interference"),
|
|
QStringLiteral("Downed aircraft"),
|
|
QStringLiteral("Reserved")
|
|
};
|
|
|
|
const QString ADSBDemodGUI::m_flightStatuses[] = {
|
|
QStringLiteral("Airborne"),
|
|
QStringLiteral("On-ground"),
|
|
QStringLiteral("Alert, airborne"),
|
|
QStringLiteral("Alert, on-ground"),
|
|
QStringLiteral("Alert, SPI"),
|
|
QStringLiteral("SPI"),
|
|
QStringLiteral("Reserved"),
|
|
QStringLiteral("Not assigned")
|
|
};
|
|
|
|
const QString ADSBDemodGUI::m_hazardSeverity[] = {
|
|
"NIL", "Light", "Moderate", "Severe"
|
|
};
|
|
|
|
const QString ADSBDemodGUI::m_fomSources[] = {
|
|
"Invalid", "INS", "GNSS", "DME/DME", "DME/VOR", "Reserved", "Reserved", "Reserved", "Reserved", "Reserved", "Reserved", "Reserved", "Reserved", "Reserved", "Reserved", "Reserved"
|
|
};
|
|
|
|
ADSBDemodGUI* ADSBDemodGUI::create(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, BasebandSampleSink *rxChannel)
|
|
{
|
|
ADSBDemodGUI* gui = new ADSBDemodGUI(pluginAPI, deviceUISet, rxChannel);
|
|
return gui;
|
|
}
|
|
|
|
void ADSBDemodGUI::destroy()
|
|
{
|
|
delete this;
|
|
}
|
|
|
|
void ADSBDemodGUI::resetToDefaults()
|
|
{
|
|
m_settings.resetToDefaults();
|
|
displaySettings();
|
|
applySettings();
|
|
}
|
|
|
|
QByteArray ADSBDemodGUI::serialize() const
|
|
{
|
|
return m_settings.serialize();
|
|
}
|
|
|
|
bool ADSBDemodGUI::deserialize(const QByteArray& data)
|
|
{
|
|
if(m_settings.deserialize(data))
|
|
{
|
|
updateChannelList();
|
|
displaySettings();
|
|
applySettings(true);
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
resetToDefaults();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Longitude zone (returns value in range [1,59]
|
|
static int cprNL(double lat)
|
|
{
|
|
if (lat == 0.0)
|
|
{
|
|
return 59;
|
|
}
|
|
else if ((lat == 87.0) || (lat == -87.0))
|
|
{
|
|
return 2;
|
|
}
|
|
else if ((lat > 87.0) || (lat < -87.0))
|
|
{
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
double nz = 15.0;
|
|
double n = 1 - std::cos(M_PI / (2.0 * nz));
|
|
double d = std::cos(std::fabs(lat) * M_PI/180.0);
|
|
return std::floor((M_PI * 2.0) / std::acos(1.0 - (n/(d*d))));
|
|
}
|
|
}
|
|
|
|
static int cprN(double lat, int odd)
|
|
{
|
|
int nl = cprNL(lat) - odd;
|
|
if (nl > 1) {
|
|
return nl;
|
|
} else {
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
// Can't use std::fmod, as that works differently for negative numbers (See C.2.6.2)
|
|
static Real modulus(double x, double y)
|
|
{
|
|
return x - y * std::floor(x/y);
|
|
}
|
|
|
|
QString Aircraft::getImage() const
|
|
{
|
|
if (m_emitterCategory.length() > 0)
|
|
{
|
|
if (!m_emitterCategory.compare("Heavy")) {
|
|
return QString("aircraft_4engine.png"); // Can also be 777, 787
|
|
} else if (!m_emitterCategory.compare("Large")) {
|
|
return QString("aircraft_2engine.png");
|
|
} else if (!m_emitterCategory.compare("Small")) {
|
|
return QString("aircraft_2enginesmall.png");
|
|
} else if (!m_emitterCategory.compare("Rotorcraft")) {
|
|
return QString("aircraft_helicopter.png");
|
|
} else if (!m_emitterCategory.compare("High performance")) {
|
|
return QString("aircraft_fighter.png");
|
|
} else if (!m_emitterCategory.compare("Light")
|
|
|| !m_emitterCategory.compare("Ultralight")
|
|
|| !m_emitterCategory.compare("Glider/sailplane")) {
|
|
return QString("aircraft_light.png");
|
|
} else if (!m_emitterCategory.compare("Space vehicle")) {
|
|
return QString("aircraft_space.png");
|
|
} else if (!m_emitterCategory.compare("UAV")) {
|
|
return QString("aircraft_drone.png");
|
|
} else if (!m_emitterCategory.compare("Emergency vehicle")
|
|
|| !m_emitterCategory.compare("Service vehicle")) {
|
|
return QString("truck.png");
|
|
} else {
|
|
return QString("aircraft_2engine.png");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return QString("aircraft_2engine.png");
|
|
}
|
|
}
|
|
|
|
QString Aircraft::getText(const ADSBDemodSettings *settings, bool all) const
|
|
{
|
|
QStringList list;
|
|
if (m_showAll || all)
|
|
{
|
|
if (!m_flagIconURL.isEmpty() && !m_airlineIconURL.isEmpty())
|
|
{
|
|
list.append(QString("<table width=100%><tr><td><img src=%1><td><img src=%2 align=right></table>").arg(m_airlineIconURL).arg(m_flagIconURL));
|
|
}
|
|
else
|
|
{
|
|
if (!m_flagIconURL.isEmpty()) {
|
|
list.append(QString("<img src=%1>").arg(m_flagIconURL));
|
|
} else if (!m_airlineIconURL.isEmpty()) {
|
|
list.append(QString("<img src=%1>").arg(m_airlineIconURL));
|
|
}
|
|
}
|
|
list.append(QString("ICAO: %1").arg(m_icaoHex));
|
|
if (!m_callsign.isEmpty()) {
|
|
list.append(QString("Callsign: %1").arg(m_callsign));
|
|
}
|
|
QString atcCallsign = m_atcCallsignItem->text();
|
|
if (!atcCallsign.isEmpty()) {
|
|
list.append(QString("ATC Callsign: %1").arg(atcCallsign));
|
|
}
|
|
if (m_aircraftInfo != nullptr)
|
|
{
|
|
if (!m_aircraftInfo->m_model.isEmpty()) {
|
|
list.append(QString("Aircraft: %1").arg(m_aircraftInfo->m_model));
|
|
}
|
|
}
|
|
if (!m_emitterCategory.isEmpty()) {
|
|
list.append(QString("Category: %1").arg(m_emitterCategory));
|
|
}
|
|
if (m_altitudeValid)
|
|
{
|
|
if (m_onSurface)
|
|
{
|
|
list.append(QString("Altitude: Surface"));
|
|
}
|
|
else
|
|
{
|
|
QString reference = m_altitudeGNSS ? "GNSS" : "Baro";
|
|
if (m_gui->useSIUints()) {
|
|
list.append(QString("Altitude: %1 (m %2)").arg(Units::feetToIntegerMetres(m_altitude)).arg(reference));
|
|
} else {
|
|
list.append(QString("Altitude: %1 (ft %2)").arg(m_altitude).arg(reference));
|
|
}
|
|
}
|
|
}
|
|
if (m_groundspeedValid)
|
|
{
|
|
if (m_gui->useSIUints()) {
|
|
list.append(QString("GS: %1 (kph)").arg(Units::knotsToIntegerKPH(m_groundspeed)));
|
|
} else {
|
|
list.append(QString("GS: %1 (kn)").arg(m_groundspeed));
|
|
}
|
|
}
|
|
if (m_verticalRateValid)
|
|
{
|
|
QString desc;
|
|
Real rate;
|
|
QString units;
|
|
|
|
if (m_gui->useSIUints())
|
|
{
|
|
rate = Units::feetPerMinToIntegerMetresPerSecond(m_verticalRate);
|
|
units = QString("m/s");
|
|
}
|
|
else
|
|
{
|
|
rate = m_verticalRate;
|
|
units = QString("ft/min");
|
|
}
|
|
if (m_verticalRate == 0) {
|
|
desc = "Level flight";
|
|
} else if (rate > 0) {
|
|
desc = QString("Climbing: %1 (%2)").arg(rate).arg(units);
|
|
} else {
|
|
desc = QString("Descending: %1 (%2)").arg(rate).arg(units);
|
|
}
|
|
list.append(QString(desc));
|
|
}
|
|
if ((m_status.length() > 0) && m_status.compare("No emergency")) {
|
|
list.append(m_status);
|
|
}
|
|
|
|
QString flightStatus = m_flightStatusItem->text();
|
|
if (!flightStatus.isEmpty()) {
|
|
list.append(QString("Flight status: %1").arg(flightStatus));
|
|
}
|
|
QString dep = m_depItem->text();
|
|
if (!dep.isEmpty()) {
|
|
list.append(QString("Departed: %1").arg(dep));
|
|
}
|
|
QString std = m_stdItem->text();
|
|
if (!std.isEmpty()) {
|
|
list.append(QString("STD: %1").arg(std));
|
|
}
|
|
QString atd = m_atdItem->text();
|
|
if (!atd.isEmpty())
|
|
{
|
|
list.append(QString("ATD: %1").arg(atd));
|
|
}
|
|
else
|
|
{
|
|
QString etd = m_etdItem->text();
|
|
if (!etd.isEmpty()) {
|
|
list.append(QString("ETD: %1").arg(etd));
|
|
}
|
|
}
|
|
QString arr = m_arrItem->text();
|
|
if (!arr.isEmpty()) {
|
|
list.append(QString("Arrival: %1").arg(arr));
|
|
}
|
|
QString sta = m_staItem->text();
|
|
if (!sta.isEmpty()) {
|
|
list.append(QString("STA: %1").arg(sta));
|
|
}
|
|
QString ata = m_ataItem->text();
|
|
if (!ata.isEmpty())
|
|
{
|
|
list.append(QString("ATA: %1").arg(ata));
|
|
}
|
|
else
|
|
{
|
|
QString eta = m_etaItem->text();
|
|
if (!eta.isEmpty()) {
|
|
list.append(QString("ETA: %1").arg(eta));
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
list.append(getLabel(settings));
|
|
}
|
|
return list.join("<br>");
|
|
}
|
|
|
|
// See https://nats.aero/blog/2017/07/drone-disruption-gatwick/ for example of UK ATC display
|
|
QString Aircraft::getLabel(const ADSBDemodSettings *settings) const
|
|
{
|
|
QString id;
|
|
if (!m_callsign.isEmpty())
|
|
{
|
|
QString atcCallsign = m_atcCallsignItem->text();
|
|
if (settings->m_atcCallsigns && !atcCallsign.isEmpty()) {
|
|
id = QString("%1 %2").arg(atcCallsign).arg(m_callsign.mid(3));
|
|
} else {
|
|
id = m_callsign;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
id = m_icaoHex;
|
|
}
|
|
QStringList strings;
|
|
strings.append(id);
|
|
if (settings->m_atcLabels)
|
|
{
|
|
if (m_altitudeValid)
|
|
{
|
|
QStringList row1;
|
|
int transitionAlt = 6500;
|
|
QChar c = m_altitude >= settings->m_transitionAlt ? 'F' : 'A';
|
|
// Convert altitude to flight level
|
|
int fl = m_altitude / 100;
|
|
row1.append(QString("%1%2").arg(c).arg(fl));
|
|
// Indicate whether climbing or descending
|
|
if (m_verticalRateValid && ((m_verticalRate != 0) || (m_selAltitudeValid && (m_altitude != m_selAltitude))))
|
|
{
|
|
QChar dir = m_verticalRate == 0 ? QChar('-') : (m_verticalRate > 0 ? QChar(0x2191) : QChar(0x2193));
|
|
row1.append(dir);
|
|
}
|
|
if (m_selAltitudeValid && (m_altitude != m_selAltitude))
|
|
{
|
|
int selfl = m_selAltitude / 100;
|
|
row1.append(QString::number(selfl));
|
|
}
|
|
strings.append(row1.join(" "));
|
|
}
|
|
QStringList row2;
|
|
// Display speed
|
|
if (m_groundspeedValid) {
|
|
row2.append(QString("G%2").arg(m_groundspeed));
|
|
} else if (m_indicatedAirspeedValid) {
|
|
row2.append(QString("I%1").arg(m_indicatedAirspeed));
|
|
}
|
|
// Aircraft type
|
|
if (m_aircraftInfo && !m_aircraftInfo->m_model.isEmpty())
|
|
{
|
|
QString name = m_aircraftInfo->m_model;
|
|
int idx;
|
|
idx = name.indexOf(' ');
|
|
if (idx >= 0) {
|
|
name = name.left(idx);
|
|
}
|
|
idx = name.indexOf('-');
|
|
if (idx >= 0) {
|
|
name = name.left(idx);
|
|
}
|
|
row2.append(name);
|
|
}
|
|
strings.append(row2.join(" "));
|
|
// FIXME: Add ATC altitude and waypoint from ATC feature
|
|
}
|
|
return strings.join("<br>");
|
|
}
|
|
|
|
QVariant AircraftModel::data(const QModelIndex &index, int role) const
|
|
{
|
|
int row = index.row();
|
|
if ((row < 0) || (row >= m_aircrafts.count()))
|
|
return QVariant();
|
|
if (role == AircraftModel::positionRole)
|
|
{
|
|
// Coordinates to display the aircraft icon at
|
|
QGeoCoordinate coords;
|
|
coords.setLatitude(m_aircrafts[row]->m_latitude);
|
|
coords.setLongitude(m_aircrafts[row]->m_longitude);
|
|
coords.setAltitude(Units::feetToMetres(m_aircrafts[row]->m_altitude));
|
|
return QVariant::fromValue(coords);
|
|
}
|
|
else if (role == AircraftModel::headingRole)
|
|
{
|
|
// What rotation to draw the aircraft icon at
|
|
return QVariant::fromValue(m_aircrafts[row]->m_heading);
|
|
}
|
|
else if (role == AircraftModel::adsbDataRole)
|
|
{
|
|
// Create the text to go in the bubble next to the aircraft
|
|
return QVariant::fromValue(m_aircrafts[row]->getText(m_settings));
|
|
}
|
|
else if (role == AircraftModel::aircraftImageRole)
|
|
{
|
|
// Select an image to use for the aircraft
|
|
return QVariant::fromValue(m_aircrafts[row]->getImage());
|
|
}
|
|
else if (role == AircraftModel::bubbleColourRole)
|
|
{
|
|
// Select a background colour for the text bubble next to the aircraft
|
|
if (m_aircrafts[row]->m_isTarget)
|
|
return QVariant::fromValue(QColor("lightgreen"));
|
|
else if (m_aircrafts[row]->m_isHighlighted)
|
|
return QVariant::fromValue(QColor("orange"));
|
|
else if ((m_aircrafts[row]->m_status.length() > 0) && m_aircrafts[row]->m_status.compare("No emergency"))
|
|
return QVariant::fromValue(QColor("lightred"));
|
|
else
|
|
return QVariant::fromValue(QColor("lightblue"));
|
|
}
|
|
else if (role == AircraftModel::aircraftPathRole)
|
|
{
|
|
if ((m_flightPaths && m_aircrafts[row]->m_isHighlighted) || m_allFlightPaths)
|
|
{
|
|
return m_aircrafts[row]->m_coordinates;
|
|
}
|
|
else if (m_settings->m_atcLabels)
|
|
{
|
|
// Display last 20 seconds of coordinates
|
|
QDateTime cutoff = QDateTime::currentDateTime().addSecs(-20);
|
|
QVariantList coordinates;
|
|
for (int i = m_aircrafts[row]->m_coordinateDateTimes.size() - 1; i >= 0; i--)
|
|
{
|
|
if (m_aircrafts[row]->m_coordinateDateTimes[i] < cutoff) {
|
|
break;
|
|
}
|
|
coordinates.push_front(m_aircrafts[row]->m_coordinates[i]);
|
|
}
|
|
return coordinates;
|
|
}
|
|
else
|
|
{
|
|
return QVariantList();
|
|
}
|
|
}
|
|
else if (role == AircraftModel::showAllRole)
|
|
return QVariant::fromValue(m_aircrafts[row]->m_showAll);
|
|
else if (role == AircraftModel::highlightedRole)
|
|
return QVariant::fromValue(m_aircrafts[row]->m_isHighlighted);
|
|
else if (role == AircraftModel::targetRole)
|
|
return QVariant::fromValue(m_aircrafts[row]->m_isTarget);
|
|
return QVariant();
|
|
}
|
|
|
|
bool AircraftModel::setData(const QModelIndex &index, const QVariant& value, int role)
|
|
{
|
|
int row = index.row();
|
|
if ((row < 0) || (row >= m_aircrafts.count()))
|
|
return false;
|
|
if (role == AircraftModel::showAllRole)
|
|
{
|
|
bool showAll = value.toBool();
|
|
if (showAll != m_aircrafts[row]->m_showAll)
|
|
{
|
|
m_aircrafts[row]->m_showAll = showAll;
|
|
emit dataChanged(index, index);
|
|
}
|
|
return true;
|
|
}
|
|
else if (role == AircraftModel::highlightedRole)
|
|
{
|
|
bool highlight = value.toBool();
|
|
if (highlight != m_aircrafts[row]->m_isHighlighted)
|
|
{
|
|
m_aircrafts[row]->m_gui->highlightAircraft(m_aircrafts[row]);
|
|
emit dataChanged(index, index);
|
|
}
|
|
return true;
|
|
}
|
|
else if (role == AircraftModel::targetRole)
|
|
{
|
|
bool target = value.toBool();
|
|
if (target != m_aircrafts[row]->m_isTarget)
|
|
{
|
|
m_aircrafts[row]->m_gui->targetAircraft(m_aircrafts[row]);
|
|
emit dataChanged(index, index);
|
|
}
|
|
return true;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void AircraftModel::findOnMap(int index)
|
|
{
|
|
if ((index < 0) || (index >= m_aircrafts.count())) {
|
|
return;
|
|
}
|
|
FeatureWebAPIUtils::mapFind(m_aircrafts[index]->m_icaoHex);
|
|
}
|
|
|
|
// Get list of frequeny scanners to use in menu
|
|
QStringList AirportModel::getFreqScanners() const
|
|
{
|
|
QStringList list;
|
|
std::vector<ChannelAPI*> channels = MainCore::instance()->getChannels("sdrangel.channel.freqscanner");
|
|
for (const auto channel : channels) {
|
|
list.append(QString("R%1:%2").arg(channel->getDeviceSetIndex()).arg(channel->getIndexInDeviceSet()));
|
|
}
|
|
return list;
|
|
}
|
|
|
|
// Send airport frequencies to frequency scanner with given id (Rn:n)
|
|
void AirportModel::sendToFreqScanner(int index, const QString& id)
|
|
{
|
|
if ((index < 0) || (index >= m_airports.count())) {
|
|
return;
|
|
}
|
|
const AirportInformation *airport = m_airports[index];
|
|
|
|
const QRegularExpression re("R([0-9]+):([0-9]+)");
|
|
QRegularExpressionMatch match = re.match(id);
|
|
if (match.hasMatch())
|
|
{
|
|
int deviceSet = match.capturedTexts()[1].toInt();
|
|
int channelIndex = match.capturedTexts()[2].toInt();
|
|
|
|
QJsonArray array;
|
|
for (const auto airportFrequency : airport->m_frequencies)
|
|
{
|
|
QJsonObject obj;
|
|
QJsonValue frequency(airportFrequency->m_frequency * 1000000);
|
|
QJsonValue enabled(1); // true doesn't work
|
|
QJsonValue notes(QString("%1 %2").arg(airport->m_ident).arg(airportFrequency->m_description));
|
|
obj.insert("frequency", frequency);
|
|
obj.insert("enabled", enabled);
|
|
obj.insert("notes", notes);
|
|
QJsonValue value(obj);
|
|
array.append(value);
|
|
}
|
|
ChannelWebAPIUtils::patchChannelSetting(deviceSet, channelIndex, "frequencies", array);
|
|
}
|
|
else
|
|
{
|
|
qDebug() << "AirportModel::sendToFreqScanner: Malformed id: " << id;
|
|
}
|
|
}
|
|
|
|
QVariant AirportModel::data(const QModelIndex &index, int role) const
|
|
{
|
|
int row = index.row();
|
|
if ((row < 0) || (row >= m_airports.count()))
|
|
return QVariant();
|
|
if (role == AirportModel::positionRole)
|
|
{
|
|
// Coordinates to display the airport icon at
|
|
QGeoCoordinate coords;
|
|
coords.setLatitude(m_airports[row]->m_latitude);
|
|
coords.setLongitude(m_airports[row]->m_longitude);
|
|
coords.setAltitude(Units::feetToMetres(m_airports[row]->m_elevation));
|
|
return QVariant::fromValue(coords);
|
|
}
|
|
else if (role == AirportModel::airportDataRole)
|
|
{
|
|
if (m_showFreq[row])
|
|
{
|
|
QString text = m_airportDataFreq[row];
|
|
if (!m_metar[row].isEmpty()) {
|
|
text = text + "\n" + m_metar[row];
|
|
}
|
|
return QVariant::fromValue(text);
|
|
}
|
|
else
|
|
return QVariant::fromValue(m_airports[row]->m_ident);
|
|
}
|
|
else if (role == AirportModel::airportDataRowsRole)
|
|
{
|
|
if (m_showFreq[row])
|
|
{
|
|
int rows = m_airportDataFreqRows[row];
|
|
if (!m_metar[row].isEmpty()) {
|
|
rows += 1 + m_metar[row].count("\n");
|
|
}
|
|
return QVariant::fromValue(rows);
|
|
}
|
|
else
|
|
return 1;
|
|
}
|
|
else if (role == AirportModel::airportImageRole)
|
|
{
|
|
// Select an image to use for the airport
|
|
return QVariant::fromValue(m_airports[row]->getImageName());
|
|
}
|
|
else if (role == AirportModel::bubbleColourRole)
|
|
{
|
|
// Select a background colour for the text bubble next to the airport
|
|
return QVariant::fromValue(QColor("lightyellow"));
|
|
}
|
|
else if (role == AirportModel::showFreqRole)
|
|
{
|
|
return QVariant::fromValue(m_showFreq[row]);
|
|
}
|
|
return QVariant();
|
|
}
|
|
|
|
bool AirportModel::setData(const QModelIndex &index, const QVariant& value, int role)
|
|
{
|
|
int row = index.row();
|
|
if ((row < 0) || (row >= m_airports.count()))
|
|
return false;
|
|
if (role == AirportModel::showFreqRole)
|
|
{
|
|
bool showFreq = value.toBool();
|
|
if (showFreq != m_showFreq[row])
|
|
{
|
|
m_showFreq[row] = showFreq;
|
|
emit dataChanged(index, index);
|
|
if (showFreq) {
|
|
emit requestMetar(m_airports[row]->m_ident);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
else if (role == AirportModel::selectedFreqRole)
|
|
{
|
|
int idx = value.toInt();
|
|
if ((idx >= 0) && (idx < m_airports[row]->m_frequencies.size()))
|
|
{
|
|
// Do in two steps to avoid rounding errors
|
|
qint64 freqkHz = (qint64) std::round(m_airports[row]->m_frequencies[idx]->m_frequency*1000.0);
|
|
qint64 freqHz = freqkHz * 1000;
|
|
m_gui->setFrequency(freqHz);
|
|
}
|
|
else if (idx == m_airports[row]->m_frequencies.size())
|
|
{
|
|
// Set airport as target
|
|
m_gui->target(m_airports[row]->m_name, m_azimuth[row], m_elevation[row], m_range[row]);
|
|
emit dataChanged(index, index);
|
|
}
|
|
return true;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
QVariant AirspaceModel::data(const QModelIndex &index, int role) const
|
|
{
|
|
int row = index.row();
|
|
if ((row < 0) || (row >= m_airspaces.count())) {
|
|
return QVariant();
|
|
}
|
|
if (role == AirspaceModel::nameRole)
|
|
{
|
|
// Airspace name
|
|
return QVariant::fromValue(m_airspaces[row]->m_name);
|
|
}
|
|
else if (role == AirspaceModel::detailsRole)
|
|
{
|
|
// Airspace name and altitudes
|
|
QString details;
|
|
details.append(m_airspaces[row]->m_name);
|
|
details.append(QString("\n%1 - %2")
|
|
.arg(m_airspaces[row]->getAlt(&m_airspaces[row]->m_bottom))
|
|
.arg(m_airspaces[row]->getAlt(&m_airspaces[row]->m_top)));
|
|
return QVariant::fromValue(details);
|
|
}
|
|
else if (role == AirspaceModel::positionRole)
|
|
{
|
|
// Coordinates to display the airspace name at
|
|
QGeoCoordinate coords;
|
|
coords.setLatitude(m_airspaces[row]->m_position.y());
|
|
coords.setLongitude(m_airspaces[row]->m_position.x());
|
|
coords.setAltitude(m_airspaces[row]->topHeightInMetres());
|
|
return QVariant::fromValue(coords);
|
|
}
|
|
else if (role == AirspaceModel::airspaceBorderColorRole)
|
|
{
|
|
if ((m_airspaces[row]->m_category == "D")
|
|
|| (m_airspaces[row]->m_category == "G")
|
|
|| (m_airspaces[row]->m_category == "CTR")) {
|
|
return QVariant::fromValue(QColor(0x00, 0x00, 0xff, 0x00));
|
|
} else {
|
|
return QVariant::fromValue(QColor(0xff, 0x00, 0x00, 0x00));
|
|
}
|
|
}
|
|
else if (role == AirspaceModel::airspaceFillColorRole)
|
|
{
|
|
if ((m_airspaces[row]->m_category == "D")
|
|
|| (m_airspaces[row]->m_category == "G")
|
|
|| (m_airspaces[row]->m_category == "CTR")) {
|
|
return QVariant::fromValue(QColor(0x00, 0x00, 0xff, 0x10));
|
|
} else {
|
|
return QVariant::fromValue(QColor(0xff, 0x00, 0x00, 0x10));
|
|
}
|
|
}
|
|
else if (role == AirspaceModel::airspacePolygonRole)
|
|
{
|
|
return m_polygons[row];
|
|
}
|
|
return QVariant();
|
|
}
|
|
|
|
bool AirspaceModel::setData(const QModelIndex &index, const QVariant& value, int role)
|
|
{
|
|
(void) value;
|
|
(void) role;
|
|
|
|
int row = index.row();
|
|
if ((row < 0) || (row >= m_airspaces.count())) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
QVariant NavAidModel::data(const QModelIndex &index, int role) const
|
|
{
|
|
int row = index.row();
|
|
if ((row < 0) || (row >= m_navAids.count())) {
|
|
return QVariant();
|
|
}
|
|
if (role == NavAidModel::positionRole)
|
|
{
|
|
// Coordinates to display the VOR icon at
|
|
QGeoCoordinate coords;
|
|
coords.setLatitude(m_navAids[row]->m_latitude);
|
|
coords.setLongitude(m_navAids[row]->m_longitude);
|
|
coords.setAltitude(Units::feetToMetres(m_navAids[row]->m_elevation));
|
|
return QVariant::fromValue(coords);
|
|
}
|
|
else if (role == NavAidModel::navAidDataRole)
|
|
{
|
|
// Create the text to go in the bubble next to the VOR
|
|
if (m_selected[row])
|
|
{
|
|
QStringList list;
|
|
list.append(QString("Name: %1").arg(m_navAids[row]->m_name));
|
|
if (m_navAids[row]->m_type == "NDB") {
|
|
list.append(QString("Frequency: %1 kHz").arg(m_navAids[row]->m_frequencykHz, 0, 'f', 1));
|
|
} else {
|
|
list.append(QString("Frequency: %1 MHz").arg(m_navAids[row]->m_frequencykHz / 1000.0f, 0, 'f', 2));
|
|
}
|
|
if (m_navAids[row]->m_channel != "") {
|
|
list.append(QString("Channel: %1").arg(m_navAids[row]->m_channel));
|
|
}
|
|
list.append(QString("Ident: %1 %2").arg(m_navAids[row]->m_ident).arg(Morse::toSpacedUnicodeMorse(m_navAids[row]->m_ident)));
|
|
list.append(QString("Range: %1 nm").arg(m_navAids[row]->m_range));
|
|
if (m_navAids[row]->m_alignedTrueNorth) {
|
|
list.append(QString("Magnetic declination: Aligned to true North"));
|
|
} else if (m_navAids[row]->m_magneticDeclination != 0.0f) {
|
|
list.append(QString("Magnetic declination: %1%2").arg(std::round(m_navAids[row]->m_magneticDeclination)).arg(QChar(0x00b0)));
|
|
}
|
|
QString data = list.join("\n");
|
|
return QVariant::fromValue(data);
|
|
}
|
|
else
|
|
{
|
|
return QVariant::fromValue(m_navAids[row]->m_name);
|
|
}
|
|
}
|
|
else if (role == NavAidModel::navAidImageRole)
|
|
{
|
|
// Select an image to use for the NavAid
|
|
return QVariant::fromValue(QString("%1.png").arg(m_navAids[row]->m_type));
|
|
}
|
|
else if (role == NavAidModel::bubbleColourRole)
|
|
{
|
|
// Select a background colour for the text bubble next to the NavAid
|
|
return QVariant::fromValue(QColor("lightgreen"));
|
|
}
|
|
else if (role == NavAidModel::selectedRole)
|
|
{
|
|
return QVariant::fromValue(m_selected[row]);
|
|
}
|
|
return QVariant();
|
|
}
|
|
|
|
bool NavAidModel::setData(const QModelIndex &index, const QVariant& value, int role)
|
|
{
|
|
int row = index.row();
|
|
if ((row < 0) || (row >= m_navAids.count())) {
|
|
return false;
|
|
}
|
|
if (role == NavAidModel::selectedRole)
|
|
{
|
|
bool selected = value.toBool();
|
|
m_selected[row] = selected;
|
|
emit dataChanged(index, index);
|
|
return true;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Set selected AM Demod to the given frequency (used to tune to ATC selected from airports on map)
|
|
bool ADSBDemodGUI::setFrequency(qint64 targetFrequencyHz)
|
|
{
|
|
const QRegularExpression re("R([0-9]+):([0-9]+)");
|
|
QRegularExpressionMatch match = re.match(m_settings.m_amDemod);
|
|
if (match.hasMatch())
|
|
{
|
|
int deviceSet = match.capturedTexts()[1].toInt();
|
|
int channelIndex = match.capturedTexts()[2].toInt();
|
|
const int halfChannelBW = 20000/2;
|
|
int dcOffset = halfChannelBW;
|
|
|
|
double centerFrequency;
|
|
int sampleRate;
|
|
|
|
if (ChannelWebAPIUtils::getCenterFrequency(deviceSet, centerFrequency))
|
|
{
|
|
if (ChannelWebAPIUtils::getDevSampleRate(deviceSet, sampleRate))
|
|
{
|
|
sampleRate *= 0.75; // Don't use guard bands
|
|
|
|
// Adjust device center frequency if not in range
|
|
if ( ((targetFrequencyHz - halfChannelBW) < (centerFrequency - sampleRate / 2))
|
|
|| ((targetFrequencyHz + halfChannelBW) >= (centerFrequency + sampleRate / 2))
|
|
)
|
|
{
|
|
ChannelWebAPIUtils::setCenterFrequency(deviceSet, targetFrequencyHz - dcOffset);
|
|
ChannelWebAPIUtils::setFrequencyOffset(deviceSet, channelIndex, dcOffset);
|
|
}
|
|
else
|
|
{
|
|
qint64 offset = targetFrequencyHz - centerFrequency;
|
|
// Also adjust center frequency if channel would cross DC
|
|
if (std::abs(offset) < halfChannelBW)
|
|
{
|
|
ChannelWebAPIUtils::setCenterFrequency(deviceSet, targetFrequencyHz - dcOffset);
|
|
ChannelWebAPIUtils::setFrequencyOffset(deviceSet, channelIndex, dcOffset);
|
|
}
|
|
else
|
|
{
|
|
// Just tune channel
|
|
ChannelWebAPIUtils::setFrequencyOffset(deviceSet, channelIndex, offset);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Called when we have both lat & long
|
|
void ADSBDemodGUI::updatePosition(Aircraft *aircraft)
|
|
{
|
|
if (!aircraft->m_positionValid)
|
|
{
|
|
aircraft->m_positionValid = true;
|
|
// Now we have a position, add a plane to the map
|
|
QGeoCoordinate coords;
|
|
coords.setLatitude(aircraft->m_latitude);
|
|
coords.setLongitude(aircraft->m_longitude);
|
|
m_aircraftModel.addAircraft(aircraft);
|
|
}
|
|
// Calculate range, azimuth and elevation to aircraft from station
|
|
m_azEl.setTarget(aircraft->m_latitude, aircraft->m_longitude, Units::feetToMetres(aircraft->m_altitude));
|
|
m_azEl.calculate();
|
|
aircraft->m_range = m_azEl.getDistance();
|
|
aircraft->m_azimuth = m_azEl.getAzimuth();
|
|
aircraft->m_elevation = m_azEl.getElevation();
|
|
aircraft->m_rangeItem->setText(QString::number(aircraft->m_range/1000.0, 'f', 1));
|
|
aircraft->m_azElItem->setText(QString("%1/%2").arg(std::round(aircraft->m_azimuth)).arg(std::round(aircraft->m_elevation)));
|
|
if (aircraft == m_trackAircraft) {
|
|
m_adsbDemod->setTarget(aircraft->targetName(), aircraft->m_azimuth, aircraft->m_elevation, aircraft->m_range);
|
|
}
|
|
}
|
|
|
|
// Called when we have lat & long from local decode and we need to check if it is in a valid range (<180nm/333km)
|
|
// or 1/4 of that for surface positions
|
|
bool ADSBDemodGUI::updateLocalPosition(Aircraft *aircraft, double latitude, double longitude, bool surfacePosition)
|
|
{
|
|
// Calculate range to aircraft from station
|
|
m_azEl.setTarget(latitude, longitude, Units::feetToMetres(aircraft->m_altitude));
|
|
m_azEl.calculate();
|
|
|
|
// Don't use the full 333km, as there may be some error in station position
|
|
if (m_azEl.getDistance() < (surfacePosition ? 80000 : 320000))
|
|
{
|
|
aircraft->m_latitude = latitude;
|
|
aircraft->m_longitude = longitude;
|
|
updatePosition(aircraft);
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
//qDebug() << "Local position out of range - calculated distance: " << m_azEl.getDistance();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void ADSBDemodGUI::clearFromMap(const QString& name)
|
|
{
|
|
QList<ObjectPipe*> mapPipes;
|
|
MainCore::instance()->getMessagePipes().getMessagePipes(m_adsbDemod, "mapitems", mapPipes);
|
|
|
|
for (const auto& pipe : mapPipes)
|
|
{
|
|
MessageQueue *messageQueue = qobject_cast<MessageQueue*>(pipe->m_element);
|
|
SWGSDRangel::SWGMapItem *swgMapItem = new SWGSDRangel::SWGMapItem();
|
|
swgMapItem->setName(new QString(name));
|
|
swgMapItem->setImage(new QString(""));
|
|
MainCore::MsgMapItem *msg = MainCore::MsgMapItem::create(m_adsbDemod, swgMapItem);
|
|
messageQueue->push(msg);
|
|
}
|
|
}
|
|
|
|
void ADSBDemodGUI::sendToMap(Aircraft *aircraft, QList<SWGSDRangel::SWGMapAnimation *> *animations)
|
|
{
|
|
// Send to Map feature
|
|
QList<ObjectPipe*> mapPipes;
|
|
MainCore::instance()->getMessagePipes().getMessagePipes(m_adsbDemod, "mapitems", mapPipes);
|
|
|
|
if (mapPipes.size() > 0)
|
|
{
|
|
// Adjust altitude by airfield barometric elevation, so aircraft appears to
|
|
// take-off/land at correct point on runway
|
|
int altitudeFt = aircraft->m_altitude;
|
|
|
|
if (!aircraft->m_onSurface && !aircraft->m_altitudeGNSS) {
|
|
altitudeFt -= m_settings.m_airfieldElevation;
|
|
}
|
|
|
|
float altitudeM = Units::feetToMetres(altitudeFt);
|
|
|
|
for (const auto& pipe : mapPipes)
|
|
{
|
|
MessageQueue *messageQueue = qobject_cast<MessageQueue*>(pipe->m_element);
|
|
SWGSDRangel::SWGMapItem *swgMapItem = new SWGSDRangel::SWGMapItem();
|
|
swgMapItem->setName(new QString(aircraft->m_icaoHex));
|
|
swgMapItem->setLatitude(aircraft->m_latitude);
|
|
swgMapItem->setLongitude(aircraft->m_longitude);
|
|
swgMapItem->setAltitude(altitudeM);
|
|
swgMapItem->setPositionDateTime(new QString(aircraft->m_positionDateTime.toString(Qt::ISODateWithMs)));
|
|
swgMapItem->setFixedPosition(false);
|
|
swgMapItem->setAvailableUntil(new QString(aircraft->m_positionDateTime.addSecs(60).toString(Qt::ISODateWithMs)));
|
|
swgMapItem->setImage(new QString(QString("qrc:///map/%1").arg(aircraft->getImage())));
|
|
swgMapItem->setImageRotation(aircraft->m_heading);
|
|
swgMapItem->setText(new QString(aircraft->getText(&m_settings, true)));
|
|
|
|
if (!aircraft->m_aircraft3DModel.isEmpty()) {
|
|
swgMapItem->setModel(new QString(aircraft->m_aircraft3DModel));
|
|
} else {
|
|
swgMapItem->setModel(new QString(aircraft->m_aircraftCat3DModel));
|
|
}
|
|
|
|
swgMapItem->setLabel(new QString(aircraft->getLabel(&m_settings)));
|
|
|
|
if (aircraft->m_headingValid)
|
|
{
|
|
swgMapItem->setOrientation(1);
|
|
swgMapItem->setHeading(aircraft->m_heading);
|
|
swgMapItem->setPitch(aircraft->m_pitchEst);
|
|
swgMapItem->setRoll(aircraft->m_rollEst);
|
|
swgMapItem->setOrientationDateTime(new QString(aircraft->m_positionDateTime.toString(Qt::ISODateWithMs)));
|
|
}
|
|
else
|
|
{
|
|
// Orient aircraft based on velocity calculated from position
|
|
swgMapItem->setOrientation(0);
|
|
}
|
|
|
|
swgMapItem->setModelAltitudeOffset(aircraft->m_modelAltitudeOffset);
|
|
swgMapItem->setLabelAltitudeOffset(aircraft->m_labelAltitudeOffset);
|
|
swgMapItem->setAltitudeReference(3); // CLIP_TO_GROUND so aircraft don't go under runway
|
|
swgMapItem->setAnimations(animations); // Does this need to be duplicated?
|
|
|
|
MainCore::MsgMapItem *msg = MainCore::MsgMapItem::create(m_adsbDemod, swgMapItem);
|
|
messageQueue->push(msg);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Find aircraft with icao, or create if it doesn't exist
|
|
Aircraft *ADSBDemodGUI::getAircraft(int icao, bool &newAircraft)
|
|
{
|
|
Aircraft *aircraft;
|
|
|
|
if (m_aircraft.contains(icao))
|
|
{
|
|
// Update existing aircraft info
|
|
aircraft = m_aircraft.value(icao);
|
|
}
|
|
else
|
|
{
|
|
// Add new aircraft
|
|
newAircraft = true;
|
|
aircraft = new Aircraft(this);
|
|
aircraft->m_icao = icao;
|
|
aircraft->m_icaoHex = QString::number(aircraft->m_icao, 16);
|
|
m_aircraft.insert(icao, aircraft);
|
|
aircraft->m_icaoItem->setText(aircraft->m_icaoHex);
|
|
ui->adsbData->setSortingEnabled(false);
|
|
int row = ui->adsbData->rowCount();
|
|
ui->adsbData->setRowCount(row + 1);
|
|
ui->adsbData->setItem(row, ADSB_COL_ICAO, aircraft->m_icaoItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_ATC_CALLSIGN, aircraft->m_atcCallsignItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_CALLSIGN, aircraft->m_callsignItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_MODEL, aircraft->m_modelItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_AIRLINE, aircraft->m_airlineItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_ALTITUDE, aircraft->m_altitudeItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_HEADING, aircraft->m_headingItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_VERTICALRATE, aircraft->m_verticalRateItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_RANGE, aircraft->m_rangeItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_AZEL, aircraft->m_azElItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_LATITUDE, aircraft->m_latitudeItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_LONGITUDE, aircraft->m_longitudeItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_CATEGORY, aircraft->m_emitterCategoryItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_STATUS, aircraft->m_statusItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_SQUAWK, aircraft->m_squawkItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_REGISTRATION, aircraft->m_registrationItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_COUNTRY, aircraft->m_countryItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_REGISTERED, aircraft->m_registeredItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_MANUFACTURER, aircraft->m_manufacturerNameItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_OWNER, aircraft->m_ownerItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_OPERATOR_ICAO, aircraft->m_operatorICAOItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_TIME, aircraft->m_timeItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_FRAMECOUNT, aircraft->m_adsbFrameCountItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_CORRELATION, aircraft->m_correlationItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_RSSI, aircraft->m_rssiItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_FLIGHT_STATUS, aircraft->m_flightStatusItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_DEP, aircraft->m_depItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_ARR, aircraft->m_arrItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_STD, aircraft->m_stdItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_ETD, aircraft->m_etdItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_ATD, aircraft->m_atdItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_STA, aircraft->m_staItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_ETA, aircraft->m_etaItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_ATA, aircraft->m_ataItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_SEL_ALTITUDE, aircraft->m_selAltitudeItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_SEL_HEADING, aircraft->m_selHeadingItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_BARO, aircraft->m_baroItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_AP, aircraft->m_apItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_V_MODE, aircraft->m_vModeItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_L_MODE, aircraft->m_lModeItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_ROLL, aircraft->m_rollItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_GROUND_SPEED, aircraft->m_groundspeedItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_TURNRATE, aircraft->m_turnRateItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_TRUE_AIRSPEED, aircraft->m_trueAirspeedItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_INDICATED_AIRSPEED, aircraft->m_indicatedAirspeedItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_MACH, aircraft->m_machItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_HEADWIND, aircraft->m_headwindItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_EST_AIR_TEMP, aircraft->m_estAirTempItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_WIND_SPEED, aircraft->m_windSpeedItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_WIND_DIR, aircraft->m_windDirItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_STATIC_PRESSURE, aircraft->m_staticPressureItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_STATIC_AIR_TEMP, aircraft->m_staticAirTempItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_HUMIDITY, aircraft->m_humidityItem);
|
|
ui->adsbData->setItem(row, ADSB_COL_TIS_B, aircraft->m_tisBItem);
|
|
// Look aircraft up in database
|
|
if (m_aircraftInfo != nullptr)
|
|
{
|
|
if (m_aircraftInfo->contains(icao))
|
|
{
|
|
aircraft->m_aircraftInfo = m_aircraftInfo->value(icao);
|
|
aircraft->m_modelItem->setText(aircraft->m_aircraftInfo->m_model);
|
|
aircraft->m_registrationItem->setText(aircraft->m_aircraftInfo->m_registration);
|
|
aircraft->m_manufacturerNameItem->setText(aircraft->m_aircraftInfo->m_manufacturerName);
|
|
aircraft->m_ownerItem->setText(aircraft->m_aircraftInfo->m_owner);
|
|
aircraft->m_operatorICAOItem->setText(aircraft->m_aircraftInfo->m_operatorICAO);
|
|
aircraft->m_registeredItem->setText(aircraft->m_aircraftInfo->m_registered);
|
|
// Try loading an airline logo based on operator ICAO
|
|
QIcon *icon = nullptr;
|
|
if (aircraft->m_aircraftInfo->m_operatorICAO.size() > 0)
|
|
{
|
|
aircraft->m_airlineIconURL = AircraftInformation::getFlagIconURL(aircraft->m_aircraftInfo->m_operatorICAO);
|
|
icon = AircraftInformation::getAirlineIcon(aircraft->m_aircraftInfo->m_operatorICAO);
|
|
if (icon != nullptr)
|
|
{
|
|
aircraft->m_airlineItem->setSizeHint(QSize(85, 20));
|
|
aircraft->m_airlineItem->setIcon(*icon);
|
|
}
|
|
}
|
|
if (icon == nullptr)
|
|
{
|
|
if (aircraft->m_aircraftInfo->m_operator.size() > 0)
|
|
aircraft->m_airlineItem->setText(aircraft->m_aircraftInfo->m_operator);
|
|
else
|
|
aircraft->m_airlineItem->setText(aircraft->m_aircraftInfo->m_owner);
|
|
}
|
|
// Try loading a flag based on registration
|
|
if (aircraft->m_aircraftInfo->m_registration.size() > 0)
|
|
{
|
|
QString flag = aircraft->m_aircraftInfo->getFlag();
|
|
if (flag != "")
|
|
{
|
|
aircraft->m_flagIconURL = AircraftInformation::getFlagIconPath(flag);
|
|
if (aircraft->m_flagIconURL.startsWith(':')) {
|
|
aircraft->m_flagIconURL = "qrc://" + aircraft->m_flagIconURL.mid(1);
|
|
}
|
|
icon = AircraftInformation::getFlagIcon(flag);
|
|
if (icon != nullptr)
|
|
{
|
|
aircraft->m_countryItem->setSizeHint(QSize(40, 20));
|
|
aircraft->m_countryItem->setIcon(*icon);
|
|
}
|
|
}
|
|
}
|
|
get3DModel(aircraft);
|
|
}
|
|
}
|
|
|
|
if (aircraft->m_aircraft3DModel.isEmpty())
|
|
{
|
|
// Default to A320 until we get some more info
|
|
aircraft->m_aircraftCat3DModel = get3DModel("A320");
|
|
if (m_modelAltitudeOffset.contains("A320"))
|
|
{
|
|
aircraft->m_modelAltitudeOffset = m_modelAltitudeOffset.value("A320");
|
|
aircraft->m_labelAltitudeOffset = m_labelAltitudeOffset.value("A320");
|
|
}
|
|
}
|
|
|
|
if (!m_loadingData)
|
|
{
|
|
if (m_settings.m_autoResizeTableColumns)
|
|
ui->adsbData->resizeColumnsToContents();
|
|
ui->adsbData->setSortingEnabled(true);
|
|
}
|
|
// Check to see if we need to emit a notification about this new aircraft
|
|
checkStaticNotification(aircraft);
|
|
}
|
|
|
|
return aircraft;
|
|
}
|
|
|
|
void ADSBDemodGUI::atcCallsign(Aircraft *aircraft)
|
|
{
|
|
QString icao = aircraft->m_callsign.left(3);
|
|
const Airline *airline = Airline::getByICAO(icao);
|
|
if (airline)
|
|
{
|
|
aircraft->m_atcCallsignItem->setText(airline->m_callsign);
|
|
// Create icons using data from Airline class, if it doesn't exist in database
|
|
if (!aircraft->m_aircraftInfo)
|
|
{
|
|
// Airline logo
|
|
QIcon *icon = nullptr;
|
|
aircraft->m_airlineIconURL = AircraftInformation::getFlagIconURL(airline->m_icao);
|
|
icon = AircraftInformation::getAirlineIcon(airline->m_icao);
|
|
if (icon != nullptr)
|
|
{
|
|
aircraft->m_airlineItem->setSizeHint(QSize(85, 20));
|
|
aircraft->m_airlineItem->setIcon(*icon);
|
|
}
|
|
else
|
|
{
|
|
aircraft->m_airlineItem->setText(airline->m_name);
|
|
}
|
|
// Flag
|
|
QString flag = airline->m_country.toLower().replace(" ", "_");
|
|
aircraft->m_flagIconURL = AircraftInformation::getFlagIconPath(flag);
|
|
if (aircraft->m_flagIconURL.startsWith(':')) {
|
|
aircraft->m_flagIconURL = "qrc://" + aircraft->m_flagIconURL.mid(1);
|
|
}
|
|
icon = AircraftInformation::getFlagIcon(flag);
|
|
if (icon != nullptr)
|
|
{
|
|
aircraft->m_countryItem->setSizeHint(QSize(40, 20));
|
|
aircraft->m_countryItem->setIcon(*icon);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Try to map callsign to flight number
|
|
void ADSBDemodGUI::callsignToFlight(Aircraft *aircraft)
|
|
{
|
|
if (!aircraft->m_callsign.isEmpty())
|
|
{
|
|
QRegularExpression flightNoExp("^[A-Z]{2,3}[0-9]{1,4}$");
|
|
// Airlines line BA add a single charater suffix that can be stripped
|
|
// If the suffix is two characters, then it typically means a digit
|
|
// has been replaced which I don't know how to guess
|
|
// E.g Easyjet might use callsign EZY67JQ for flight EZY6267
|
|
// BA use BAW90BG for BA890
|
|
QRegularExpression suffixedFlightNoExp("^([A-Z]{2,3})([0-9]{1,4})[A-Z]?$");
|
|
QRegularExpressionMatch suffixMatch;
|
|
|
|
if (flightNoExp.match(aircraft->m_callsign).hasMatch())
|
|
{
|
|
aircraft->m_flight = aircraft->m_callsign;
|
|
}
|
|
else if ((suffixMatch = suffixedFlightNoExp.match(aircraft->m_callsign)).hasMatch())
|
|
{
|
|
aircraft->m_flight = QString("%1%2").arg(suffixMatch.captured(1)).arg(suffixMatch.captured(2));
|
|
}
|
|
else
|
|
{
|
|
// Don't guess, to save wasting API calls
|
|
aircraft->m_flight = "";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
aircraft->m_flight = "";
|
|
}
|
|
}
|
|
|
|
// ADS-B and Mode-S selected altitudes have slightly different precision, so values can jump around a bit
|
|
// And we end up with altitudes such as 38008 rather than 38000
|
|
// To remove this, we round to nearest 50 feet
|
|
int ADSBDemodGUI::roundTo50Feet(int alt)
|
|
{
|
|
return ((alt + 25) / 50) * 50;
|
|
}
|
|
|
|
// Estimate outside air temperature (static temperature) from Mach number and true airspeed, assuming dry air
|
|
bool ADSBDemodGUI::calcAirTemp(Aircraft *aircraft)
|
|
{
|
|
if (aircraft->m_machValid && aircraft->m_trueAirspeedValid)
|
|
{
|
|
// Calculate speed of sound
|
|
float c = Units::knotsToMetresPerSecond(aircraft->m_trueAirspeed) / aircraft->m_mach;
|
|
|
|
// Calculate temperature, given the speed of sound
|
|
float a = c / 331.3f;
|
|
float T = (a * a - 1.0f) * 273.15f;
|
|
|
|
aircraft->m_estAirTempItem->setData(Qt::DisplayRole, (int)std::round(T));
|
|
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void ADSBDemodGUI::handleADSB(
|
|
const QByteArray data,
|
|
const QDateTime dateTime,
|
|
float correlation,
|
|
float correlationOnes,
|
|
unsigned crc,
|
|
bool updateModel)
|
|
{
|
|
bool newAircraft = false;
|
|
bool updatedCallsign = false;
|
|
bool resetAnimation = false;
|
|
|
|
int df = (data[0] >> 3) & ADS_B_DF_MASK; // Downlink format
|
|
int ca = data[0] & 0x7; // Capability
|
|
unsigned icao;
|
|
Aircraft *aircraft;
|
|
|
|
if ((df == 4) || (df == 5) || (df == 20) || (df == 21))
|
|
{
|
|
// Extract ICAO from parity
|
|
int bytes = data.length();
|
|
unsigned parity = (data[bytes-3] << 16) | (data[bytes-2] << 8) | data[bytes-1];
|
|
icao = (parity ^ crc) & 0xffffff;
|
|
if (m_aircraft.contains(icao))
|
|
{
|
|
//qDebug() << "Mode-S from known aircraft - DF " << df << " ICAO " << Qt::hex << icao;
|
|
aircraft = getAircraft(icao, newAircraft);
|
|
}
|
|
else
|
|
{
|
|
// Ignore if not from a known aircraft, as its likely not to be a valid packet
|
|
//qDebug() << "Skipping Mode-S from unknown aircraft - DF " << df << " ICAO " << Qt::hex << icao;
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
icao = ((data[1] & 0xff) << 16) | ((data[2] & 0xff) << 8) | (data[3] & 0xff); // ICAO aircraft address
|
|
aircraft = getAircraft(icao, newAircraft);
|
|
}
|
|
int tc = (data[4] >> 3) & 0x1f; // Type code
|
|
|
|
aircraft->m_time = dateTime;
|
|
QTime time = dateTime.time();
|
|
aircraft->m_timeItem->setText(QString("%1:%2:%3").arg(time.hour(), 2, 10, QLatin1Char('0')).arg(time.minute(), 2, 10, QLatin1Char('0')).arg(time.second(), 2, 10, QLatin1Char('0')));
|
|
aircraft->m_adsbFrameCount++;
|
|
aircraft->m_adsbFrameCountItem->setData(Qt::DisplayRole, aircraft->m_adsbFrameCount);
|
|
if (df == 18)
|
|
{
|
|
aircraft->m_tisBFrameCount++;
|
|
aircraft->m_tisBItem->setData(Qt::DisplayRole, aircraft->m_tisBFrameCount);
|
|
}
|
|
|
|
if (correlation < aircraft->m_minCorrelation)
|
|
aircraft->m_minCorrelation = correlation;
|
|
if (correlation > aircraft->m_maxCorrelation)
|
|
aircraft->m_maxCorrelation = correlation;
|
|
m_correlationAvg(correlation);
|
|
aircraft->m_correlationAvg(correlation);
|
|
aircraft->m_correlation = aircraft->m_correlationAvg.instantAverage();
|
|
aircraft->m_correlationItem->setText(QString("%1/%2/%3")
|
|
.arg(CalcDb::dbPower(aircraft->m_minCorrelation), 3, 'f', 1)
|
|
.arg(CalcDb::dbPower(aircraft->m_correlation), 3, 'f', 1)
|
|
.arg(CalcDb::dbPower(aircraft->m_maxCorrelation), 3, 'f', 1));
|
|
m_correlationOnesAvg(correlationOnes);
|
|
aircraft->m_rssiItem->setText(QString("%1")
|
|
.arg(CalcDb::dbPower(m_correlationOnesAvg.instantAverage()), 3, 'f', 1));
|
|
|
|
// ADS-B, non-transponder ADS-B or TIS-B rebroadcast of ADS-B (ADS-R)
|
|
if ((df == 17) || ((df == 18) && (ca != 4)))
|
|
{
|
|
|
|
if ((tc >= 1) && ((tc <= 4)))
|
|
{
|
|
// Aircraft identification - BDS 0,8
|
|
int ec = data[4] & 0x7; // Emitter category
|
|
|
|
QString prevEmitterCategory = aircraft->m_emitterCategory;
|
|
if (tc == 4) {
|
|
aircraft->m_emitterCategory = m_categorySetA[ec];
|
|
} else if (tc == 3) {
|
|
aircraft->m_emitterCategory = m_categorySetB[ec];
|
|
} else if (tc == 2) {
|
|
aircraft->m_emitterCategory = m_categorySetC[ec];
|
|
} else {
|
|
aircraft->m_emitterCategory = QStringLiteral("Reserved");
|
|
}
|
|
aircraft->m_emitterCategoryItem->setText(aircraft->m_emitterCategory);
|
|
|
|
// Flight/callsign - Extract 8 6-bit characters from 6 8-bit bytes, MSB first
|
|
unsigned char c[8];
|
|
char callsign[9];
|
|
c[0] = (data[5] >> 2) & 0x3f; // 6
|
|
c[1] = ((data[5] & 0x3) << 4) | ((data[6] & 0xf0) >> 4); // 2+4
|
|
c[2] = ((data[6] & 0xf) << 2) | ((data[7] & 0xc0) >> 6); // 4+2
|
|
c[3] = (data[7] & 0x3f); // 6
|
|
c[4] = (data[8] >> 2) & 0x3f;
|
|
c[5] = ((data[8] & 0x3) << 4) | ((data[9] & 0xf0) >> 4);
|
|
c[6] = ((data[9] & 0xf) << 2) | ((data[10] & 0xc0) >> 6);
|
|
c[7] = (data[10] & 0x3f);
|
|
// Map to ASCII
|
|
for (int i = 0; i < 8; i++)
|
|
callsign[i] = m_idMap[c[i]];
|
|
callsign[8] = '\0';
|
|
QString callsignTrimmed = QString(callsign).trimmed();
|
|
|
|
updatedCallsign = aircraft->m_callsign != callsignTrimmed;
|
|
if (updatedCallsign)
|
|
{
|
|
aircraft->m_callsign = callsignTrimmed;
|
|
aircraft->m_callsignItem->setText(aircraft->m_callsign);
|
|
atcCallsign(aircraft);
|
|
callsignToFlight(aircraft);
|
|
}
|
|
|
|
// Select 3D model based on category, if we don't already have one based on ICAO
|
|
if ( aircraft->m_aircraft3DModel.isEmpty()
|
|
&& ( aircraft->m_aircraftCat3DModel.isEmpty()
|
|
|| (prevEmitterCategory != aircraft->m_emitterCategory)
|
|
)
|
|
)
|
|
{
|
|
get3DModelBasedOnCategory(aircraft);
|
|
// As we're changing the model, we need to reset animations to
|
|
// ensure gear/flaps are in correct position on new model
|
|
resetAnimation = true;
|
|
}
|
|
}
|
|
else if (((tc >= 5) && (tc <= 18)) || ((tc >= 20) && (tc <= 22)))
|
|
{
|
|
bool wasOnSurface = aircraft->m_onSurface;
|
|
aircraft->m_onSurface = (tc >= 5) && (tc <= 8);
|
|
|
|
if (wasOnSurface != aircraft->m_onSurface)
|
|
{
|
|
// Can't mix CPR values used on surface and those that are airbourne
|
|
aircraft->m_cprValid[0] = false;
|
|
aircraft->m_cprValid[1] = false;
|
|
}
|
|
|
|
if (aircraft->m_onSurface)
|
|
{
|
|
// Surface position - BDS 0,6
|
|
|
|
// There are a few airports that are below 0 MSL
|
|
// https://en.wikipedia.org/wiki/List_of_lowest_airports
|
|
// So we set altitude to a negative value here, which should
|
|
// then get clipped to actual terrain elevation in 3D map
|
|
aircraft->m_altitudeValid = true;
|
|
aircraft->m_altitude = -200;
|
|
aircraft->m_altitudeItem->setData(Qt::DisplayRole, "Surface");
|
|
|
|
int movement = ((data[4] & 0x7) << 4) | ((data[5] >> 4) & 0xf);
|
|
if (movement == 0)
|
|
{
|
|
// No information available
|
|
aircraft->m_groundspeedValid = false;
|
|
aircraft->m_groundspeedItem->setData(Qt::DisplayRole, "");
|
|
}
|
|
else if (movement == 1)
|
|
{
|
|
// Aircraft stopped
|
|
aircraft->m_groundspeedValid = true;
|
|
aircraft->m_groundspeedItem->setData(Qt::DisplayRole, 0);
|
|
aircraft->m_groundspeed = 0.0;
|
|
}
|
|
else if ((movement >= 2) && (movement <= 123))
|
|
{
|
|
float base, step; // In knts
|
|
int adjust;
|
|
if ((movement >= 2) && (movement <= 8))
|
|
{
|
|
base = 0.125f;
|
|
step = 0.125f;
|
|
adjust = 2;
|
|
}
|
|
else if ((movement >= 9) && (movement <= 12))
|
|
{
|
|
base = 1.0f;
|
|
step = 0.25f;
|
|
adjust = 9;
|
|
}
|
|
else if ((movement >= 13) && (movement <= 38))
|
|
{
|
|
base = 2.0f;
|
|
step = 0.5f;
|
|
adjust = 13;
|
|
}
|
|
else if ((movement >= 39) && (movement <= 93))
|
|
{
|
|
base = 15.0f;
|
|
step = 1.0f;
|
|
adjust = 39;
|
|
}
|
|
else if ((movement >= 94) && (movement <= 108))
|
|
{
|
|
base = 70.0f;
|
|
step = 2.0f;
|
|
adjust = 94;
|
|
}
|
|
else
|
|
{
|
|
base = 100.0f;
|
|
step = 5.0f;
|
|
adjust = 109;
|
|
}
|
|
aircraft->m_groundspeed = base + (movement - adjust) * step;
|
|
aircraft->m_groundspeedValid = true;
|
|
aircraft->m_groundspeedItem->setData(Qt::DisplayRole, m_settings.m_siUnits ? Units::knotsToIntegerKPH(aircraft->m_groundspeed) : (int)std::round(aircraft->m_groundspeed));
|
|
}
|
|
else if (movement == 124)
|
|
{
|
|
aircraft->m_groundspeedValid = true;
|
|
aircraft->m_groundspeedItem->setData(Qt::DisplayRole, m_settings.m_siUnits ? 324 : 175); // Actually greater than this
|
|
}
|
|
|
|
int groundTrackStatus = (data[5] >> 3) & 1;
|
|
int groundTrackValue = ((data[5] & 0x7) << 4) | ((data[6] >> 4) & 0xf);
|
|
if (groundTrackStatus)
|
|
{
|
|
aircraft->m_heading = groundTrackValue * 360.0/128.0;
|
|
aircraft->m_headingValid = true;
|
|
aircraft->m_headingItem->setData(Qt::DisplayRole, std::round(aircraft->m_heading));
|
|
}
|
|
}
|
|
else if (((tc >= 9) && (tc <= 18)) || ((tc >= 20) && (tc <= 22)))
|
|
{
|
|
// Airbourne position (9-18 baro, 20-22 GNSS)
|
|
int alt = ((data[5] & 0xff) << 4) | ((data[6] >> 4) & 0xf); // Altitude
|
|
int q = (alt & 0x10) != 0;
|
|
int n = ((alt >> 1) & 0x7f0) | (alt & 0xf); // Remove Q-bit
|
|
int alt_ft;
|
|
if (q == 1)
|
|
{
|
|
alt_ft = n * ((alt & 0x10) ? 25 : 100) - 1000;
|
|
}
|
|
else
|
|
{
|
|
alt_ft = gillhamToFeet(n);
|
|
}
|
|
|
|
aircraft->m_altitude = alt_ft;
|
|
aircraft->m_altitudeValid = alt != 0;
|
|
aircraft->m_altitudeGNSS = ((tc >= 20) && (tc <= 22));
|
|
// setData rather than setText so it sorts numerically
|
|
aircraft->m_altitudeItem->setData(Qt::DisplayRole, m_settings.m_siUnits ? Units::feetToIntegerMetres(aircraft->m_altitude) : aircraft->m_altitude);
|
|
|
|
// Assume runway elevation is at first reported airboune altitude
|
|
if (wasOnSurface)
|
|
{
|
|
aircraft->m_runwayAltitude = aircraft->m_altitude;
|
|
aircraft->m_runwayAltitudeValid = true;
|
|
}
|
|
}
|
|
|
|
int f = (data[6] >> 2) & 1; // CPR odd/even frame - should alternate every 0.2s
|
|
int lat_cpr = ((data[6] & 3) << 15) | ((data[7] & 0xff) << 7) | ((data[8] >> 1) & 0x7f);
|
|
int lon_cpr = ((data[8] & 1) << 16) | ((data[9] & 0xff) << 8) | (data[10] & 0xff);
|
|
|
|
aircraft->m_cprValid[f] = true;
|
|
aircraft->m_cprLat[f] = lat_cpr/131072.0f;
|
|
aircraft->m_cprLong[f] = lon_cpr/131072.0f;
|
|
aircraft->m_cprTime[f] = dateTime;
|
|
|
|
// CPR decoding
|
|
// Refer to Technical Provisions for Mode S Services and Extended Squitter - Appendix C2.6
|
|
// See also: https://mode-s.org/decode/adsb/airborne-position.html
|
|
// For global decoding, we need both odd and even frames
|
|
// We also need to check that both frames aren't greater than 10s apart in time (C.2.6.7), otherwise position may be out by ~10deg
|
|
// I've reduced this to 8.5s, as problems have been seen where times are just 9s apart. This may be because
|
|
// our timestamps aren't accurate, as the times are generated when packets are decoded on buffered data.
|
|
// We could compare global + local methods to see if the positions are sensible
|
|
if (aircraft->m_cprValid[0] && aircraft->m_cprValid[1]
|
|
&& (std::abs(aircraft->m_cprTime[0].toMSecsSinceEpoch() - aircraft->m_cprTime[1].toMSecsSinceEpoch()) <= 8500)
|
|
&& !aircraft->m_onSurface)
|
|
{
|
|
// Global decode using odd and even frames (C.2.6)
|
|
|
|
// Calculate latitude
|
|
const double dLatEven = 360.0/60.0;
|
|
const double dLatOdd = 360.0/59.0;
|
|
double latEven, latOdd;
|
|
double latitude, longitude;
|
|
int ni, m;
|
|
|
|
int j = std::floor(59.0f*aircraft->m_cprLat[0] - 60.0f*aircraft->m_cprLat[1] + 0.5);
|
|
latEven = dLatEven * (modulus(j, 60) + aircraft->m_cprLat[0]);
|
|
// Southern hemisphere is in range 270-360, so adjust to -90-0
|
|
if (latEven >= 270.0f)
|
|
latEven -= 360.0f;
|
|
latOdd = dLatOdd * (modulus(j, 59) + aircraft->m_cprLat[1]);
|
|
if (latOdd >= 270.0f)
|
|
latOdd -= 360.0f;
|
|
if (aircraft->m_cprTime[0] >= aircraft->m_cprTime[1])
|
|
latitude = latEven;
|
|
else
|
|
latitude = latOdd;
|
|
if ((latitude <= 90.0) && (latitude >= -90.0))
|
|
{
|
|
// Check if both frames in same latitude zone
|
|
int latEvenNL = cprNL(latEven);
|
|
int latOddNL = cprNL(latOdd);
|
|
if (latEvenNL == latOddNL)
|
|
{
|
|
// Calculate longitude
|
|
if (!f)
|
|
{
|
|
ni = cprN(latEven, 0);
|
|
m = std::floor(aircraft->m_cprLong[0] * (latEvenNL - 1) - aircraft->m_cprLong[1] * latEvenNL + 0.5f);
|
|
longitude = (360.0f/ni) * (modulus(m, ni) + aircraft->m_cprLong[0]);
|
|
}
|
|
else
|
|
{
|
|
ni = cprN(latOdd, 1);
|
|
m = std::floor(aircraft->m_cprLong[0] * (latOddNL - 1) - aircraft->m_cprLong[1] * latOddNL + 0.5f);
|
|
longitude = (360.0f/ni) * (modulus(m, ni) + aircraft->m_cprLong[1]);
|
|
}
|
|
if (longitude > 180.0f)
|
|
longitude -= 360.0f;
|
|
aircraft->m_latitude = latitude;
|
|
aircraft->m_latitudeItem->setData(Qt::DisplayRole, aircraft->m_latitude);
|
|
aircraft->m_longitude = longitude;
|
|
aircraft->m_longitudeItem->setData(Qt::DisplayRole, aircraft->m_longitude);
|
|
aircraft->m_positionDateTime = dateTime;
|
|
QGeoCoordinate coord(aircraft->m_latitude, aircraft->m_longitude, aircraft->m_altitude);
|
|
aircraft->m_coordinates.push_back(QVariant::fromValue(coord));
|
|
aircraft->m_coordinateDateTimes.push_back(dateTime);
|
|
updatePosition(aircraft);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
qDebug() << "ADSBDemodGUI::handleADSB: Invalid latitude " << latitude << " for " << QString("%1").arg(aircraft->m_icaoHex)
|
|
<< " m_cprLat[0] " << aircraft->m_cprLat[0]
|
|
<< " m_cprLat[1] " << aircraft->m_cprLat[1];
|
|
aircraft->m_cprValid[0] = false;
|
|
aircraft->m_cprValid[1] = false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Local decode using a single aircraft position + location of receiver
|
|
// Only valid if airbourne within 180nm/333km (C.2.6.4) or 45nm for surface
|
|
|
|
// Caclulate latitude
|
|
const double maxDeg = aircraft->m_onSurface ? 90.0 : 360.0;
|
|
const double dLatEven = maxDeg/60.0;
|
|
const double dLatOdd = maxDeg/59.0;
|
|
double dLat = f ? dLatOdd : dLatEven;
|
|
double latitude, longitude;
|
|
|
|
int j = std::floor(m_azEl.getLocationSpherical().m_latitude/dLat) + std::floor(modulus(m_azEl.getLocationSpherical().m_latitude, dLat)/dLat - aircraft->m_cprLat[f] + 0.5);
|
|
latitude = dLat * (j + aircraft->m_cprLat[f]);
|
|
|
|
// Caclulate longitude
|
|
double dLong;
|
|
int latNL = cprNL(latitude);
|
|
if (f == 0)
|
|
{
|
|
if (latNL > 0)
|
|
dLong = maxDeg / latNL;
|
|
else
|
|
dLong = maxDeg;
|
|
}
|
|
else
|
|
{
|
|
if ((latNL - 1) > 0)
|
|
dLong = maxDeg / (latNL - 1);
|
|
else
|
|
dLong = maxDeg;
|
|
}
|
|
int m = std::floor(m_azEl.getLocationSpherical().m_longitude/dLong) + std::floor(modulus(m_azEl.getLocationSpherical().m_longitude, dLong)/dLong - aircraft->m_cprLong[f] + 0.5);
|
|
longitude = dLong * (m + aircraft->m_cprLong[f]);
|
|
|
|
if (updateLocalPosition(aircraft, latitude, longitude, aircraft->m_onSurface))
|
|
{
|
|
aircraft->m_latitude = latitude;
|
|
aircraft->m_latitudeItem->setData(Qt::DisplayRole, aircraft->m_latitude);
|
|
aircraft->m_longitude = longitude;
|
|
aircraft->m_longitudeItem->setData(Qt::DisplayRole, aircraft->m_longitude);
|
|
aircraft->m_positionDateTime = dateTime;
|
|
QGeoCoordinate coord(aircraft->m_latitude, aircraft->m_longitude, aircraft->m_altitude);
|
|
aircraft->m_coordinates.push_back(QVariant::fromValue(coord));
|
|
aircraft->m_coordinateDateTimes.push_back(dateTime);
|
|
}
|
|
}
|
|
}
|
|
else if (tc == 19)
|
|
{
|
|
// Airbourne velocity - BDS 0,9
|
|
int st = data[4] & 0x7; // Subtype
|
|
if ((st == 1) || (st == 2))
|
|
{
|
|
// Ground speed
|
|
int s_ew = (data[5] >> 2) & 1; // East-west velocity sign
|
|
int v_ew = ((data[5] & 0x3) << 8) | (data[6] & 0xff); // East-west velocity
|
|
int s_ns = (data[7] >> 7) & 1; // North-south velocity sign
|
|
int v_ns = ((data[7] & 0x7f) << 3) | ((data[8] >> 5) & 0x7); // North-south velocity
|
|
|
|
int v_we;
|
|
int v_sn;
|
|
float v;
|
|
float h;
|
|
|
|
if (s_ew) {
|
|
v_we = -1 * (v_ew - 1);
|
|
} else {
|
|
v_we = v_ew - 1;
|
|
}
|
|
if (s_ns) {
|
|
v_sn = -1 * (v_ns - 1);
|
|
} else {
|
|
v_sn = v_ns - 1;
|
|
}
|
|
v = std::round(std::sqrt(v_we*v_we + v_sn*v_sn));
|
|
h = std::atan2(v_we, v_sn) * 360.0/(2.0*M_PI);
|
|
if (h < 0.0) {
|
|
h += 360.0;
|
|
}
|
|
|
|
aircraft->m_heading = h; // This is actually track, rather than heading
|
|
aircraft->m_headingValid = true;
|
|
aircraft->m_headingDateTime = dateTime;
|
|
aircraft->m_groundspeed = v;
|
|
aircraft->m_groundspeedValid = true;
|
|
aircraft->m_headingItem->setData(Qt::DisplayRole, std::round(aircraft->m_heading));
|
|
aircraft->m_groundspeedItem->setData(Qt::DisplayRole,m_settings.m_siUnits ? Units::knotsToIntegerKPH(aircraft->m_groundspeed) : aircraft->m_groundspeed);
|
|
aircraft->m_orientationDateTime = dateTime;
|
|
}
|
|
else
|
|
{
|
|
// Airspeed (only likely to get this if an aircraft is unable to determine it's position)
|
|
int s_hdg = (data[5] >> 2) & 1; // Heading status
|
|
int hdg = ((data[5] & 0x3) << 8) | (data[6] & 0xff); // Heading
|
|
if (s_hdg)
|
|
{
|
|
aircraft->m_heading = hdg/1024.0f*360.0f;
|
|
aircraft->m_headingValid = true;
|
|
aircraft->m_headingDateTime = dateTime;
|
|
aircraft->m_headingItem->setData(Qt::DisplayRole, std::round(aircraft->m_heading));
|
|
aircraft->m_orientationDateTime = dateTime;
|
|
}
|
|
|
|
int as_t = (data[7] >> 7) & 1; // Airspeed type
|
|
int as = ((data[7] & 0x7f) << 3) | ((data[8] >> 5) & 0x7); // Airspeed
|
|
|
|
if (as_t == 1)
|
|
{
|
|
aircraft->m_trueAirspeed = as;
|
|
aircraft->m_trueAirspeedValid = true;
|
|
aircraft->m_trueAirspeedItem->setData(Qt::DisplayRole, m_settings.m_siUnits ? Units::knotsToIntegerKPH(aircraft->m_trueAirspeed) : aircraft->m_trueAirspeed);
|
|
}
|
|
else
|
|
{
|
|
aircraft->m_indicatedAirspeed = as;
|
|
aircraft->m_indicatedAirspeedValid = true;
|
|
aircraft->m_indicatedAirspeedItem->setData(Qt::DisplayRole, m_settings.m_siUnits ? Units::knotsToIntegerKPH(aircraft->m_indicatedAirspeed) : aircraft->m_indicatedAirspeed);
|
|
}
|
|
}
|
|
//int vr_source = (data[8] >> 4) & 1; // Source of vertical rate GNSS=0 Baro=1
|
|
int s_vr = (data[8] >> 3) & 1; // Vertical rate sign
|
|
int vr = ((data[8] & 0x7) << 6) | ((data[9] >> 2) & 0x3f); // Vertical rate
|
|
aircraft->m_verticalRate = (vr-1)*64*(s_vr?-1:1);
|
|
aircraft->m_verticalRateValid = true;
|
|
if (m_settings.m_siUnits)
|
|
aircraft->m_verticalRateItem->setData(Qt::DisplayRole, Units::feetPerMinToIntegerMetresPerSecond(aircraft->m_verticalRate));
|
|
else
|
|
aircraft->m_verticalRateItem->setData(Qt::DisplayRole, aircraft->m_verticalRate);
|
|
}
|
|
else if (tc == 28)
|
|
{
|
|
// Aircraft status - BDS 6,1
|
|
int st = data[4] & 0x7; // Subtype
|
|
if (st == 1)
|
|
{
|
|
int es = (data[5] >> 5) & 0x7; // Emergency state
|
|
int modeA = ((data[5] << 8) & 0x1f00) | (data[6] & 0xff); // Mode-A code (squawk)
|
|
aircraft->m_status = m_emergencyStatus[es];
|
|
aircraft->m_statusItem->setText(aircraft->m_status);
|
|
aircraft->m_squawk = squawkDecode(modeA);
|
|
if (modeA & 0x40)
|
|
aircraft->m_squawkItem->setText(QString("%1 IDENT").arg(aircraft->m_squawk, 4, 10, QLatin1Char('0')));
|
|
else
|
|
aircraft->m_squawkItem->setText(QString("%1").arg(aircraft->m_squawk, 4, 10, QLatin1Char('0')));
|
|
}
|
|
else if (st == 2)
|
|
{
|
|
// TCAS/ACAS RA Broadcast
|
|
}
|
|
}
|
|
else if (tc == 29)
|
|
{
|
|
// Target state and status
|
|
//bool selAltitudeType = (data[5] >> 7) & 0x1;
|
|
int selAltitudeFix = ((data[5] & 0x7f) << 4) | ((data[6] >> 4) & 0xf);
|
|
if (selAltitudeFix != 0)
|
|
{
|
|
int selAltitude = (selAltitudeFix - 1) * 32; // Ft
|
|
aircraft->m_selAltitude = selAltitude;
|
|
aircraft->m_selAltitudeValid = true;
|
|
if (m_settings.m_siUnits) {
|
|
aircraft->m_selAltitudeItem->setData(Qt::DisplayRole, Units::feetToIntegerMetres(aircraft->m_selAltitude));
|
|
} else {
|
|
aircraft->m_selAltitudeItem->setData(Qt::DisplayRole, roundTo50Feet(aircraft->m_selAltitude));
|
|
}
|
|
}
|
|
int baroFix = ((data[6] & 0xf) << 5) | ((data[7] >> 3) & 0x1f);
|
|
if (baroFix != 0)
|
|
{
|
|
float baro = (baroFix - 1) * 0.8f + 800.0f; // mb
|
|
aircraft->m_baro = baro;
|
|
aircraft->m_baroValid = true;
|
|
aircraft->m_baroItem->setData(Qt::DisplayRole, std::round(aircraft->m_baro));
|
|
}
|
|
bool selHeadingValid = (data[7] >> 2) & 0x1;
|
|
if (selHeadingValid)
|
|
{
|
|
int selHeadingFix = ((data[7] & 0x3) << 7) | ((data[8] >> 1) & 0x7f);
|
|
selHeadingFix = (selHeadingFix << 23) >> 23;
|
|
float selHeading = selHeadingFix * 180.0f / 256.0f;
|
|
if (selHeading < 0.0f) {
|
|
selHeading += 360.0f;
|
|
}
|
|
aircraft->m_selHeading = selHeading;
|
|
aircraft->m_selHeadingValid = true;
|
|
aircraft->m_selHeadingItem->setData(Qt::DisplayRole, std::round(aircraft->m_selHeading));
|
|
}
|
|
|
|
bool modeValid = (data[9] >> 1) & 0x1;
|
|
if (modeValid)
|
|
{
|
|
bool autoPilot = data[9] & 0x1;
|
|
bool vnavMode = (data[10] >> 7) & 0x1;
|
|
bool altHoldMode = (data[10] >> 6) & 0x1;
|
|
bool approachMode = (data[10] >> 4) & 0x1;
|
|
bool lnavMode = (data[10] >> 2) & 0x1;
|
|
|
|
aircraft->m_apItem->setText(autoPilot ? QChar(0x2713) : QChar(0x2717)); // Tick or cross
|
|
|
|
QString vMode = "";
|
|
if (vnavMode) {
|
|
vMode = vMode + "VNAV ";
|
|
}
|
|
if (altHoldMode) {
|
|
vMode = vMode + "HOLD ";
|
|
}
|
|
if (approachMode) {
|
|
vMode = vMode + "APP ";
|
|
}
|
|
vMode = vMode.trimmed();
|
|
aircraft->m_vModeItem->setText(vMode);
|
|
|
|
QString lMode = "";
|
|
if (lnavMode) {
|
|
lMode = lMode + "LNAV ";
|
|
}
|
|
if (approachMode) {
|
|
lMode = lMode + "APP ";
|
|
}
|
|
lMode = lMode.trimmed();
|
|
aircraft->m_lModeItem->setText(lMode);
|
|
}
|
|
|
|
}
|
|
else if (tc == 31)
|
|
{
|
|
// Aircraft operation status
|
|
}
|
|
|
|
// Update aircraft in map
|
|
if (aircraft->m_positionValid)
|
|
{
|
|
// Check to see if we need to start any animations
|
|
QList<SWGSDRangel::SWGMapAnimation *> *animations = animate(dateTime, aircraft);
|
|
|
|
// Update map displayed in channel
|
|
if (updateModel) {
|
|
m_aircraftModel.aircraftUpdated(aircraft);
|
|
}
|
|
|
|
// Send to Map feature
|
|
sendToMap(aircraft, animations);
|
|
|
|
if (resetAnimation)
|
|
{
|
|
// Wait until after model has changed before reseting
|
|
// otherwise animation might play on old model
|
|
aircraft->m_gearDown = false;
|
|
aircraft->m_flaps = 0.0;
|
|
aircraft->m_engineStarted = false;
|
|
aircraft->m_rotorStarted = false;
|
|
}
|
|
}
|
|
}
|
|
else if (df == 18)
|
|
{
|
|
// TIS-B that doesn't match ADS-B formats, such as TIS-B management
|
|
qDebug() << "TIS B message cf=" << ca << " icao: " << QString::number(icao, 16);
|
|
}
|
|
else if ((df == 4) || (df == 5))
|
|
{
|
|
decodeModeS(data, df, aircraft);
|
|
}
|
|
else if ((df == 20) || (df == 21))
|
|
{
|
|
decodeModeS(data, df, aircraft);
|
|
decodeCommB(data, dateTime, df, aircraft, updatedCallsign);
|
|
}
|
|
|
|
// Check to see if we need to emit a notification about this aircraft
|
|
checkDynamicNotification(aircraft);
|
|
|
|
// Update text below photo if it's likely to have changed
|
|
if ((aircraft == m_highlightAircraft) && (newAircraft || updatedCallsign)) {
|
|
updatePhotoText(aircraft);
|
|
}
|
|
}
|
|
|
|
void ADSBDemodGUI::decodeModeS(const QByteArray data, int df, Aircraft *aircraft)
|
|
{
|
|
bool wasOnSurface = aircraft->m_onSurface;
|
|
bool takenOff = false;
|
|
|
|
int flightStatus = data[0] & 0x7;
|
|
if ((flightStatus == 0) || (flightStatus == 2))
|
|
{
|
|
takenOff = wasOnSurface;
|
|
aircraft->m_onSurface = false;
|
|
}
|
|
else if ((flightStatus == 1) || (flightStatus == 3))
|
|
{
|
|
aircraft->m_onSurface = true;
|
|
}
|
|
if (wasOnSurface != aircraft->m_onSurface)
|
|
{
|
|
// Can't mix CPR values used on surface and those that are airbourne
|
|
aircraft->m_cprValid[0] = false;
|
|
aircraft->m_cprValid[1] = false;
|
|
}
|
|
//qDebug() << "Flight Status " << m_flightStatuses[flightStatus];
|
|
|
|
int altitude = 0; // Altitude in feet
|
|
|
|
if ((df == 4) || (df == 20))
|
|
{
|
|
int altitudeCode = ((data[2] & 0x1f) << 8) | (data[3] & 0xff);
|
|
if (altitudeCode & 0x40) // M bit indicates metres
|
|
{
|
|
int altitudeMetres = ((altitudeCode & 0x1f80) >> 1) | (altitudeCode & 0x3f);
|
|
altitude = Units::metresToFeet(altitudeMetres);
|
|
}
|
|
else
|
|
{
|
|
// Remove M and Q bits
|
|
int altitudeFix = ((altitudeCode & 0x1f80) >> 2) | ((altitudeCode & 0x20) >> 1) | (altitudeCode & 0xf);
|
|
|
|
// Convert to feet
|
|
if (altitudeCode & 0x10) {
|
|
altitude = altitudeFix * 25 - 1000;
|
|
} else {
|
|
altitude = gillhamToFeet(altitudeFix);
|
|
}
|
|
}
|
|
|
|
aircraft->m_altitude = altitude;
|
|
aircraft->m_altitudeValid = true;
|
|
aircraft->m_altitudeGNSS = false;
|
|
aircraft->m_altitudeItem->setData(Qt::DisplayRole, m_settings.m_siUnits ? Units::feetToIntegerMetres(aircraft->m_altitude) : aircraft->m_altitude);
|
|
|
|
// Assume runway elevation is at first reported airboune altitude
|
|
if (takenOff)
|
|
{
|
|
aircraft->m_runwayAltitude = aircraft->m_altitude;
|
|
aircraft->m_runwayAltitudeValid = true;
|
|
}
|
|
}
|
|
else if ((df == 5) || (df == 21))
|
|
{
|
|
// Squawk ident code
|
|
int identCode = ((data[2] & 0x1f) << 8) | (data[3] & 0xff);
|
|
int squawk = squawkDecode(identCode);
|
|
|
|
if (squawk != aircraft->m_squawk)
|
|
{
|
|
aircraft->m_squawk = squawk;
|
|
if (identCode & 0x40) {
|
|
aircraft->m_squawkItem->setText(QString("%1 IDENT").arg(aircraft->m_squawk, 4, 10, QLatin1Char('0')));
|
|
} else {
|
|
aircraft->m_squawkItem->setText(QString("%1").arg(aircraft->m_squawk, 4, 10, QLatin1Char('0')));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void ADSBDemodGUI::decodeCommB(const QByteArray data, const QDateTime dateTime, int df, Aircraft *aircraft, bool &updatedCallsign)
|
|
{
|
|
// We only see downlink messages, so do not know the data format, so have to decode all posibilities
|
|
// and then see which have legal values and values that are consistent with ADS-B data
|
|
|
|
// All IFR aircraft should support ELS (Elementary Surveillance) which includes BDS 1,0 1,7 2,0 3,0
|
|
// Large aircraft are also required to support EHS (Enhanced Surveillance) which adds BDS 4,0 5,0 6,0
|
|
// There is also MRAR (Meteorological Routine Air Report) BDS 4,4 4,5, but only a small % of aircraft support this
|
|
// See: https://www.icao.int/APAC/Documents/edocs/Mode%20S%20DAPs%20Implementation%20and%20Operations%20Guidance%20Document3.0.pdf
|
|
|
|
// I've implemented a few extra BDSes, but these are rarely seen.
|
|
// Figure 2 in "Mode S Transponder Comm-B Capabilities in Current Operational Aircraft" gives a breakdown of what capabilities are reported by BDS 1,7:
|
|
// https://www.researchgate.net/publication/346521949_Mode_S_Transponder_Comm-B_Capabilities_in_Current_Operational_Aircraft/link/5fc60b794585152e9be8571c/download
|
|
|
|
// Skip messages that are all zeros
|
|
if (data[4] || data[5] || data[6] || data[7] || data[8] || data[9] || data[10])
|
|
{
|
|
|
|
const int maxWind = 250; // Maximum expected head/tail wind in knts
|
|
const int maxSpeedDiff = 50; // Maximum speed difference we allow before we assume message is inconsistent
|
|
const int maxAlt = 46000; // Maximum expected altitude for commercial jet
|
|
const float maxHeadingDiff = 20.0f; // Maximum difference in heading/track
|
|
|
|
// BDS 1,0 - ELS
|
|
|
|
bool bds_1_0 = (data[4] == 0x10) && ((data[5] & 0x7c) == 0x00);
|
|
|
|
// BDS 1,7 - Common usage GICB capability report - ELS
|
|
|
|
bool cap_0_5 = (data[4] >> 7) & 0x1;
|
|
bool cap_0_6 = (data[4] >> 6) & 0x1;
|
|
bool cap_0_7 = (data[4] >> 5) & 0x1;
|
|
bool cap_0_8 = (data[4] >> 4) & 0x1;
|
|
bool cap_0_9 = (data[4] >> 3) & 0x1;
|
|
bool cap_0_a = (data[4] >> 2) & 0x1;
|
|
bool cap_2_0 = (data[4] >> 1) & 0x1;
|
|
bool cap_2_1 = (data[4] >> 0) & 0x1;
|
|
|
|
bool cap_4_0 = (data[5] >> 7) & 0x1;
|
|
bool cap_4_1 = (data[5] >> 6) & 0x1;
|
|
bool cap_4_2 = (data[5] >> 5) & 0x1;
|
|
bool cap_4_3 = (data[5] >> 4) & 0x1;
|
|
bool cap_4_4 = (data[5] >> 3) & 0x1;
|
|
bool cap_4_5 = (data[5] >> 2) & 0x1;
|
|
bool cap_4_8 = (data[5] >> 1) & 0x1;
|
|
bool cap_5_0 = (data[5] >> 0) & 0x1;
|
|
|
|
bool cap_5_1 = (data[6] >> 7) & 0x1;
|
|
bool cap_5_2 = (data[6] >> 6) & 0x1;
|
|
bool cap_5_3 = (data[6] >> 5) & 0x1;
|
|
bool cap_5_4 = (data[6] >> 4) & 0x1;
|
|
bool cap_5_5 = (data[6] >> 3) & 0x1;
|
|
bool cap_5_6 = (data[6] >> 2) & 0x1;
|
|
bool cap_5_f = (data[6] >> 1) & 0x1;
|
|
bool cap_6_0 = (data[6] >> 0) & 0x1;
|
|
|
|
QStringList caps;
|
|
if (cap_0_5) {
|
|
caps.append("0,5");
|
|
}
|
|
if (cap_0_6) {
|
|
caps.append("0,6");
|
|
}
|
|
if (cap_0_7) {
|
|
caps.append("0,7");
|
|
}
|
|
if (cap_0_8) {
|
|
caps.append("0,8");
|
|
}
|
|
if (cap_0_9) {
|
|
caps.append("0,9");
|
|
}
|
|
if (cap_0_a) {
|
|
caps.append("0,A");
|
|
}
|
|
if (cap_2_0) {
|
|
caps.append("2,0");
|
|
}
|
|
if (cap_2_1) {
|
|
caps.append("2,1");
|
|
}
|
|
if (cap_4_0) {
|
|
caps.append("4,0");
|
|
}
|
|
if (cap_4_1) {
|
|
caps.append("4,1");
|
|
}
|
|
if (cap_4_2) {
|
|
caps.append("4,2");
|
|
}
|
|
if (cap_4_3) {
|
|
caps.append("4,3");
|
|
}
|
|
if (cap_4_4) {
|
|
caps.append("4,4");
|
|
}
|
|
if (cap_4_5) {
|
|
caps.append("4,5");
|
|
}
|
|
if (cap_4_8) {
|
|
caps.append("4,8");
|
|
}
|
|
if (cap_5_0) {
|
|
caps.append("5,0");
|
|
}
|
|
if (cap_5_1) {
|
|
caps.append("5,1");
|
|
}
|
|
if (cap_5_2) {
|
|
caps.append("5,2");
|
|
}
|
|
if (cap_5_3) {
|
|
caps.append("5,3");
|
|
}
|
|
if (cap_5_4) {
|
|
caps.append("5,4");
|
|
}
|
|
if (cap_5_5) {
|
|
caps.append("5,5");
|
|
}
|
|
if (cap_5_6) {
|
|
caps.append("5,6");
|
|
}
|
|
if (cap_5_f) {
|
|
caps.append("5,F");
|
|
}
|
|
if (cap_5_5) {
|
|
caps.append("6,0");
|
|
}
|
|
|
|
bool bds_1_7 = cap_2_0 && (data[7] == 0x0) && (data[8] == 0x0) && (data[9] == 0x0) && (data[10] == 0x0);
|
|
|
|
// BDS 1,8 1,9 1,A 1,B 1,C 1,D 1,E 1,F Mode S specific services
|
|
|
|
// Apart from 1,C and 1,F these can have any bits set/clear and specify BDS code capabilities
|
|
// Don't decode for now
|
|
|
|
// BDS 2,0 - Aircraft identification - ELS
|
|
|
|
// Flight/callsign - Extract 8 6-bit characters from 6 8-bit bytes, MSB first
|
|
unsigned char c[9];
|
|
char callsign[9];
|
|
c[0] = (data[5] >> 2) & 0x3f; // 6
|
|
c[1] = ((data[5] & 0x3) << 4) | ((data[6] & 0xf0) >> 4); // 2+4
|
|
c[2] = ((data[6] & 0xf) << 2) | ((data[7] & 0xc0) >> 6); // 4+2
|
|
c[3] = (data[7] & 0x3f); // 6
|
|
c[4] = (data[8] >> 2) & 0x3f;
|
|
c[5] = ((data[8] & 0x3) << 4) | ((data[9] & 0xf0) >> 4);
|
|
c[6] = ((data[9] & 0xf) << 2) | ((data[10] & 0xc0) >> 6);
|
|
c[7] = (data[10] & 0x3f);
|
|
// Map to ASCII
|
|
for (int i = 0; i < 8; i++) {
|
|
callsign[i] = m_idMap[c[i]];
|
|
}
|
|
callsign[8] = '\0';
|
|
QString callsignTrimmed = QString(callsign).trimmed();
|
|
bool invalidCallsign = QString(callsign).contains('#');
|
|
bool bds_2_0 = (data[4] == 0x20) && !invalidCallsign;
|
|
|
|
// BDS 2,1 - Aircraft and airline registration markings
|
|
|
|
bool aircraftRegistrationStatus = (data[4] >> 7) & 0x1;
|
|
char aircraftRegistration[8];
|
|
c[0] = (data[4] >> 1) & 0x3f;
|
|
c[1] = ((data[4] & 0x1) << 5) | ((data[5] >> 3) & 0x1f);
|
|
c[2] = ((data[5] & 0x7) << 3) | ((data[6] >> 5) & 0x7);
|
|
c[3] = ((data[6] & 0x1f) << 1) | ((data[7] >> 7) & 0x1);
|
|
c[4] = ((data[7] >> 1) & 0x1f);
|
|
c[5] = ((data[7] & 0x1) >> 3) | ((data[8] >> 3) & 0x1f);
|
|
c[6] = ((data[8] & 0x7) << 3) | ((data[9] >> 5) & 0x7);
|
|
// Map to ASCII
|
|
for (int i = 0; i < 7; i++) {
|
|
aircraftRegistration[i] = m_idMap[c[i]];
|
|
}
|
|
aircraftRegistration[7] = '\0';
|
|
QString aircraftRegistrationString = QString(aircraftRegistration).trimmed();
|
|
bool aircraftRegistrationInvalid = QString(aircraftRegistrationString).contains('#');
|
|
bool aircraftRegistrationInconsistent = !aircraftRegistrationStatus && (c[0] || c[1] || c[2] || c[3] || c[4] || c[5] || c[6]);
|
|
|
|
bool airlineRegistrationStatus = (data[9] >> 4) & 0x1;
|
|
char airlineRegistration[3];
|
|
c[0] = ((data[9] & 0xf) << 2) | ((data[10] >> 6) & 0x3);
|
|
c[1] = data[10] & 0x3f;
|
|
// Map to ASCII
|
|
for (int i = 0; i < 2; i++) {
|
|
airlineRegistration[i] = m_idMap[c[i]];
|
|
}
|
|
airlineRegistration[2] = '\0';
|
|
QString airlineRegistrationString = QString(airlineRegistration).trimmed();
|
|
bool airlineRegistrationInvalid = QString(airlineRegistrationString).contains('#') || !QChar::isLetter(c[0]) || !QChar::isLetter(c[1]);
|
|
bool airlineRegistrationInconsistent = !airlineRegistrationStatus && (c[0] || c[1]);
|
|
|
|
bool bds_2_1 = !aircraftRegistrationInvalid && !aircraftRegistrationInconsistent && !airlineRegistrationInvalid && !airlineRegistrationInconsistent;
|
|
|
|
// BDS 3,0 - ACAS active resolution advisory - ELS
|
|
|
|
int acas = data[6] & 0x7f;
|
|
int threatType = (data[7] >> 2) & 0x3;
|
|
bool bds_3_0 = (data[4] == 0x30) && (acas < 48) && (threatType != 3);
|
|
|
|
// BDS 4,0 - Selected vertical information - EHS
|
|
|
|
bool mcpSelectedAltStatus = (data[4] >> 7) & 0x1;
|
|
int mcpSelectedAltFix = ((data[4] & 0x7f) << 5) | ((data[5] >> 3) & 0x1f);
|
|
int mcpSelectedAlt = mcpSelectedAltFix * 16; // ft
|
|
bool mcpSelectedAltInconsistent = (mcpSelectedAlt > maxAlt) || (!mcpSelectedAltStatus && (mcpSelectedAltFix != 0));
|
|
|
|
bool fmsSelectedAltStatus = (data[5] >> 2) & 0x1;
|
|
int fmsSelectedAltFix = ((data[5] & 0x3) << 10) | ((data[6] & 0xff) << 2) || (data[7] >> 6) & 0x3;
|
|
int fmsSelectedAlt = fmsSelectedAltFix * 16; // ft
|
|
bool fmsSelectedAltInconsistent = (fmsSelectedAlt > maxAlt) || (!fmsSelectedAltStatus && (fmsSelectedAltFix != 0));
|
|
|
|
bool baroSettingStatus = (data[7] >> 5) & 0x1;
|
|
int baroSettingFix = ((data[7] & 0x1f) << 7) | ((data[8] >> 1) & 0x7f);
|
|
float baroSetting = baroSettingFix * 0.1f + 800.0f; // mb
|
|
bool baroSettingIncosistent = !baroSettingStatus && (baroSettingFix != 0);
|
|
|
|
bool modeStatus = data[9] & 0x1;
|
|
bool vnavMode = (data[10] >> 7) & 0x1;
|
|
bool altHoldMode = (data[10] >> 6) & 0x1;
|
|
bool approachMode = (data[10] >> 5) & 0x1;
|
|
bool modeInconsistent = !modeStatus && (vnavMode || altHoldMode || approachMode);
|
|
|
|
bool targetAltSourceStatus = (data[10] >> 2) & 0x1;
|
|
int targetAltSource = data[10] & 0x3;
|
|
bool targetAltSourceInconsistent = !targetAltSourceStatus && (targetAltSource != 0);
|
|
|
|
bool bds_4_0 = ((data[8] & 0x01) == 0x0) && ((data[9] & 0xfe) == 0x0) && ((data[10] & 0x18) == 0x0)
|
|
&& !mcpSelectedAltInconsistent && !fmsSelectedAltInconsistent && !baroSettingIncosistent && !modeInconsistent && !targetAltSourceInconsistent;
|
|
|
|
// BDS 4,1 - Next waypoint
|
|
|
|
bool waypointStatus = (data[4] >> 7) & 0x1;
|
|
char waypoint[10];
|
|
c[0] = (data[4] >> 1) & 0x3f;
|
|
c[1] = ((data[4] & 0x1) << 5) | ((data[5] >> 3) & 0x1f);
|
|
c[2] = ((data[5] & 0x7) << 3) | ((data[6] >> 5) & 0x7);
|
|
c[3] = ((data[6] & 0x1f) << 1) | ((data[7] >> 7) & 0x1);
|
|
c[4] = ((data[7] >> 1) & 0x1f);
|
|
c[5] = ((data[7] & 0x1) >> 3) | ((data[8] >> 3) & 0x1f);
|
|
c[6] = ((data[8] & 0x7) << 3) | ((data[9] >> 5) & 0x7);
|
|
c[7] = ((data[9] & 0x1f) << 1) | ((data[10] >> 7) & 0x1);
|
|
c[8] = ((data[10] >> 1) & 0x3f);
|
|
// Map to ASCII
|
|
for (int i = 0; i < 9; i++) {
|
|
waypoint[i] = m_idMap[c[i]];
|
|
}
|
|
waypoint[9] = '\0';
|
|
QString waypointString = QString(waypoint).trimmed();
|
|
bool waypointInvalid = QString(waypointString).contains('#');
|
|
bool waypointInconsistent = (waypointString.size() != 5) // Most navaid waypoints are 5 characters, and this prevents some incorrect matches, but is it correct? Need examples.
|
|
|| (!waypointStatus && (c[0] || c[1] || c[2] || c[3] || c[4] || c[5] || c[6] || c[7] || c[8]));
|
|
|
|
bool bds_4_1 = !waypointInvalid && !waypointInconsistent;
|
|
|
|
// BDS 4,4 - Meteorological routine air report - MRAR - (Appendix E suggests a slightly different format in the future)
|
|
|
|
int fomSource = (data[4] >> 4) & 0xf;
|
|
bool fomSourceInconsistent = fomSource > 4;
|
|
|
|
bool windSpeedStatus = (data[4] >> 3) & 0x1;
|
|
int windSpeedFix = ((data[4] & 0x7) << 6) | ((data[5] >> 2) & 0x3f);
|
|
int windSpeed = windSpeedFix; // knots
|
|
int windDirectionFix = ((data[5] & 0x3) << 6) | ((data[6] >> 2) & 0x3f);
|
|
int windDirection = windDirectionFix * 180.0f / 256.0f; // Degreees
|
|
bool windSpeedInconsistent = (windSpeed > 250.0f) || (!windSpeedStatus && ((windSpeedFix != 0) || (windDirectionFix != 0)));
|
|
|
|
int staticAirTemperatureFix = ((data[6] & 0x1) << 10) | ((data[7] & 0xff) << 2) | ((data[8] >> 6) & 0x3);
|
|
staticAirTemperatureFix = (staticAirTemperatureFix << 21) >> 21;
|
|
float staticAirTemperature = staticAirTemperatureFix * 0.25f;
|
|
bool staticAirTemperatureInconsistent = (staticAirTemperature < -80.0f) || (staticAirTemperature > 60.0f);
|
|
|
|
bool averageStaticPressureStatus = (data[8] >> 5) & 0x1;
|
|
int averageStaticPressureFix = ((data[8] & 0x1f) << 6) | ((data[9] >> 2) & 0x3f);
|
|
int averageStaticPressure = averageStaticPressureFix; // hPa
|
|
bool averageStaticPressureInconsistent = !averageStaticPressureStatus && (averageStaticPressureFix != 0);
|
|
|
|
bool turbulenceStatus = (data[9] >> 1) & 0x1;
|
|
int turbulence = ((data[9] & 0x1) << 1) | ((data[10] >> 7) & 0x1);
|
|
bool turbulenceInconsistent = !turbulenceStatus && (turbulence != 0);
|
|
|
|
bool humidityStatus = (data[10] >> 6) & 0x1;
|
|
int humidityFix = data[10] & 0x3f;
|
|
float humidity = humidityFix * 100.0f / 64.0f; // %
|
|
bool humidityInconsistent = (humidity > 100.0) || (!humidityStatus && (humidityFix != 0));
|
|
|
|
// Occasionally get frames: 20000000000000 or 08000000000000 - these seem unlikely to be BDS 4,4
|
|
bool noMetData = ((data[4] == 0x20) || (data[4] == 0x08)) && !(data[5] || data[6] || data[7] || data[8] || data[9] || data[10]);
|
|
|
|
bool bds_4_4 = !noMetData && !fomSourceInconsistent && !windSpeedInconsistent && !staticAirTemperatureInconsistent && !averageStaticPressureInconsistent && !turbulenceInconsistent && !humidityInconsistent;
|
|
|
|
// BDS 4,5 - Meteorological hazard report - MRAR - (Appendix E suggests a slightly different format in the future)
|
|
|
|
bool hazardTurbulenceStatus = (data[4] >> 7) & 0x1;
|
|
int hazardTurbulence = (data[4] >> 5) & 0x3;
|
|
bool hazardTurbulenceInconsistent = !hazardTurbulenceStatus && (hazardTurbulence != 0);
|
|
|
|
bool hazardWindShearStatus = (data[4] >> 4) & 0x1;
|
|
int hazardWindShear = (data[4] >> 2) & 0x3;
|
|
bool hazardWindShearInconsistent = !hazardWindShearStatus && (hazardWindShear != 0);
|
|
|
|
bool hazardMicroburstStatus = (data[4] >> 1) & 0x1;
|
|
int hazardMicroburst = ((data[4] & 0x1) << 1) | ((data[5] >> 7) & 0x1);
|
|
bool hazardMicroburstInconsistent = !hazardMicroburstStatus && (hazardMicroburst != 0);
|
|
|
|
bool hazardIcingStatus = (data[5] >> 6) & 0x1;
|
|
int hazardIcing = ((data[5] >> 4) & 0x3);
|
|
bool hazardIcingInconsistent = !hazardIcingStatus && (hazardIcing != 0);
|
|
|
|
bool hazardWakeVortexStatus = (data[5] >> 3) & 0x1;
|
|
int hazardWakeVortex = ((data[5] >> 1) & 0x3);
|
|
bool hazardWakeVortexInconsistent = !hazardWakeVortexStatus && (hazardWakeVortex != 0);
|
|
|
|
bool hazardStaticAirTemperatureStatus = data[5] & 0x1;
|
|
int hazardStaticAirTemperatureFix = ((data[6] & 0xff) << 2) | ((data[7] >> 6) & 0x3);
|
|
hazardStaticAirTemperatureFix = (hazardStaticAirTemperatureFix << 22) >> 22;
|
|
float hazardStaticAirTemperature = hazardStaticAirTemperatureFix * 0.25f; // deg C
|
|
bool hazardStaticAirTemperatureInconsistent = (hazardStaticAirTemperature < -80.0f) || (hazardStaticAirTemperature > 60.0f) || (!hazardStaticAirTemperatureStatus && (hazardStaticAirTemperatureFix != 0));
|
|
|
|
bool hazardAverageStaticPressureStatus = (data[7] >> 5) & 0x1;
|
|
int hazardAverageStaticPressureFix = ((data[7] & 0x1f) << 6) | ((data[8] >> 2) & 0x3f);
|
|
int hazardAverageStaticPressure = hazardAverageStaticPressureFix; // hPa
|
|
bool hazardAverageStaticPressureInconsistent = !hazardAverageStaticPressureStatus && (hazardAverageStaticPressureFix != 0);
|
|
|
|
bool hazardRadioHeightStatus = (data[8] >> 1) & 0x1;
|
|
int hazardRadioHeightFix = ((data[8] & 0x1) << 11) | ((data[9] & 0xff) << 3) | ((data[10] >> 5) & 0x7);
|
|
int hazardRadioHeight = hazardRadioHeightFix * 16; // Ft
|
|
bool hazardRadioHeightInconsistent = (hazardRadioHeight > maxAlt) || (!aircraft->m_onSurface && (hazardRadioHeight == 0)) || (!hazardRadioHeightStatus && (hazardRadioHeightFix != 0));
|
|
|
|
bool hazardReserveredInconsistent = (data[10] & 0x1f) != 0;
|
|
|
|
bool harzardIcingTempInconsistent = hazardIcingStatus && hazardStaticAirTemperatureStatus && (hazardIcing != 0) && ((hazardStaticAirTemperature >= 20.0f) || (hazardStaticAirTemperature <= -40.0f));
|
|
|
|
bool bds_4_5 = !hazardTurbulenceInconsistent && !hazardWindShearInconsistent && !hazardMicroburstInconsistent && !hazardIcingInconsistent
|
|
&& !hazardWakeVortexInconsistent && !hazardStaticAirTemperatureInconsistent && !hazardAverageStaticPressureInconsistent
|
|
&& !hazardRadioHeightInconsistent && !hazardReserveredInconsistent && !harzardIcingTempInconsistent;
|
|
|
|
// BDS 5,0 - Track and turn report - EHS
|
|
|
|
bool rollAngleStatus = (data[4] >> 7) & 0x1;
|
|
int rollAngleFix = ((data[4] & 0x7f) << 3) | ((data[5] >> 5) & 0x7);
|
|
rollAngleFix = (rollAngleFix << 22) >> 22;
|
|
float rollAngle = rollAngleFix * (45.0f/256.0f);
|
|
bool rollAngleInvalid = (rollAngle < -50.0f) || (rollAngle > 50.0f); // More than 50 deg bank unlikely for airliners
|
|
bool rollAngleInconsistent = ((abs(rollAngle) >= 1.0f) && aircraft->m_onSurface) || (!rollAngleStatus && (rollAngleFix != 0));
|
|
|
|
bool trueTrackAngleStatus = (data[5] >> 4) & 0x1;
|
|
int trueTrackAngleFix = ((data[5] & 0xf) << 7) | ((data[6] >> 1) & 0x7f);
|
|
trueTrackAngleFix = (trueTrackAngleFix << 21) >> 21;
|
|
float trueTrackAngle = trueTrackAngleFix * (90.0f/512.0f);
|
|
if (trueTrackAngle < 0.0f) {
|
|
trueTrackAngle += 360.0f;
|
|
}
|
|
bool trueTrackAngleInconsistent = (aircraft->m_headingValid && (abs(trueTrackAngle - aircraft->m_heading) > maxHeadingDiff))
|
|
|| (!trueTrackAngleStatus && (trueTrackAngleFix != 0));
|
|
|
|
bool groundSpeedStatus = data[6] & 0x1;
|
|
int groundSpeedFix = ((data[7] & 0xff) << 2) | ((data[8] >> 6) & 0x3);
|
|
int groundSpeed = groundSpeedFix * 2;
|
|
bool groundSpeedInconsistent = ((groundSpeed > 800) && (aircraft->m_emitterCategory != "High performance"))
|
|
|| (aircraft->m_groundspeedValid && (abs(aircraft->m_groundspeed - groundSpeed) > maxSpeedDiff))
|
|
|| (!groundSpeedStatus && (groundSpeedFix != 0));
|
|
|
|
bool trackAngleRateStatus = (data[8] >> 5) & 0x1;
|
|
int trackAngleRateFix = ((data[8] & 0x1f) << 5) | ((data[9] >> 3) & 0x1f);
|
|
trackAngleRateFix = (trackAngleRateFix << 22) >> 22;
|
|
float trackAngleRate = trackAngleRateFix * (8.0f/256.0f);
|
|
bool trackAngleRateInconsistent = !trackAngleRateStatus && (trackAngleRateFix != 0);
|
|
|
|
bool trueAirspeedStatus = (data[9] >> 2) & 0x1;
|
|
int trueAirspeedFix = ((data[9] & 0x3) << 8) | (data[10] & 0xff);
|
|
int trueAirspeed = trueAirspeedFix * 2;
|
|
bool trueAirspeedInconsistent = ((trueAirspeed > 575) && (aircraft->m_emitterCategory != "High performance"))
|
|
|| (aircraft->m_groundspeedValid && (abs(aircraft->m_groundspeed - trueAirspeed) > maxWind+maxSpeedDiff))
|
|
|| (!trueAirspeedStatus && (trueAirspeedFix != 0));
|
|
|
|
bool headwindStatus = groundSpeedStatus && trueAirspeedStatus;
|
|
int headwind = trueAirspeed - groundSpeed;
|
|
bool headwindInconsistent = abs(headwind) > maxWind;
|
|
|
|
bool bds_5_0 = !rollAngleInvalid && (!rollAngleInconsistent && !trueTrackAngleInconsistent && !groundSpeedInconsistent && !trackAngleRateInconsistent && !trueAirspeedInconsistent && !headwindInconsistent);
|
|
|
|
// BDS 5,1 - Position report coarse
|
|
|
|
bool positionValid = (data[4] >> 7) & 0x1;
|
|
|
|
int latitudeFix = ((data[4] & 0x3f) << 13) | ((data[5] & 0xff) << 5) | ((data[6] >> 3) & 0x1f);
|
|
latitudeFix = (latitudeFix << 12) >> 12;
|
|
float latitude = latitudeFix * (360.0f / 1048576.0f);
|
|
|
|
int longitudeFix = ((data[6] & 0x7) << 17) | ((data[7] & 0xff) << 9) | ((data[8] & 0xff) << 1) | ((data[9] >> 7) & 0x1);
|
|
longitudeFix = (longitudeFix << 12) >> 12;
|
|
float longitude = longitudeFix * (360.0f / 1048576.0f);
|
|
|
|
bool positionInconsistent = !aircraft->m_positionValid
|
|
|| (positionValid && aircraft->m_positionValid && ((abs(latitude - aircraft->m_latitude) > 2.0f) || (abs(longitude - aircraft->m_longitude) > 2.0f)))
|
|
|| (!positionValid && ((latitudeFix != 0) || (longitudeFix != 0)));
|
|
|
|
int pressureAltFix = ((data[9] & 0x7f) << 8) | (data[10] & 0xff);
|
|
pressureAltFix = (pressureAltFix << 17) >> 17;
|
|
int pressureAlt = pressureAltFix * 8;
|
|
bool pressureAltInconsistent = (pressureAlt > 50000) || (pressureAlt < -1000) || (positionValid && aircraft->m_altitudeValid && (abs(pressureAlt - aircraft->m_altitude) > 2000))
|
|
|| (!positionValid && (pressureAltFix != 0));
|
|
|
|
bool bds_5_1 = !positionInconsistent && !pressureAltInconsistent;
|
|
|
|
// BDS 5,3 - Air-referenced state vector
|
|
|
|
bool arMagHeadingStatus = (data[4] >> 7) & 1;
|
|
int arMagHeadingFix = ((data[4] & 0x7f) << 4) | ((data[5] >> 4) & 0xf);
|
|
float arMagHeading = arMagHeadingFix * 90.0f / 512.0f;
|
|
bool arMagHeadingInconsistent = (aircraft->m_headingValid && arMagHeadingStatus && (abs(aircraft->m_heading - arMagHeading) > maxHeadingDiff))
|
|
|| (!arMagHeadingStatus && (arMagHeadingFix != 0));
|
|
|
|
bool arIndicatedAirspeedStatus = (data[5] >> 3) & 0x1;
|
|
int arIndicatedAirspeedFix = ((data[5] & 0x7) << 7) | ((data[6] >> 1) & 0x7f);
|
|
int arIndicatedAirspeed = arIndicatedAirspeedFix; // knots
|
|
bool arIndicatedAirspeedInconsistent = ((arIndicatedAirspeed > 550) && (aircraft->m_emitterCategory != "High performance"))
|
|
|| (aircraft->m_groundspeedValid && (abs(aircraft->m_groundspeed - arIndicatedAirspeed) > maxWind+maxSpeedDiff))
|
|
|| (aircraft->m_indicatedAirspeedValid && (abs(aircraft->m_indicatedAirspeed - arIndicatedAirspeed) > maxSpeedDiff))
|
|
|| (arIndicatedAirspeedStatus && (arIndicatedAirspeed < 100) && !aircraft->m_onSurface && (aircraft->m_emitterCategory != "Light"))
|
|
|| (!arIndicatedAirspeedStatus && (arIndicatedAirspeedFix != 0));
|
|
|
|
bool arMachStatus = data[6] & 0x1;
|
|
int arMachFix = ((data[7] & 0xff) << 1) | ((data[8] >> 7) & 0x1);
|
|
float arMach = arMachFix * 0.008f;
|
|
bool arMachInconsistent = ((arMach >= 1.0f) && (aircraft->m_emitterCategory != "High performance"))
|
|
|| (!arMachStatus && (arMachFix != 0));
|
|
|
|
bool arTrueAirspeedStatus = (data[8] >> 6) & 0x1;
|
|
int arTureAirspeedFix = ((data[8] & 0x3f) << 6) | ((data[9] >> 2) & 0x3f);
|
|
float arTrueAirspeed = arTureAirspeedFix * 0.5f; // knots
|
|
bool arTrueAirspeedInconsistent = ((arTrueAirspeed > 550) && (aircraft->m_emitterCategory != "High performance"))
|
|
|| (aircraft->m_groundspeedValid && (abs(aircraft->m_groundspeed - arTrueAirspeed) > maxWind+maxSpeedDiff))
|
|
|| (aircraft->m_trueAirspeedValid && (abs(aircraft->m_trueAirspeed - arTrueAirspeed) > maxSpeedDiff))
|
|
|| (arTrueAirspeedStatus && (arTureAirspeedFix < 100) && !aircraft->m_onSurface && (aircraft->m_emitterCategory != "Light"))
|
|
|| (!arTrueAirspeedStatus && (arTureAirspeedFix != 0));
|
|
|
|
bool arAltitudeRateStatus = (data[9] >> 1) & 0x1;
|
|
int arAltitudeRateFix = ((data[9] & 0x1) << 8) | (data[10] & 0xff);
|
|
int arAltitudeRate = arAltitudeRateFix * 64; // Ft/min
|
|
bool arAltitudeRateInconsistent = (abs(arAltitudeRate) > 6000) || (!arAltitudeRateStatus && (arAltitudeRateFix != 0));
|
|
|
|
bool bds_5_3 = !arMagHeadingInconsistent && !arIndicatedAirspeedInconsistent && !arMachInconsistent && !arTrueAirspeedInconsistent && !arAltitudeRateInconsistent;
|
|
|
|
// BDS 6,0 - Heading and speed report - EHS
|
|
|
|
bool magHeadingStatus = (data[4] >> 7) & 1;
|
|
int magHeadingFix = ((data[4] & 0x7f) << 4) | ((data[6] >> 4) & 0xf);
|
|
magHeadingFix = (magHeadingFix << 21) >> 21;
|
|
float magHeading = magHeadingFix * (90.0f / 512.0f);
|
|
if (magHeading < 0.0f) {
|
|
magHeading += 360.f;
|
|
}
|
|
bool magHeadingInconsistent = (aircraft->m_headingValid && magHeadingStatus && (abs(aircraft->m_heading - magHeading) > maxHeadingDiff))
|
|
|| (!magHeadingStatus && (magHeadingFix != 0));
|
|
|
|
bool indicatedAirspeedStatus = (data[5] >> 3) & 0x1;
|
|
int indicatedAirspeedFix = ((data[5] & 0x7) << 7) | ((data[6] >> 1) & 0x7f);
|
|
int indicatedAirspeed = indicatedAirspeedFix;
|
|
bool indicatedAirspeedInconsistent = ((indicatedAirspeed > 550) && (aircraft->m_emitterCategory != "High performance"))
|
|
|| (aircraft->m_groundspeedValid && (abs(aircraft->m_groundspeed - indicatedAirspeed) > maxWind+maxSpeedDiff))
|
|
|| (aircraft->m_indicatedAirspeedValid && (abs(aircraft->m_indicatedAirspeed - indicatedAirspeed) > maxSpeedDiff))
|
|
|| (indicatedAirspeedStatus && (indicatedAirspeed < 100) && !aircraft->m_onSurface && (aircraft->m_emitterCategory != "Light"))
|
|
|| (!indicatedAirspeedStatus && (indicatedAirspeedFix != 0));
|
|
|
|
bool machStatus = data[6] & 0x1;
|
|
int machFix = ((data[7] & 0xff) << 2) | ((data[8] >> 6) & 0x3);
|
|
float mach = machFix * 2.048f / 512.0f;
|
|
bool machInconsistent = ((mach >= 1.0f) && (aircraft->m_emitterCategory != "High performance"))
|
|
|| (!machStatus && (machFix != 0));
|
|
|
|
bool baroAltRateStatus = (data[8] >> 5) & 0x1;
|
|
int baroAltRateFix = ((data[8] & 0x1f) << 5) | ((data[9] >> 3) & 0x1f);
|
|
baroAltRateFix = (baroAltRateFix << 22) >> 22;
|
|
int baroAltRate = baroAltRateFix * 32; // ft/min
|
|
bool baroAltRateInconsistent = (abs(baroAltRate) > 6000) || (aircraft->m_verticalRateValid && abs(baroAltRate - aircraft->m_verticalRate) > 2000)
|
|
|| (!baroAltRateStatus && (baroAltRateFix != 0));
|
|
|
|
bool verticalVelStatus = (data[9] >> 2) & 0x1;
|
|
int verticalVelFix = ((data[9] & 0x3) << 8) | (data[10] & 0xff);
|
|
verticalVelFix = (verticalVelFix << 22) >> 22;
|
|
int verticalVel = verticalVelFix * 32; // ft/min
|
|
bool verticalVelInconsistent = (abs(verticalVel) > 6000) || (aircraft->m_verticalRateValid && abs(verticalVel - aircraft->m_verticalRate) > 2000)
|
|
|| (!verticalVelStatus && (verticalVelFix != 0));
|
|
|
|
bool bds_6_0 = !magHeadingInconsistent && !indicatedAirspeedInconsistent && !machInconsistent && !baroAltRateInconsistent && !verticalVelInconsistent;
|
|
|
|
int possibleMatches = bds_1_0 + bds_1_7 + bds_2_0 + bds_2_1 + bds_3_0 + bds_4_0 + bds_4_1 + bds_4_4 + bds_4_5 + bds_5_0 + bds_5_1 + bds_5_3 + bds_6_0;
|
|
|
|
if (possibleMatches == 1)
|
|
{
|
|
if (bds_1_7)
|
|
{
|
|
// Some of these bits are dynamic, so can't assume that because a bit isn't set,
|
|
// that message is not ever supported
|
|
aircraft->m_bdsCapabilitiesValid = true;
|
|
aircraft->m_bdsCapabilities[0][5] |= cap_0_5;
|
|
aircraft->m_bdsCapabilities[0][6] |= cap_0_6;
|
|
aircraft->m_bdsCapabilities[0][7] |= cap_0_7;
|
|
aircraft->m_bdsCapabilities[0][8] |= cap_0_8;
|
|
aircraft->m_bdsCapabilities[0][9] |= cap_0_9;
|
|
aircraft->m_bdsCapabilities[0][10] |= cap_0_a;
|
|
aircraft->m_bdsCapabilities[2][0] |= cap_2_0;
|
|
aircraft->m_bdsCapabilities[2][1] |= cap_2_1;
|
|
aircraft->m_bdsCapabilities[4][0] |= cap_4_0;
|
|
aircraft->m_bdsCapabilities[4][1] |= cap_4_1;
|
|
aircraft->m_bdsCapabilities[4][2] |= cap_4_2;
|
|
aircraft->m_bdsCapabilities[4][3] |= cap_4_3;
|
|
aircraft->m_bdsCapabilities[4][4] |= cap_4_4;
|
|
aircraft->m_bdsCapabilities[4][8] |= cap_4_8;
|
|
aircraft->m_bdsCapabilities[5][0] |= cap_5_0;
|
|
aircraft->m_bdsCapabilities[5][1] |= cap_5_1;
|
|
aircraft->m_bdsCapabilities[5][2] |= cap_5_2;
|
|
aircraft->m_bdsCapabilities[5][3] |= cap_5_4;
|
|
aircraft->m_bdsCapabilities[5][4] |= cap_5_5;
|
|
aircraft->m_bdsCapabilities[5][5] |= cap_5_6;
|
|
aircraft->m_bdsCapabilities[5][6] |= cap_5_6;
|
|
aircraft->m_bdsCapabilities[5][15] |= cap_5_f;
|
|
aircraft->m_bdsCapabilities[6][0] |= cap_6_0;
|
|
}
|
|
if (bds_2_0)
|
|
{
|
|
updatedCallsign = aircraft->m_callsign != callsignTrimmed;
|
|
if (updatedCallsign)
|
|
{
|
|
aircraft->m_callsign = callsignTrimmed;
|
|
aircraft->m_callsignItem->setText(aircraft->m_callsign);
|
|
atcCallsign(aircraft);
|
|
callsignToFlight(aircraft);
|
|
}
|
|
}
|
|
if (bds_2_1)
|
|
{
|
|
qDebug() << "BDS 2,1 - "
|
|
<< "ICAO:" << aircraft->m_icaoHex
|
|
<< "aircraftRegistration:" << aircraftRegistrationString
|
|
<< "airlineRegistration:" << airlineRegistrationString
|
|
<< "m_bdsCapabilities[2][1]: " << aircraft->m_bdsCapabilities[2][1]
|
|
<< "m_bdsCapabilitiesValid: " << aircraft->m_bdsCapabilitiesValid;
|
|
|
|
if (!aircraftRegistrationString.isEmpty()) {
|
|
aircraft->m_registrationItem->setText(aircraftRegistrationString);
|
|
}
|
|
}
|
|
if (bds_4_0)
|
|
{
|
|
// Could use targetAltSource here, but yet to see it set to anything other than unknown
|
|
if (mcpSelectedAltStatus)
|
|
{
|
|
aircraft->m_selAltitude = mcpSelectedAlt;
|
|
aircraft->m_selAltitudeValid = true;
|
|
if (m_settings.m_siUnits) {
|
|
aircraft->m_selAltitudeItem->setData(Qt::DisplayRole, Units::feetToIntegerMetres(aircraft->m_selAltitude));
|
|
} else {
|
|
aircraft->m_selAltitudeItem->setData(Qt::DisplayRole, roundTo50Feet(aircraft->m_selAltitude));
|
|
}
|
|
}
|
|
else if (fmsSelectedAltStatus)
|
|
{
|
|
aircraft->m_selAltitude = fmsSelectedAlt;
|
|
aircraft->m_selAltitudeValid = true;
|
|
if (m_settings.m_siUnits) {
|
|
aircraft->m_selAltitudeItem->setData(Qt::DisplayRole, Units::feetToIntegerMetres(aircraft->m_selAltitude));
|
|
} else {
|
|
aircraft->m_selAltitudeItem->setData(Qt::DisplayRole, roundTo50Feet(aircraft->m_selAltitude));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
aircraft->m_selAltitude = 0;
|
|
aircraft->m_selAltitudeValid = false;
|
|
aircraft->m_selAltitudeItem->setText("");
|
|
}
|
|
|
|
if (baroSettingStatus)
|
|
{
|
|
aircraft->m_baro = baroSetting;
|
|
aircraft->m_baroValid = true;
|
|
aircraft->m_baroItem->setData(Qt::DisplayRole, std::round(aircraft->m_baro));
|
|
}
|
|
|
|
if (modeStatus)
|
|
{
|
|
QString mode = "";
|
|
if (vnavMode) {
|
|
mode = mode + "VNAV ";
|
|
}
|
|
if (altHoldMode) {
|
|
mode = mode + "HOLD ";
|
|
}
|
|
if (approachMode) {
|
|
mode = mode + "APP ";
|
|
}
|
|
mode = mode.trimmed();
|
|
aircraft->m_vModeItem->setText(mode);
|
|
}
|
|
}
|
|
if (bds_4_1)
|
|
{
|
|
qDebug() << "BDS 4,1 - "
|
|
<< "ICAO:" << aircraft->m_icaoHex
|
|
<< "waypoint:" << waypointString
|
|
<< "m_bdsCapabilities[4][1]: " << aircraft->m_bdsCapabilities[4][1]
|
|
<< "m_bdsCapabilitiesValid: " << aircraft->m_bdsCapabilitiesValid;
|
|
}
|
|
if (bds_4_4)
|
|
{
|
|
if (fomSource != 0) // Ignore FOM "invalid"
|
|
{
|
|
if (windSpeedStatus)
|
|
{
|
|
if (m_settings.m_siUnits) {
|
|
aircraft->m_groundspeedItem->setData(Qt::DisplayRole, Units::knotsToIntegerKPH(aircraft->m_groundspeed));
|
|
} else {
|
|
aircraft->m_windSpeedItem->setData(Qt::DisplayRole, windSpeed);
|
|
}
|
|
aircraft->m_windDirItem->setData(Qt::DisplayRole, windDirection);
|
|
// Not clear if air temp depends on the previous status bit
|
|
aircraft->m_staticAirTempItem->setData(Qt::DisplayRole, (int)std::round(staticAirTemperature));
|
|
}
|
|
if (averageStaticPressureStatus) {
|
|
aircraft->m_staticPressureItem->setData(Qt::DisplayRole, averageStaticPressure);
|
|
}
|
|
if (humidityStatus) {
|
|
aircraft->m_humidityItem->setData(Qt::DisplayRole, (int)std::round(humidity));
|
|
}
|
|
}
|
|
}
|
|
if (bds_4_5)
|
|
{
|
|
qDebug() << "BDS 4,5 - "
|
|
<< "ICAO:" << aircraft->m_icaoHex
|
|
<< "hazardTurbulence:" << m_hazardSeverity[hazardTurbulence]
|
|
<< "hazardWindShear:" << m_hazardSeverity[hazardWindShear]
|
|
<< "hazardMicroburst:" << m_hazardSeverity[hazardMicroburst]
|
|
<< "hazardIcing:" << m_hazardSeverity[hazardIcing]
|
|
<< "hazardWakeVortex:" << m_hazardSeverity[hazardWakeVortex]
|
|
<< "hazardStaticAirTemperature:" << hazardStaticAirTemperature << "C"
|
|
<< "hazardAverageStaticPressure:" << hazardAverageStaticPressure << "hPA"
|
|
<< "hazardRadioHeight:" << hazardRadioHeight << "ft"
|
|
<< "(Aircraft Alt: " << aircraft->m_altitude << "ft)"
|
|
<< "m_bdsCapabilities[4][5]: " << aircraft->m_bdsCapabilities[4][5]
|
|
<< "m_bdsCapabilitiesValid: " << aircraft->m_bdsCapabilitiesValid;
|
|
;
|
|
}
|
|
if (bds_5_0)
|
|
{
|
|
if (rollAngleStatus)
|
|
{
|
|
aircraft->m_roll = rollAngle;
|
|
aircraft->m_rollValid = true;
|
|
aircraft->m_rollItem->setData(Qt::DisplayRole, std::round(aircraft->m_roll));
|
|
}
|
|
if (trueTrackAngleStatus)
|
|
{
|
|
aircraft->m_heading = trueTrackAngle;
|
|
aircraft->m_headingValid = true;
|
|
aircraft->m_headingDateTime = dateTime;
|
|
aircraft->m_headingItem->setData(Qt::DisplayRole, std::round(aircraft->m_heading));
|
|
aircraft->m_orientationDateTime = dateTime;
|
|
}
|
|
if (groundSpeedStatus)
|
|
{
|
|
aircraft->m_groundspeed = groundSpeed;
|
|
aircraft->m_groundspeedValid = true;
|
|
if (m_settings.m_siUnits) {
|
|
aircraft->m_groundspeedItem->setData(Qt::DisplayRole, Units::knotsToIntegerKPH(aircraft->m_groundspeed));
|
|
} else {
|
|
aircraft->m_groundspeedItem->setData(Qt::DisplayRole, aircraft->m_groundspeed);
|
|
}
|
|
}
|
|
if (trackAngleRateStatus)
|
|
{
|
|
aircraft->m_turnRate = trackAngleRate;
|
|
aircraft->m_turnRateValid = true;
|
|
aircraft->m_turnRateItem->setData(Qt::DisplayRole, std::round(aircraft->m_turnRate*10.0f)/10.0f);
|
|
}
|
|
if (trueAirspeedStatus)
|
|
{
|
|
aircraft->m_trueAirspeed = trueAirspeed;
|
|
aircraft->m_trueAirspeedValid = true;
|
|
if (m_settings.m_siUnits) {
|
|
aircraft->m_trueAirspeedItem->setData(Qt::DisplayRole, Units::knotsToIntegerKPH(aircraft->m_trueAirspeed));
|
|
} else {
|
|
aircraft->m_trueAirspeedItem->setData(Qt::DisplayRole, aircraft->m_trueAirspeed);
|
|
}
|
|
}
|
|
if (headwindStatus)
|
|
{
|
|
if (m_settings.m_siUnits) {
|
|
aircraft->m_headwindItem->setData(Qt::DisplayRole, Units::knotsToIntegerKPH(headwind));
|
|
} else {
|
|
aircraft->m_headwindItem->setData(Qt::DisplayRole, headwind);
|
|
}
|
|
}
|
|
}
|
|
if (bds_5_1)
|
|
{
|
|
// Position is specified as "coarse" - is it worth using?
|
|
qDebug() << "BDS 5,1 - "
|
|
<< "ICAO:" << aircraft->m_icaoHex
|
|
<< "latitude:" << latitude << "(ADS-B:" << aircraft->m_latitude << ") "
|
|
<< "longitude:" << longitude << "(ADS-B:" << aircraft->m_longitude << ") "
|
|
<< "pressureAlt:" << pressureAlt << "(ADS-B:" << aircraft->m_altitude << ")"
|
|
<< "m_bdsCapabilities[5][1]: " << aircraft->m_bdsCapabilities[5][1]
|
|
<< "m_bdsCapabilitiesValid: " << aircraft->m_bdsCapabilitiesValid;
|
|
;
|
|
}
|
|
if (bds_5_3)
|
|
{
|
|
qDebug() << "BDS 5,3 - "
|
|
<< "ICAO:" << aircraft->m_icaoHex
|
|
<< "arMagHeading:" << arMagHeading << "(ADS-B:" << aircraft->m_heading << ") "
|
|
<< "arIndicatedAirspeed:" << arIndicatedAirspeed << "knts" << "(ADS-B GS: " << aircraft->m_groundspeed << ") "
|
|
<< "arMach:" << arMach
|
|
<< "arTrueAirspeed:" << arTrueAirspeed << "knts"
|
|
<< "arAltitudeRate:" << arAltitudeRate << "ft/min"
|
|
<< "m_bdsCapabilities[5][3]: " << aircraft->m_bdsCapabilities[5][3]
|
|
<< "m_bdsCapabilitiesValid: " << aircraft->m_bdsCapabilitiesValid;
|
|
;
|
|
}
|
|
if (bds_6_0)
|
|
{
|
|
if (indicatedAirspeedStatus)
|
|
{
|
|
aircraft->m_indicatedAirspeed = indicatedAirspeed;
|
|
aircraft->m_indicatedAirspeedValid = true;
|
|
if (m_settings.m_siUnits) {
|
|
aircraft->m_indicatedAirspeedItem->setData(Qt::DisplayRole, Units::knotsToIntegerKPH(aircraft->m_indicatedAirspeed));
|
|
} else {
|
|
aircraft->m_indicatedAirspeedItem->setData(Qt::DisplayRole, aircraft->m_indicatedAirspeed);
|
|
}
|
|
}
|
|
if (machStatus)
|
|
{
|
|
aircraft->m_mach = mach;
|
|
aircraft->m_machValid = true;
|
|
aircraft->m_machItem->setData(Qt::DisplayRole, aircraft->m_mach);
|
|
}
|
|
if (verticalVelStatus)
|
|
{
|
|
aircraft->m_verticalRate = verticalVel;
|
|
aircraft->m_verticalRateValid = true;
|
|
if (m_settings.m_siUnits) {
|
|
aircraft->m_verticalRateItem->setData(Qt::DisplayRole, Units::feetPerMinToIntegerMetresPerSecond(aircraft->m_verticalRate));
|
|
} else {
|
|
aircraft->m_verticalRateItem->setData(Qt::DisplayRole, aircraft->m_verticalRate);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bds_5_0 || bds_6_0) {
|
|
calcAirTemp(aircraft);
|
|
}
|
|
}
|
|
else if (false) // Enable to debug multiple matching frames
|
|
{
|
|
qDebug() << "DF" << df
|
|
<< "matches" << possibleMatches
|
|
<< "bds_1_0" << bds_1_0
|
|
<< "bds_1_7" << bds_1_7
|
|
<< "bds_2_0" << bds_2_0
|
|
<< "bds_2_1" << bds_2_1
|
|
<< "bds_3_0" << bds_3_0
|
|
<< "bds_4_0" << bds_4_0
|
|
<< "bds_4_1" << bds_4_1
|
|
<< "bds_4_4" << bds_4_4
|
|
<< "bds_4_5" << bds_4_5
|
|
<< "bds_5_0" << bds_5_0
|
|
<< "bds_5_1" << bds_5_1
|
|
<< "bds_5_3" << bds_5_3
|
|
<< "bds_6_0" << bds_6_0
|
|
;
|
|
|
|
qDebug() << data.toHex();
|
|
|
|
qDebug() << (bds_1_0 ? "+" : "-")
|
|
<< "BDS 1,0 - ";
|
|
qDebug() << (bds_1_7 ? "+" : "-")
|
|
<< "BDS 1,7 - "
|
|
<< "ICAO:" << aircraft->m_icaoHex
|
|
<< "BDS:" << caps.join(" ");
|
|
qDebug() << (bds_2_0 ? "+" : "-")
|
|
<< "BDS 2,0 - "
|
|
<< "ICAO:" << aircraft->m_icaoHex
|
|
<< "Callsign:" << callsignTrimmed;
|
|
qDebug() << (bds_2_1 ? "+" : "-")
|
|
<< "BDS 2,1 - "
|
|
<< "ICAO:" << aircraft->m_icaoHex
|
|
<< "aircraftRegistration:" << aircraftRegistrationString
|
|
<< "airlineRegistration:" << airlineRegistrationString
|
|
<< "m_bdsCapabilities[2][1]: " << aircraft->m_bdsCapabilities[2][1]
|
|
<< "m_bdsCapabilitiesValid: " << aircraft->m_bdsCapabilitiesValid;
|
|
qDebug() << (bds_3_0 ? "+" : "-")
|
|
<< "BDS 3,0 - ";
|
|
qDebug() << (bds_4_0 ? "+" : "-")
|
|
<< "BDS 4,0 - "
|
|
<< "ICAO:" << aircraft->m_icaoHex
|
|
<< "mcpSelectedAlt:" << mcpSelectedAlt << "ft"
|
|
<< "fmsSelectedAlt:" << fmsSelectedAlt << "ft"
|
|
<< "baroSetting:" << (baroSettingStatus ? QString::number(baroSetting) : "invalid") << (baroSettingStatus ? "mb" : "")
|
|
<< "vnav: " << vnavMode
|
|
<< "altHold: " << altHoldMode
|
|
<< "approach: " << approachMode
|
|
<< "targetAltSource:" << targetAltSource
|
|
<< "m_bdsCapabilities[4][0]: " << aircraft->m_bdsCapabilities[4][0]
|
|
<< "m_bdsCapabilitiesValid: " << aircraft->m_bdsCapabilitiesValid;
|
|
qDebug() << (bds_4_1 ? "+" : "-")
|
|
<< "BDS 4,1 - "
|
|
<< "ICAO:" << aircraft->m_icaoHex
|
|
<< "waypoint:" << waypointString
|
|
<< "m_bdsCapabilities[4][1]: " << aircraft->m_bdsCapabilities[4][1]
|
|
<< "m_bdsCapabilitiesValid: " << aircraft->m_bdsCapabilitiesValid;
|
|
qDebug() << (bds_4_4 ? "+" : "-")
|
|
<< "BDS 4,4 - "
|
|
<< "ICAO:" << aircraft->m_icaoHex
|
|
<< "fomSource:" << m_fomSources[fomSource]
|
|
<< "windSpeed:" << windSpeed << "knts"
|
|
<< "windDirection:" << windDirection << "deg"
|
|
<< "staticAirTemperature:" << staticAirTemperature << "C"
|
|
<< "averageStaticPressure:" << averageStaticPressure << "hPa"
|
|
<< "turbulence:" << turbulence
|
|
<< "humidity:" << humidity << "%"
|
|
<< "m_bdsCapabilities[4][4]: " << aircraft->m_bdsCapabilities[4][4]
|
|
<< "m_bdsCapabilitiesValid: " << aircraft->m_bdsCapabilitiesValid;
|
|
qDebug() << (bds_4_5 ? "+" : "-")
|
|
<< "BDS 4,5 - "
|
|
<< "ICAO:" << aircraft->m_icaoHex
|
|
<< "hazardTurbulence:" << m_hazardSeverity[hazardTurbulence]
|
|
<< "hazardWindShear:" << m_hazardSeverity[hazardWindShear]
|
|
<< "hazardMicroburst:" << m_hazardSeverity[hazardMicroburst]
|
|
<< "hazardIcing:" << m_hazardSeverity[hazardIcing]
|
|
<< "hazardWakeVortex:" << m_hazardSeverity[hazardWakeVortex]
|
|
<< "hazardStaticAirTemperature:" << hazardStaticAirTemperature << "C"
|
|
<< "hazardAverageStaticPressure:" << hazardAverageStaticPressure << "hPA"
|
|
<< "hazardRadioHeight:" << hazardRadioHeight << "ft"
|
|
<< "m_bdsCapabilities[4][5]: " << aircraft->m_bdsCapabilities[4][5]
|
|
<< "m_bdsCapabilitiesValid: " << aircraft->m_bdsCapabilitiesValid;
|
|
qDebug() << (bds_5_0 ? "+" : "-")
|
|
<< "BDS 5,0 - "
|
|
<< "ICAO:" << aircraft->m_icaoHex
|
|
<< "rollAngle:" << rollAngle
|
|
<< "trueTrackAngle:" << trueTrackAngle
|
|
<< "trackAngleRate: " << trackAngleRate
|
|
<< "groundSpeed:" << groundSpeed
|
|
<< "trueAirspeed:" << trueAirspeed
|
|
<< "headwind:" << headwind
|
|
<< "(ADS-B GS: " << aircraft->m_groundspeed << ")"
|
|
<< "(ADS-B TAS: " << aircraft->m_trueAirspeed << ")"
|
|
<< "(ADS-B heading:" << aircraft->m_heading << ")"
|
|
<< "m_bdsCapabilities[5][0]: " << aircraft->m_bdsCapabilities[5][0]
|
|
<< "m_bdsCapabilitiesValid: " << aircraft->m_bdsCapabilitiesValid;
|
|
qDebug() << (bds_5_1 ? "+" : "-")
|
|
<< "BDS 5,1 - "
|
|
<< "ICAO:" << aircraft->m_icaoHex
|
|
<< "latitude:" << latitude << "(ADS-B:" << aircraft->m_latitude << ") "
|
|
<< "longitude:" << longitude << "(ADS-B:" << aircraft->m_longitude << ") "
|
|
<< "pressureAlt:" << pressureAlt << "(ADS-B:" << aircraft->m_altitude << ")"
|
|
<< "m_bdsCapabilities[5][1]: " << aircraft->m_bdsCapabilities[5][1]
|
|
<< "m_bdsCapabilitiesValid: " << aircraft->m_bdsCapabilitiesValid;
|
|
qDebug() << (bds_5_3 ? "+" : "-")
|
|
<< "BDS 5,3 - "
|
|
<< "ICAO:" << aircraft->m_icaoHex
|
|
<< "arMagHeading:" << arMagHeading << "(ADS-B:" << aircraft->m_heading << ") "
|
|
<< "arIndicatedAirspeed:" << arIndicatedAirspeed << "knts" << "(ADS-B GS: " << aircraft->m_groundspeed << ") "
|
|
<< "arMach:" << arMach
|
|
<< "arTrueAirspeed:" << arTrueAirspeed << "knts"
|
|
<< "arAltitudeRate:" << arAltitudeRate << "ft/min"
|
|
<< "arMagHeadingInconsistent" << arMagHeadingInconsistent << "arIndicatedAirspeedInconsistent" << arIndicatedAirspeedInconsistent << "arMachInconsistent" << arMachInconsistent << "arTrueAirspeedInconsistent" << arTrueAirspeedInconsistent
|
|
<< "m_bdsCapabilities[5][3]: " << aircraft->m_bdsCapabilities[5][3]
|
|
<< "m_bdsCapabilitiesValid: " << aircraft->m_bdsCapabilitiesValid;
|
|
qDebug() << (bds_6_0 ? "+" : "-")
|
|
<< "BDS 6,0 - "
|
|
<< "ICAO:" << aircraft->m_icaoHex
|
|
<< "magHeading:" << magHeading << "(ADS-B:" << aircraft->m_heading << ") "
|
|
<< "indicatedAirspeed:" << indicatedAirspeed << "knts" << "(ADS-B GS: " << aircraft->m_groundspeed << ") "
|
|
<< "mach:" << mach
|
|
<< "baroAltRate:" << baroAltRate << "ft/min"
|
|
<< "verticalVel:" << verticalVel << "ft/min"
|
|
<< "magHeadingInconsistent " << magHeadingInconsistent << "indicatedAirspeedInconsistent" << indicatedAirspeedInconsistent << "machInconsistent" << machInconsistent << "baroAltRateInconsistent" << baroAltRateInconsistent << "verticalVelInconsistent" << verticalVelInconsistent
|
|
<< "m_bdsCapabilities[6][0]: " << aircraft->m_bdsCapabilities[6][0]
|
|
<< "m_bdsCapabilitiesValid: " << aircraft->m_bdsCapabilitiesValid;
|
|
}
|
|
}
|
|
}
|
|
|
|
QList<SWGSDRangel::SWGMapAnimation *> * ADSBDemodGUI::animate(QDateTime dateTime, Aircraft *aircraft)
|
|
{
|
|
QList<SWGSDRangel::SWGMapAnimation *> *animations = new QList<SWGSDRangel::SWGMapAnimation *>();
|
|
|
|
const int gearDownSpeed = 150;
|
|
const int gearUpAltitude = 200;
|
|
const int gearUpVerticalRate = 1000;
|
|
const int accelerationHeight = 1500;
|
|
const int flapsRetractAltitude = 2000;
|
|
const int flapsCleanSpeed = 200;
|
|
|
|
bool debug = false;
|
|
|
|
// Landing gear should be down when on surface
|
|
// Check speed in case we get a mixture of surface and airbourne positions
|
|
// during take-off
|
|
if ( aircraft->m_onSurface
|
|
&& !aircraft->m_gearDown
|
|
&& ( (aircraft->m_groundspeedValid && (aircraft->m_groundspeed < 80))
|
|
|| !aircraft->m_groundspeedValid
|
|
)
|
|
)
|
|
{
|
|
if (debug) {
|
|
qDebug() << "Gear down as on surface " << aircraft->m_icaoHex;
|
|
}
|
|
animations->append(gearAnimation(dateTime, false));
|
|
aircraft->m_gearDown = true;
|
|
}
|
|
|
|
// Flaps when on the surface
|
|
if (aircraft->m_onSurface && aircraft->m_groundspeedValid)
|
|
{
|
|
if ((aircraft->m_groundspeed <= 20) && (aircraft->m_flaps != 0.0))
|
|
{
|
|
// No flaps when stationary / taxiing
|
|
if (debug) {
|
|
qDebug() << "Parking flaps " << aircraft->m_icaoHex;
|
|
}
|
|
animations->append(flapsAnimation(dateTime, aircraft->m_flaps, 0.0));
|
|
animations->append(slatsAnimation(dateTime, true));
|
|
aircraft->m_flaps = 0.0;
|
|
}
|
|
else if ((aircraft->m_groundspeed >= 30) && (aircraft->m_flaps < 0.25))
|
|
{
|
|
// Flaps for takeoff
|
|
if (debug) {
|
|
qDebug() << "Takeoff flaps " << aircraft->m_icaoHex;
|
|
}
|
|
animations->append(flapsAnimation(dateTime, aircraft->m_flaps, 0.25));
|
|
animations->append(slatsAnimation(dateTime, false));
|
|
aircraft->m_flaps = 0.25;
|
|
}
|
|
}
|
|
|
|
// Pitch up on take-off
|
|
if ( aircraft->m_gearDown
|
|
&& !aircraft->m_onSurface
|
|
&& ( (aircraft->m_verticalRateValid && (aircraft->m_verticalRate > 300))
|
|
|| (aircraft->m_runwayAltitudeValid && (aircraft->m_altitude > (aircraft->m_runwayAltitude + gearUpAltitude/2)))
|
|
)
|
|
)
|
|
{
|
|
if (debug) {
|
|
qDebug() << "Pitch up " << aircraft->m_icaoHex;
|
|
}
|
|
aircraft->m_pitchEst = 5.0;
|
|
}
|
|
|
|
// Retract landing gear after take-off
|
|
if ( aircraft->m_gearDown
|
|
&& !aircraft->m_onSurface
|
|
&& ( (aircraft->m_verticalRateValid && (aircraft->m_verticalRate > 1000))
|
|
|| (aircraft->m_runwayAltitudeValid && (aircraft->m_altitude > (aircraft->m_runwayAltitude + gearUpAltitude)))
|
|
)
|
|
)
|
|
{
|
|
if (debug) {
|
|
qDebug() << "Gear up " << aircraft->m_icaoHex
|
|
<< " VR " << (aircraft->m_verticalRateValid && (aircraft->m_verticalRate > gearUpVerticalRate))
|
|
<< " Alt " << (aircraft->m_runwayAltitudeValid && (aircraft->m_altitude > (aircraft->m_runwayAltitude + gearUpAltitude)))
|
|
<< "m_altitude " << aircraft->m_altitude << " aircraft->m_runwayAltitude " << aircraft->m_runwayAltitude;
|
|
}
|
|
aircraft->m_pitchEst = 10.0;
|
|
animations->append(gearAnimation(dateTime.addSecs(2), true));
|
|
aircraft->m_gearDown = false;
|
|
}
|
|
|
|
// Reduce pitch at acceleration height
|
|
if ( (aircraft->m_flaps > 0.0)
|
|
&& (aircraft->m_runwayAltitudeValid && (aircraft->m_altitude > (aircraft->m_runwayAltitude + accelerationHeight)))
|
|
)
|
|
{
|
|
aircraft->m_pitchEst = 5.0;
|
|
}
|
|
|
|
// Retract flaps/slats after take-off
|
|
// Should be after acceleration altitude (1500-3000ft AAL)
|
|
// And before max speed for flaps is reached (215knt for A320, 255KIAS for 777)
|
|
if ( (aircraft->m_flaps > 0.0)
|
|
&& ( (aircraft->m_runwayAltitudeValid && (aircraft->m_altitude > (aircraft->m_runwayAltitude + flapsRetractAltitude)))
|
|
|| (aircraft->m_groundspeedValid && (aircraft->m_groundspeed > flapsCleanSpeed))
|
|
)
|
|
)
|
|
{
|
|
if (debug) {
|
|
qDebug() << "Retract flaps " << aircraft->m_icaoHex
|
|
<< " Spd " << (aircraft->m_groundspeedValid && (aircraft->m_groundspeed > flapsCleanSpeed))
|
|
<< " Alt " << (aircraft->m_runwayAltitudeValid && (aircraft->m_altitude > (aircraft->m_runwayAltitude + flapsRetractAltitude)));
|
|
}
|
|
animations->append(flapsAnimation(dateTime, aircraft->m_flaps, 0.0));
|
|
animations->append(slatsAnimation(dateTime, true));
|
|
aircraft->m_flaps = 0.0;
|
|
// Clear runway information
|
|
aircraft->m_runwayAltitudeValid = false;
|
|
aircraft->m_runwayAltitude = 0.0;
|
|
}
|
|
|
|
// Extend flaps for approach and landing
|
|
// We don't know airport elevation, so just base on speed and descent rate
|
|
// Vertical rate can go negative during take-off, so we check m_runwayAltitudeValid
|
|
if (!aircraft->m_onSurface
|
|
&& !aircraft->m_runwayAltitudeValid
|
|
&& (aircraft->m_verticalRateValid && (aircraft->m_verticalRate < 0))
|
|
&& aircraft->m_groundspeedValid
|
|
)
|
|
{
|
|
if ((aircraft->m_groundspeed < flapsCleanSpeed) && (aircraft->m_flaps < 0.25))
|
|
{
|
|
// Extend flaps for approach
|
|
if (debug) {
|
|
qDebug() << "Extend flaps for approach" << aircraft->m_icaoHex;
|
|
}
|
|
animations->append(flapsAnimation(dateTime, aircraft->m_flaps, 0.25));
|
|
//animations->append(slatsAnimation(dateTime, false));
|
|
aircraft->m_flaps = 0.25;
|
|
aircraft->m_pitchEst = 1.0;
|
|
}
|
|
}
|
|
|
|
// Gear down for landing
|
|
// We don't know airport elevation, so just base on speed and descent rate
|
|
if (!aircraft->m_gearDown
|
|
&& !aircraft->m_onSurface
|
|
&& !aircraft->m_runwayAltitudeValid
|
|
&& (aircraft->m_verticalRateValid && (aircraft->m_verticalRate < 0))
|
|
&& (aircraft->m_groundspeedValid && (aircraft->m_groundspeed < gearDownSpeed))
|
|
)
|
|
{
|
|
if (debug) {
|
|
qDebug() << "Flaps/Gear down for landing " << aircraft->m_icaoHex;
|
|
}
|
|
animations->append(flapsAnimation(dateTime, aircraft->m_flaps, 0.5));
|
|
animations->append(slatsAnimation(dateTime, false));
|
|
animations->append(gearAnimation(dateTime.addSecs(8), false));
|
|
animations->append(flapsAnimation(dateTime.addSecs(16), 0.5, 1.0));
|
|
aircraft->m_gearDown = true;
|
|
aircraft->m_flaps = 1.0;
|
|
aircraft->m_pitchEst = 3.0;
|
|
}
|
|
|
|
// Engine control
|
|
if (aircraft->m_emitterCategory == "Rotorcraft")
|
|
{
|
|
// Helicopter rotors
|
|
if (!aircraft->m_rotorStarted && !aircraft->m_onSurface)
|
|
{
|
|
// Start rotors
|
|
if (debug) {
|
|
qDebug() << "Start rotors " << aircraft->m_icaoHex;
|
|
}
|
|
animations->append(rotorAnimation(dateTime, false));
|
|
aircraft->m_rotorStarted = true;
|
|
}
|
|
else if (aircraft->m_rotorStarted && aircraft->m_onSurface)
|
|
{
|
|
if (debug) {
|
|
qDebug() << "Stop rotors " << aircraft->m_icaoHex;
|
|
}
|
|
animations->append(rotorAnimation(dateTime, true));
|
|
aircraft->m_rotorStarted = false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Propellors
|
|
if (!aircraft->m_engineStarted && aircraft->m_groundspeedValid && (aircraft->m_groundspeed > 0))
|
|
{
|
|
if (debug) {
|
|
qDebug() << "Start engines " << aircraft->m_icaoHex;
|
|
}
|
|
animations->append(engineAnimation(dateTime, 1, false));
|
|
animations->append(engineAnimation(dateTime, 2, false));
|
|
aircraft->m_engineStarted = true;
|
|
}
|
|
else if (aircraft->m_engineStarted && aircraft->m_groundspeedValid && (aircraft->m_groundspeed == 0))
|
|
{
|
|
if (debug) {
|
|
qDebug() << "Stop engines " << aircraft->m_icaoHex;
|
|
}
|
|
animations->append(engineAnimation(dateTime, 1, true));
|
|
animations->append(engineAnimation(dateTime, 2, true));
|
|
aircraft->m_engineStarted = false;
|
|
}
|
|
}
|
|
|
|
// Estimate pitch, so it looks a little more realistic
|
|
if (aircraft->m_onSurface)
|
|
{
|
|
// Check speed so we don't set pitch to 0 immediately on touch-down
|
|
// Should probably record time of touch-down and reduce over time
|
|
if (aircraft->m_groundspeedValid)
|
|
{
|
|
if (aircraft->m_groundspeed < 80) {
|
|
aircraft->m_pitchEst = 0.0;
|
|
} else if ((aircraft->m_groundspeed < 130) && (aircraft->m_pitchEst >= 2)) {
|
|
aircraft->m_pitchEst = 1;
|
|
}
|
|
}
|
|
}
|
|
else if ((aircraft->m_flaps < 0.25) && aircraft->m_verticalRateValid)
|
|
{
|
|
// In climb/descent
|
|
aircraft->m_pitchEst = std::abs(aircraft->m_verticalRate / 400.0);
|
|
}
|
|
|
|
// Estimate some roll
|
|
if (aircraft->m_onSurface
|
|
|| (aircraft->m_runwayAltitudeValid && (aircraft->m_altitude < (aircraft->m_runwayAltitude + accelerationHeight))))
|
|
{
|
|
aircraft->m_rollEst = 0.0;
|
|
}
|
|
else if (aircraft->m_headingValid)
|
|
{
|
|
// Really need to use more data points for this - or better yet, get it from Mode-S frames
|
|
if (aircraft->m_prevHeadingDateTime.isValid())
|
|
{
|
|
qint64 msecs = aircraft->m_prevHeadingDateTime.msecsTo(aircraft->m_headingDateTime);
|
|
if (msecs > 0)
|
|
{
|
|
float headingDiff = fmod(aircraft->m_heading - aircraft->m_prevHeading + 540.0, 360.0) - 180.0;
|
|
float roll = headingDiff / (msecs / 1000.0);
|
|
//qDebug() << "Heading Diff " << headingDiff << " msecs " << msecs << " roll " << roll;
|
|
roll = std::min(roll, 15.0f);
|
|
roll = std::max(roll, -15.0f);
|
|
aircraft->m_rollEst = roll;
|
|
}
|
|
}
|
|
aircraft->m_prevHeadingDateTime = aircraft->m_headingDateTime;
|
|
aircraft->m_prevHeading = aircraft->m_heading;
|
|
}
|
|
|
|
return animations;
|
|
}
|
|
|
|
SWGSDRangel::SWGMapAnimation *ADSBDemodGUI::gearAnimation(QDateTime startDateTime, bool up)
|
|
{
|
|
// Gear up/down
|
|
SWGSDRangel::SWGMapAnimation *animation = new SWGSDRangel::SWGMapAnimation();
|
|
animation->setName(new QString("libxplanemp/controls/gear_ratio"));
|
|
animation->setStartDateTime(new QString(startDateTime.toString(Qt::ISODateWithMs)));
|
|
animation->setReverse(up);
|
|
animation->setLoop(0);
|
|
animation->setDuration(5);
|
|
animation->setMultiplier(0.2);
|
|
return animation;
|
|
}
|
|
|
|
SWGSDRangel::SWGMapAnimation *ADSBDemodGUI::flapsAnimation(QDateTime startDateTime, float currentFlaps, float flaps)
|
|
{
|
|
// Extend / retract flags
|
|
bool retract = flaps < currentFlaps;
|
|
SWGSDRangel::SWGMapAnimation *animation = new SWGSDRangel::SWGMapAnimation();
|
|
animation->setName(new QString("libxplanemp/controls/flap_ratio"));
|
|
animation->setStartDateTime(new QString(startDateTime.toString(Qt::ISODateWithMs)));
|
|
animation->setReverse(retract);
|
|
animation->setLoop(0);
|
|
animation->setDuration(5*std::abs(flaps-currentFlaps));
|
|
animation->setMultiplier(0.2);
|
|
if (retract) {
|
|
animation->setStartOffset(1.0 - currentFlaps);
|
|
} else {
|
|
animation->setStartOffset(currentFlaps);
|
|
}
|
|
return animation;
|
|
}
|
|
|
|
SWGSDRangel::SWGMapAnimation *ADSBDemodGUI::slatsAnimation(QDateTime startDateTime, bool retract)
|
|
{
|
|
// Extend / retract slats
|
|
SWGSDRangel::SWGMapAnimation *animation = new SWGSDRangel::SWGMapAnimation();
|
|
animation->setName(new QString("libxplanemp/controls/slat_ratio"));
|
|
animation->setStartDateTime(new QString(startDateTime.toString(Qt::ISODateWithMs)));
|
|
animation->setReverse(retract);
|
|
animation->setLoop(0);
|
|
animation->setDuration(5);
|
|
animation->setMultiplier(0.2);
|
|
return animation;
|
|
}
|
|
|
|
SWGSDRangel::SWGMapAnimation *ADSBDemodGUI::rotorAnimation(QDateTime startDateTime, bool stop)
|
|
{
|
|
// Turn rotors in helicopter.glb model
|
|
SWGSDRangel::SWGMapAnimation *animation = new SWGSDRangel::SWGMapAnimation();
|
|
animation->setName(new QString("Take 001"));
|
|
animation->setStartDateTime(new QString(startDateTime.toString(Qt::ISODateWithMs)));
|
|
animation->setReverse(false);
|
|
animation->setLoop(true);
|
|
animation->setMultiplier(1);
|
|
animation->setStop(stop);
|
|
return animation;
|
|
}
|
|
|
|
SWGSDRangel::SWGMapAnimation *ADSBDemodGUI::engineAnimation(QDateTime startDateTime, int engine, bool stop)
|
|
{
|
|
// Turn propellors
|
|
SWGSDRangel::SWGMapAnimation *animation = new SWGSDRangel::SWGMapAnimation();
|
|
animation->setName(new QString(QString("libxplanemp/engines/engine_rotation_angle_deg%1").arg(engine)));
|
|
animation->setStartDateTime(new QString(startDateTime.toString(Qt::ISODateWithMs)));
|
|
animation->setReverse(false);
|
|
animation->setLoop(true);
|
|
animation->setMultiplier(1);
|
|
animation->setStop(stop);
|
|
return animation;
|
|
}
|
|
|
|
void ADSBDemodGUI::checkStaticNotification(Aircraft *aircraft)
|
|
{
|
|
for (int i = 0; i < m_settings.m_notificationSettings.size(); i++)
|
|
{
|
|
QString match;
|
|
switch (m_settings.m_notificationSettings[i]->m_matchColumn)
|
|
{
|
|
case ADSB_COL_ICAO:
|
|
match = aircraft->m_icaoItem->data(Qt::DisplayRole).toString();
|
|
break;
|
|
case ADSB_COL_MODEL:
|
|
match = aircraft->m_modelItem->data(Qt::DisplayRole).toString();
|
|
break;
|
|
case ADSB_COL_REGISTRATION:
|
|
match = aircraft->m_registrationItem->data(Qt::DisplayRole).toString();
|
|
break;
|
|
case ADSB_COL_MANUFACTURER:
|
|
match = aircraft->m_manufacturerNameItem->data(Qt::DisplayRole).toString();
|
|
break;
|
|
case ADSB_COL_OWNER:
|
|
match = aircraft->m_ownerItem->data(Qt::DisplayRole).toString();
|
|
break;
|
|
case ADSB_COL_OPERATOR_ICAO:
|
|
match = aircraft->m_operatorICAOItem->data(Qt::DisplayRole).toString();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
if (!match.isEmpty())
|
|
{
|
|
if (m_settings.m_notificationSettings[i]->m_regularExpression.isValid())
|
|
{
|
|
if (m_settings.m_notificationSettings[i]->m_regularExpression.match(match).hasMatch())
|
|
{
|
|
highlightAircraft(aircraft);
|
|
|
|
if (!m_settings.m_notificationSettings[i]->m_speech.isEmpty()) {
|
|
speechNotification(aircraft, m_settings.m_notificationSettings[i]->m_speech);
|
|
}
|
|
if (!m_settings.m_notificationSettings[i]->m_command.isEmpty()) {
|
|
commandNotification(aircraft, m_settings.m_notificationSettings[i]->m_command);
|
|
}
|
|
if (m_settings.m_notificationSettings[i]->m_autoTarget) {
|
|
targetAircraft(aircraft);
|
|
}
|
|
|
|
aircraft->m_notified = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void ADSBDemodGUI::checkDynamicNotification(Aircraft *aircraft)
|
|
{
|
|
if (!aircraft->m_notified)
|
|
{
|
|
for (int i = 0; i < m_settings.m_notificationSettings.size(); i++)
|
|
{
|
|
if ( (m_settings.m_notificationSettings[i]->m_matchColumn == ADSB_COL_CALLSIGN)
|
|
|| (m_settings.m_notificationSettings[i]->m_matchColumn == ADSB_COL_ALTITUDE)
|
|
|| (m_settings.m_notificationSettings[i]->m_matchColumn == ADSB_COL_GROUND_SPEED)
|
|
|| (m_settings.m_notificationSettings[i]->m_matchColumn == ADSB_COL_RANGE)
|
|
|| (m_settings.m_notificationSettings[i]->m_matchColumn == ADSB_COL_CATEGORY)
|
|
|| (m_settings.m_notificationSettings[i]->m_matchColumn == ADSB_COL_STATUS)
|
|
|| (m_settings.m_notificationSettings[i]->m_matchColumn == ADSB_COL_SQUAWK)
|
|
)
|
|
{
|
|
QString match;
|
|
switch (m_settings.m_notificationSettings[i]->m_matchColumn)
|
|
{
|
|
case ADSB_COL_CALLSIGN:
|
|
match = aircraft->m_callsignItem->data(Qt::DisplayRole).toString();
|
|
break;
|
|
case ADSB_COL_ALTITUDE:
|
|
match = aircraft->m_altitudeItem->data(Qt::DisplayRole).toString();
|
|
break;
|
|
case ADSB_COL_GROUND_SPEED:
|
|
match = aircraft->m_groundspeedItem->data(Qt::DisplayRole).toString();
|
|
break;
|
|
case ADSB_COL_RANGE:
|
|
match = aircraft->m_rangeItem->data(Qt::DisplayRole).toString();
|
|
break;
|
|
case ADSB_COL_CATEGORY:
|
|
match = aircraft->m_emitterCategoryItem->data(Qt::DisplayRole).toString();
|
|
break;
|
|
case ADSB_COL_STATUS:
|
|
match = aircraft->m_statusItem->data(Qt::DisplayRole).toString();
|
|
break;
|
|
case ADSB_COL_SQUAWK:
|
|
match = aircraft->m_squawkItem->data(Qt::DisplayRole).toString();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
if (!match.isEmpty())
|
|
{
|
|
if (m_settings.m_notificationSettings[i]->m_regularExpression.isValid())
|
|
{
|
|
if (m_settings.m_notificationSettings[i]->m_regularExpression.match(match).hasMatch())
|
|
{
|
|
highlightAircraft(aircraft);
|
|
|
|
if (!m_settings.m_notificationSettings[i]->m_speech.isEmpty()) {
|
|
speechNotification(aircraft, m_settings.m_notificationSettings[i]->m_speech);
|
|
}
|
|
if (!m_settings.m_notificationSettings[i]->m_command.isEmpty()) {
|
|
commandNotification(aircraft, m_settings.m_notificationSettings[i]->m_command);
|
|
}
|
|
if (m_settings.m_notificationSettings[i]->m_autoTarget) {
|
|
targetAircraft(aircraft);
|
|
}
|
|
|
|
aircraft->m_notified = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Initialise text to speech engine
|
|
// This takes 10 seconds on some versions of Linux, so only do it, if user actually
|
|
// has speech notifications configured
|
|
void ADSBDemodGUI::enableSpeechIfNeeded()
|
|
{
|
|
if (m_speech) {
|
|
return;
|
|
}
|
|
for (const auto& notification : m_settings.m_notificationSettings)
|
|
{
|
|
if (!notification->m_speech.isEmpty())
|
|
{
|
|
qDebug() << "ADSBDemodGUI: Enabling text to speech";
|
|
m_speech = new QTextToSpeech(this);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
void ADSBDemodGUI::speechNotification(Aircraft *aircraft, const QString &speech)
|
|
{
|
|
if (m_speech) {
|
|
m_speech->say(subAircraftString(aircraft, speech));
|
|
} else {
|
|
qDebug() << "ADSBDemodGUI::speechNotification: Unable to say " << speech;
|
|
}
|
|
}
|
|
|
|
void ADSBDemodGUI::commandNotification(Aircraft *aircraft, const QString &command)
|
|
{
|
|
QString commandLine = subAircraftString(aircraft, command);
|
|
QStringList allArgs = QProcess::splitCommand(commandLine);
|
|
|
|
if (allArgs.size() > 0)
|
|
{
|
|
QString program = allArgs[0];
|
|
allArgs.pop_front();
|
|
QProcess::startDetached(program, allArgs);
|
|
}
|
|
}
|
|
|
|
QString ADSBDemodGUI::subAircraftString(Aircraft *aircraft, const QString &string)
|
|
{
|
|
QString s = string;
|
|
s = s.replace("${icao}", aircraft->m_icaoItem->data(Qt::DisplayRole).toString());
|
|
s = s.replace("${callsign}", aircraft->m_callsignItem->data(Qt::DisplayRole).toString());
|
|
s = s.replace("${aircraft}", aircraft->m_modelItem->data(Qt::DisplayRole).toString());
|
|
s = s.replace("${speed}", aircraft->m_groundspeedItem->data(Qt::DisplayRole).toString()); // For backwards compatibility
|
|
s = s.replace("${gs}", aircraft->m_groundspeedItem->data(Qt::DisplayRole).toString());
|
|
s = s.replace("${tas}", aircraft->m_trueAirspeedItem->data(Qt::DisplayRole).toString());
|
|
s = s.replace("${ias}", aircraft->m_indicatedAirspeedItem->data(Qt::DisplayRole).toString());
|
|
s = s.replace("${mach}", aircraft->m_machItem->data(Qt::DisplayRole).toString());
|
|
s = s.replace("${selAltitude}", aircraft->m_selAltitudeItem->data(Qt::DisplayRole).toString());
|
|
s = s.replace("${altitude}", aircraft->m_altitudeItem->data(Qt::DisplayRole).toString());
|
|
s = s.replace("${verticalRate}", aircraft->m_verticalRateItem->data(Qt::DisplayRole).toString());
|
|
s = s.replace("${selHeading}", aircraft->m_selHeadingItem->data(Qt::DisplayRole).toString());
|
|
s = s.replace("${heading}", aircraft->m_headingItem->data(Qt::DisplayRole).toString());
|
|
s = s.replace("${turnRate}", aircraft->m_turnRateItem->data(Qt::DisplayRole).toString());
|
|
s = s.replace("${roll}", aircraft->m_rollItem->data(Qt::DisplayRole).toString());
|
|
s = s.replace("${range}", aircraft->m_rangeItem->data(Qt::DisplayRole).toString());
|
|
s = s.replace("${azel}", aircraft->m_azElItem->data(Qt::DisplayRole).toString());
|
|
s = s.replace("${category}", aircraft->m_emitterCategoryItem->data(Qt::DisplayRole).toString());
|
|
s = s.replace("${status}", aircraft->m_statusItem->data(Qt::DisplayRole).toString());
|
|
s = s.replace("${squawk}", aircraft->m_squawkItem->data(Qt::DisplayRole).toString());
|
|
s = s.replace("${registration}", aircraft->m_registrationItem->data(Qt::DisplayRole).toString());
|
|
s = s.replace("${manufacturer}", aircraft->m_manufacturerNameItem->data(Qt::DisplayRole).toString());
|
|
s = s.replace("${owner}", aircraft->m_ownerItem->data(Qt::DisplayRole).toString());
|
|
s = s.replace("${operator}", aircraft->m_operatorICAOItem->data(Qt::DisplayRole).toString());
|
|
s = s.replace("${ap}", aircraft->m_apItem->data(Qt::DisplayRole).toString());
|
|
s = s.replace("${vMode}", aircraft->m_vModeItem->data(Qt::DisplayRole).toString());
|
|
s = s.replace("${lMode}", aircraft->m_lModeItem->data(Qt::DisplayRole).toString());
|
|
s = s.replace("${baro}", aircraft->m_baroItem->data(Qt::DisplayRole).toString());
|
|
s = s.replace("${headwind}", aircraft->m_headwindItem->data(Qt::DisplayRole).toString());
|
|
s = s.replace("${windSpeed}", aircraft->m_windSpeedItem->data(Qt::DisplayRole).toString());
|
|
s = s.replace("${windDirection}", aircraft->m_windDirItem->data(Qt::DisplayRole).toString());
|
|
s = s.replace("${staticPressure}", aircraft->m_staticPressureItem->data(Qt::DisplayRole).toString());
|
|
s = s.replace("${staticAirTemperature}", aircraft->m_staticAirTempItem->data(Qt::DisplayRole).toString());
|
|
s = s.replace("${humidity}", aircraft->m_humidityItem->data(Qt::DisplayRole).toString());
|
|
s = s.replace("${latitude}", aircraft->m_latitudeItem->data(Qt::DisplayRole).toString());
|
|
s = s.replace("${longitude}", aircraft->m_longitudeItem->data(Qt::DisplayRole).toString());
|
|
s = s.replace("${rssi}", aircraft->m_rssiItem->data(Qt::DisplayRole).toString());
|
|
s = s.replace("${flightstatus}", aircraft->m_flightStatusItem->data(Qt::DisplayRole).toString());
|
|
s = s.replace("${departure}", aircraft->m_depItem->data(Qt::DisplayRole).toString());
|
|
s = s.replace("${arrival}", aircraft->m_arrItem->data(Qt::DisplayRole).toString());
|
|
s = s.replace("${std}", aircraft->m_stdItem->data(Qt::DisplayRole).toString());
|
|
s = s.replace("${etd}", aircraft->m_etdItem->data(Qt::DisplayRole).toString());
|
|
s = s.replace("${atd}", aircraft->m_atdItem->data(Qt::DisplayRole).toString());
|
|
s = s.replace("${sta}", aircraft->m_staItem->data(Qt::DisplayRole).toString());
|
|
s = s.replace("${eta}", aircraft->m_etaItem->data(Qt::DisplayRole).toString());
|
|
s = s.replace("${ata}", aircraft->m_ataItem->data(Qt::DisplayRole).toString());
|
|
return s;
|
|
}
|
|
|
|
bool ADSBDemodGUI::handleMessage(const Message& message)
|
|
{
|
|
if (DSPSignalNotification::match(message))
|
|
{
|
|
DSPSignalNotification& notif = (DSPSignalNotification&) message;
|
|
int sr = notif.getSampleRate();
|
|
bool srTooLow = sr < 2000000;
|
|
ui->warning->setVisible(srTooLow);
|
|
if (srTooLow) {
|
|
ui->warning->setText(QString("Sample rate must be >= 2000000. Currently %1").arg(sr));
|
|
} else {
|
|
ui->warning->setText("");
|
|
}
|
|
getRollupContents()->arrangeRollups();
|
|
m_deviceCenterFrequency = notif.getCenterFrequency();
|
|
m_basebandSampleRate = sr;
|
|
ui->deltaFrequency->setValueRange(false, 7, -sr/2, sr/2);
|
|
ui->deltaFrequencyLabel->setToolTip(tr("Range %1 %L2 Hz").arg(QChar(0xB1)).arg(sr/2));
|
|
updateAbsoluteCenterFrequency();
|
|
return true;
|
|
}
|
|
else if (ADSBDemodReport::MsgReportADSB::match(message))
|
|
{
|
|
ADSBDemodReport::MsgReportADSB& report = (ADSBDemodReport::MsgReportADSB&) message;
|
|
handleADSB(
|
|
report.getData(),
|
|
report.getDateTime(),
|
|
report.getPreambleCorrelation(),
|
|
report.getCorrelationOnes(),
|
|
report.getCRC(),
|
|
true);
|
|
return true;
|
|
}
|
|
else if (ADSBDemodReport::MsgReportDemodStats::match(message))
|
|
{
|
|
ADSBDemodReport::MsgReportDemodStats& report = (ADSBDemodReport::MsgReportDemodStats&) message;
|
|
if (m_settings.m_displayDemodStats)
|
|
{
|
|
ADSBDemodStats stats = report.getDemodStats();
|
|
ui->stats->setText(QString("ADS-B: %1 Mode-S: %2 Matches: %3 CRC: %4 Type: %5 Avg Corr: %6 Demod Time: %7 Feed Time: %8").arg(stats.m_adsbFrames).arg(stats.m_modesFrames).arg(stats.m_correlatorMatches).arg(stats.m_crcFails).arg(stats.m_typeFails).arg(CalcDb::dbPower(m_correlationAvg.instantAverage()), 1, 'f', 1).arg(stats.m_demodTime, 1, 'f', 3).arg(stats.m_feedTime, 1, 'f', 3));
|
|
}
|
|
return true;
|
|
}
|
|
else if (ADSBDemod::MsgConfigureADSBDemod::match(message))
|
|
{
|
|
qDebug("ADSBDemodGUI::handleMessage: ADSBDemod::MsgConfigureADSBDemod");
|
|
const ADSBDemod::MsgConfigureADSBDemod& cfg = (ADSBDemod::MsgConfigureADSBDemod&) message;
|
|
m_settings = cfg.getSettings();
|
|
blockApplySettings(true);
|
|
m_channelMarker.updateSettings(static_cast<const ChannelMarker*>(m_settings.m_channelMarker));
|
|
displaySettings();
|
|
blockApplySettings(false);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void ADSBDemodGUI::handleInputMessages()
|
|
{
|
|
Message* message;
|
|
|
|
while ((message = getInputMessageQueue()->pop()) != 0)
|
|
{
|
|
if (handleMessage(*message))
|
|
{
|
|
delete message;
|
|
}
|
|
}
|
|
}
|
|
|
|
void ADSBDemodGUI::channelMarkerChangedByCursor()
|
|
{
|
|
ui->deltaFrequency->setValue(m_channelMarker.getCenterFrequency());
|
|
m_settings.m_inputFrequencyOffset = m_channelMarker.getCenterFrequency();
|
|
applySettings();
|
|
}
|
|
|
|
void ADSBDemodGUI::channelMarkerHighlightedByCursor()
|
|
{
|
|
setHighlighted(m_channelMarker.getHighlighted());
|
|
}
|
|
|
|
void ADSBDemodGUI::on_deltaFrequency_changed(qint64 value)
|
|
{
|
|
m_channelMarker.setCenterFrequency(value);
|
|
m_settings.m_inputFrequencyOffset = m_channelMarker.getCenterFrequency();
|
|
updateAbsoluteCenterFrequency();
|
|
applySettings();
|
|
}
|
|
|
|
void ADSBDemodGUI::on_rfBW_valueChanged(int value)
|
|
{
|
|
Real bw = (Real)value;
|
|
ui->rfBWText->setText(QString("%1M").arg(bw / 1000000.0, 0, 'f', 1));
|
|
m_channelMarker.setBandwidth(bw);
|
|
m_settings.m_rfBandwidth = bw;
|
|
applySettings();
|
|
}
|
|
|
|
void ADSBDemodGUI::on_threshold_valueChanged(int value)
|
|
{
|
|
Real thresholddB = ((Real)value)/10.0f;
|
|
ui->thresholdText->setText(QString("%1").arg(thresholddB, 0, 'f', 1));
|
|
m_settings.m_correlationThreshold = thresholddB;
|
|
applySettings();
|
|
}
|
|
|
|
void ADSBDemodGUI::on_phaseSteps_valueChanged(int value)
|
|
{
|
|
ui->phaseStepsText->setText(QString("%1").arg(value));
|
|
m_settings.m_interpolatorPhaseSteps = value;
|
|
applySettings();
|
|
}
|
|
|
|
void ADSBDemodGUI::on_tapsPerPhase_valueChanged(int value)
|
|
{
|
|
Real tapsPerPhase = ((Real)value)/10.0f;
|
|
ui->tapsPerPhaseText->setText(QString("%1").arg(tapsPerPhase, 0, 'f', 1));
|
|
m_settings.m_interpolatorTapsPerPhase = tapsPerPhase;
|
|
applySettings();
|
|
}
|
|
|
|
void ADSBDemodGUI::on_feed_clicked(bool checked)
|
|
{
|
|
m_settings.m_feedEnabled = checked;
|
|
// Don't disable host/port - so they can be entered before connecting
|
|
applySettings();
|
|
applyImportSettings();
|
|
}
|
|
|
|
void ADSBDemodGUI::on_notifications_clicked()
|
|
{
|
|
ADSBDemodNotificationDialog dialog(&m_settings);
|
|
if (dialog.exec() == QDialog::Accepted)
|
|
{
|
|
enableSpeechIfNeeded();
|
|
applySettings();
|
|
}
|
|
}
|
|
|
|
void ADSBDemodGUI::on_flightInfo_clicked()
|
|
{
|
|
if (m_flightInformation)
|
|
{
|
|
// Selection mode is single, so only a single row should be returned
|
|
QModelIndexList indexList = ui->adsbData->selectionModel()->selectedRows();
|
|
if (!indexList.isEmpty())
|
|
{
|
|
int row = indexList.at(0).row();
|
|
int icao = ui->adsbData->item(row, 0)->text().toInt(nullptr, 16);
|
|
if (m_aircraft.contains(icao))
|
|
{
|
|
Aircraft *aircraft = m_aircraft.value(icao);
|
|
if (!aircraft->m_flight.isEmpty())
|
|
{
|
|
// Download flight information
|
|
m_flightInformation->getFlightInformation(aircraft->m_flight);
|
|
}
|
|
else
|
|
{
|
|
qDebug() << "ADSBDemodGUI::on_flightInfo_clicked - No flight number for selected aircraft";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
qDebug() << "ADSBDemodGUI::on_flightInfo_clicked - No aircraft with icao " << icao;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
qDebug() << "ADSBDemodGUI::on_flightInfo_clicked - No aircraft selected";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
qDebug() << "ADSBDemodGUI::on_flightInfo_clicked - No flight information service - have you set an API key?";
|
|
}
|
|
}
|
|
|
|
// Find highlighed aircraft on Map Feature
|
|
void ADSBDemodGUI::on_findOnMapFeature_clicked()
|
|
{
|
|
QModelIndexList indexList = ui->adsbData->selectionModel()->selectedRows();
|
|
if (!indexList.isEmpty())
|
|
{
|
|
int row = indexList.at(0).row();
|
|
QString icao = ui->adsbData->item(row, 0)->text();
|
|
FeatureWebAPIUtils::mapFind(icao);
|
|
}
|
|
}
|
|
|
|
// Find aircraft on channel map
|
|
void ADSBDemodGUI::findOnChannelMap(Aircraft *aircraft)
|
|
{
|
|
if (aircraft->m_positionValid)
|
|
{
|
|
QQuickItem *item = ui->map->rootObject();
|
|
QObject *object = item->findChild<QObject*>("map");
|
|
if(object != NULL)
|
|
{
|
|
QGeoCoordinate geocoord = object->property("center").value<QGeoCoordinate>();
|
|
geocoord.setLatitude(aircraft->m_latitude);
|
|
geocoord.setLongitude(aircraft->m_longitude);
|
|
object->setProperty("center", QVariant::fromValue(geocoord));
|
|
}
|
|
}
|
|
}
|
|
|
|
void ADSBDemodGUI::adsbData_customContextMenuRequested(QPoint pos)
|
|
{
|
|
QTableWidgetItem *item = ui->adsbData->itemAt(pos);
|
|
if (item)
|
|
{
|
|
int row = item->row();
|
|
int icao = ui->adsbData->item(row, 0)->text().toInt(nullptr, 16);
|
|
Aircraft *aircraft = nullptr;
|
|
if (m_aircraft.contains(icao)) {
|
|
aircraft = m_aircraft.value(icao);
|
|
}
|
|
QString icaoHex = QString("%1").arg(icao, 1, 16);
|
|
|
|
QMenu* tableContextMenu = new QMenu(ui->adsbData);
|
|
connect(tableContextMenu, &QMenu::aboutToHide, tableContextMenu, &QMenu::deleteLater);
|
|
|
|
// Copy current cell
|
|
|
|
QAction* copyAction = new QAction("Copy", tableContextMenu);
|
|
const QString text = item->text();
|
|
connect(copyAction, &QAction::triggered, this, [text]()->void {
|
|
QClipboard *clipboard = QGuiApplication::clipboard();
|
|
clipboard->setText(text);
|
|
});
|
|
tableContextMenu->addAction(copyAction);
|
|
tableContextMenu->addSeparator();
|
|
|
|
// View aircraft on various websites
|
|
|
|
QAction* planeSpottersAction = new QAction("View aircraft on planespotters.net...", tableContextMenu);
|
|
connect(planeSpottersAction, &QAction::triggered, this, [icao]()->void {
|
|
QString icaoUpper = QString("%1").arg(icao, 1, 16).toUpper();
|
|
QDesktopServices::openUrl(QUrl(QString("https://www.planespotters.net/hex/%1").arg(icaoUpper)));
|
|
});
|
|
tableContextMenu->addAction(planeSpottersAction);
|
|
|
|
QAction* adsbExchangeAction = new QAction("View aircraft on adsbexchange.com...", tableContextMenu);
|
|
connect(adsbExchangeAction, &QAction::triggered, this, [icaoHex]()->void {
|
|
QDesktopServices::openUrl(QUrl(QString("https://globe.adsbexchange.com/?icao=%1").arg(icaoHex)));
|
|
});
|
|
tableContextMenu->addAction(adsbExchangeAction);
|
|
|
|
QAction* viewOpenSkyAction = new QAction("View aircraft on opensky-network.org...", tableContextMenu);
|
|
connect(viewOpenSkyAction, &QAction::triggered, this, [icaoHex]()->void {
|
|
QDesktopServices::openUrl(QUrl(QString("https://opensky-network.org/aircraft-profile?icao24=%1").arg(icaoHex)));
|
|
});
|
|
tableContextMenu->addAction(viewOpenSkyAction);
|
|
|
|
if (!aircraft->m_callsign.isEmpty())
|
|
{
|
|
QAction* flightRadarAction = new QAction("View flight on flightradar24.com...", tableContextMenu);
|
|
connect(flightRadarAction, &QAction::triggered, this, [aircraft]()->void {
|
|
QDesktopServices::openUrl(QUrl(QString("https://www.flightradar24.com/%1").arg(aircraft->m_callsign)));
|
|
});
|
|
tableContextMenu->addAction(flightRadarAction);
|
|
}
|
|
|
|
tableContextMenu->addSeparator();
|
|
|
|
// Edit aircraft
|
|
|
|
if (!aircraft->m_aircraftInfo)
|
|
{
|
|
QAction* addOpenSkyAction = new QAction("Add aircraft to opensky-network.org...", tableContextMenu);
|
|
connect(addOpenSkyAction, &QAction::triggered, this, []()->void {
|
|
QDesktopServices::openUrl(QUrl(QString("https://opensky-network.org/edit-aircraft-profile")));
|
|
});
|
|
tableContextMenu->addAction(addOpenSkyAction);
|
|
}
|
|
else
|
|
{
|
|
|
|
QAction* editOpenSkyAction = new QAction("Edit aircraft on opensky-network.org...", tableContextMenu);
|
|
connect(editOpenSkyAction, &QAction::triggered, this, [icaoHex]()->void {
|
|
QDesktopServices::openUrl(QUrl(QString("https://opensky-network.org/edit-aircraft-profile?icao24=%1").arg(icaoHex)));
|
|
});
|
|
tableContextMenu->addAction(editOpenSkyAction);
|
|
}
|
|
|
|
// Find on Map
|
|
if (aircraft->m_positionValid)
|
|
{
|
|
tableContextMenu->addSeparator();
|
|
|
|
QAction* findChannelMapAction = new QAction("Find on ADS-B map", tableContextMenu);
|
|
connect(findChannelMapAction, &QAction::triggered, this, [this, aircraft]()->void {
|
|
findOnChannelMap(aircraft);
|
|
});
|
|
tableContextMenu->addAction(findChannelMapAction);
|
|
|
|
QAction* findMapFeatureAction = new QAction("Find on feature map", tableContextMenu);
|
|
connect(findMapFeatureAction, &QAction::triggered, this, [icaoHex]()->void {
|
|
FeatureWebAPIUtils::mapFind(icaoHex);
|
|
});
|
|
tableContextMenu->addAction(findMapFeatureAction);
|
|
}
|
|
|
|
tableContextMenu->popup(ui->adsbData->viewport()->mapToGlobal(pos));
|
|
}
|
|
}
|
|
|
|
void ADSBDemodGUI::on_adsbData_cellClicked(int row, int column)
|
|
{
|
|
(void) column;
|
|
// Get ICAO of aircraft in row clicked
|
|
int icao = ui->adsbData->item(row, 0)->text().toInt(nullptr, 16);
|
|
if (m_aircraft.contains(icao)) {
|
|
highlightAircraft(m_aircraft.value(icao));
|
|
}
|
|
}
|
|
|
|
void ADSBDemodGUI::on_adsbData_cellDoubleClicked(int row, int column)
|
|
{
|
|
// Get ICAO of aircraft in row double clicked
|
|
int icao = ui->adsbData->item(row, 0)->text().toInt(nullptr, 16);
|
|
if (column == ADSB_COL_ICAO)
|
|
{
|
|
// Search for aircraft on planespotters.net
|
|
QString icaoUpper = QString("%1").arg(icao, 1, 16).toUpper();
|
|
QDesktopServices::openUrl(QUrl(QString("https://www.planespotters.net/hex/%1").arg(icaoUpper)));
|
|
}
|
|
else if (m_aircraft.contains(icao))
|
|
{
|
|
Aircraft *aircraft = m_aircraft.value(icao);
|
|
|
|
if (column == ADSB_COL_CALLSIGN)
|
|
{
|
|
if (!aircraft->m_callsign.isEmpty())
|
|
{
|
|
// Search for flight on flightradar24
|
|
QDesktopServices::openUrl(QUrl(QString("https://www.flightradar24.com/%1").arg(aircraft->m_callsign)));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (column == ADSB_COL_AZEL)
|
|
{
|
|
targetAircraft(aircraft);
|
|
}
|
|
// Center map view on aircraft if it has a valid position
|
|
if (aircraft->m_positionValid)
|
|
{
|
|
findOnChannelMap(aircraft);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Columns in table reordered
|
|
void ADSBDemodGUI::adsbData_sectionMoved(int logicalIndex, int oldVisualIndex, int newVisualIndex)
|
|
{
|
|
(void) oldVisualIndex;
|
|
m_settings.m_columnIndexes[logicalIndex] = newVisualIndex;
|
|
}
|
|
|
|
// Column in table resized (when hidden size is 0)
|
|
void ADSBDemodGUI::adsbData_sectionResized(int logicalIndex, int oldSize, int newSize)
|
|
{
|
|
(void) oldSize;
|
|
m_settings.m_columnSizes[logicalIndex] = newSize;
|
|
}
|
|
|
|
// Right click in ADSB table header - show column select menu
|
|
void ADSBDemodGUI::columnSelectMenu(QPoint pos)
|
|
{
|
|
menu->popup(ui->adsbData->horizontalHeader()->viewport()->mapToGlobal(pos));
|
|
}
|
|
|
|
// Hide/show column when menu selected
|
|
void ADSBDemodGUI::columnSelectMenuChecked(bool checked)
|
|
{
|
|
(void) checked;
|
|
QAction* action = qobject_cast<QAction*>(sender());
|
|
if (action != nullptr)
|
|
{
|
|
int idx = action->data().toInt(nullptr);
|
|
ui->adsbData->setColumnHidden(idx, !action->isChecked());
|
|
}
|
|
}
|
|
|
|
// Create column select menu item
|
|
QAction *ADSBDemodGUI::createCheckableItem(QString &text, int idx, bool checked)
|
|
{
|
|
QAction *action = new QAction(text, this);
|
|
action->setCheckable(true);
|
|
action->setChecked(checked);
|
|
action->setData(QVariant(idx));
|
|
connect(action, SIGNAL(triggered()), this, SLOT(columnSelectMenuChecked()));
|
|
return action;
|
|
}
|
|
|
|
void ADSBDemodGUI::on_spb_currentIndexChanged(int value)
|
|
{
|
|
m_settings.m_samplesPerBit = (value + 1) * 2;
|
|
applySettings();
|
|
}
|
|
|
|
void ADSBDemodGUI::on_correlateFullPreamble_clicked(bool checked)
|
|
{
|
|
m_settings.m_correlateFullPreamble = checked;
|
|
applySettings();
|
|
}
|
|
|
|
void ADSBDemodGUI::on_demodModeS_clicked(bool checked)
|
|
{
|
|
m_settings.m_demodModeS = checked;
|
|
applySettings();
|
|
}
|
|
|
|
void ADSBDemodGUI::on_getOSNDB_clicked()
|
|
{
|
|
// Don't try to download while already in progress
|
|
if (m_progressDialog == nullptr)
|
|
{
|
|
m_progressDialog = new QProgressDialog(this);
|
|
m_progressDialog->setCancelButton(nullptr);
|
|
m_progressDialog->setWindowFlag(Qt::WindowCloseButtonHint, false);
|
|
m_osnDB.downloadAircraftInformation();
|
|
}
|
|
}
|
|
|
|
void ADSBDemodGUI::on_getAirportDB_clicked()
|
|
{
|
|
// Don't try to download while already in progress
|
|
if (m_progressDialog == nullptr)
|
|
{
|
|
m_progressDialog = new QProgressDialog(this);
|
|
m_progressDialog->setCancelButton(nullptr);
|
|
m_progressDialog->setWindowFlag(Qt::WindowCloseButtonHint, false);
|
|
m_ourAirportsDB.downloadAirportInformation();
|
|
}
|
|
}
|
|
|
|
void ADSBDemodGUI::on_getAirspacesDB_clicked()
|
|
{
|
|
// Don't try to download while already in progress
|
|
if (m_progressDialog == nullptr)
|
|
{
|
|
m_progressDialog = new QProgressDialog(this);
|
|
m_progressDialog->setMaximum(OpenAIP::m_countryCodes.size());
|
|
m_progressDialog->setCancelButton(nullptr);
|
|
m_progressDialog->setWindowFlag(Qt::WindowCloseButtonHint, false);
|
|
m_openAIP.downloadAirspaces();
|
|
}
|
|
}
|
|
|
|
void ADSBDemodGUI::on_flightPaths_clicked(bool checked)
|
|
{
|
|
m_settings.m_flightPaths = checked;
|
|
m_aircraftModel.setFlightPaths(checked);
|
|
}
|
|
|
|
void ADSBDemodGUI::on_allFlightPaths_clicked(bool checked)
|
|
{
|
|
m_settings.m_allFlightPaths = checked;
|
|
m_aircraftModel.setAllFlightPaths(checked);
|
|
}
|
|
|
|
void ADSBDemodGUI::on_atcLabels_clicked(bool checked)
|
|
{
|
|
m_settings.m_atcLabels = checked;
|
|
m_aircraftModel.setSettings(&m_settings);
|
|
applySettings();
|
|
}
|
|
|
|
QString ADSBDemodGUI::getDataDir()
|
|
{
|
|
// Get directory to store app data in (aircraft & airport databases and user-definable icons)
|
|
QStringList locations = QStandardPaths::standardLocations(QStandardPaths::AppDataLocation);
|
|
// First dir is writable
|
|
return locations[0];
|
|
}
|
|
|
|
void ADSBDemodGUI::onWidgetRolled(QWidget* widget, bool rollDown)
|
|
{
|
|
(void) widget;
|
|
(void) rollDown;
|
|
|
|
getRollupContents()->saveState(m_rollupState);
|
|
applySettings();
|
|
}
|
|
|
|
void ADSBDemodGUI::onMenuDialogCalled(const QPoint &p)
|
|
{
|
|
if (m_contextMenuType == ContextMenuChannelSettings)
|
|
{
|
|
BasicChannelSettingsDialog dialog(&m_channelMarker, this);
|
|
dialog.setUseReverseAPI(m_settings.m_useReverseAPI);
|
|
dialog.setReverseAPIAddress(m_settings.m_reverseAPIAddress);
|
|
dialog.setReverseAPIPort(m_settings.m_reverseAPIPort);
|
|
dialog.setReverseAPIDeviceIndex(m_settings.m_reverseAPIDeviceIndex);
|
|
dialog.setReverseAPIChannelIndex(m_settings.m_reverseAPIChannelIndex);
|
|
dialog.setDefaultTitle(m_displayedName);
|
|
|
|
if (m_deviceUISet->m_deviceMIMOEngine)
|
|
{
|
|
dialog.setNumberOfStreams(m_adsbDemod->getNumberOfDeviceStreams());
|
|
dialog.setStreamIndex(m_settings.m_streamIndex);
|
|
}
|
|
|
|
dialog.move(p);
|
|
new DialogPositioner(&dialog, false);
|
|
dialog.exec();
|
|
|
|
m_settings.m_rgbColor = m_channelMarker.getColor().rgb();
|
|
m_settings.m_title = m_channelMarker.getTitle();
|
|
m_settings.m_useReverseAPI = dialog.useReverseAPI();
|
|
m_settings.m_reverseAPIAddress = dialog.getReverseAPIAddress();
|
|
m_settings.m_reverseAPIPort = dialog.getReverseAPIPort();
|
|
m_settings.m_reverseAPIDeviceIndex = dialog.getReverseAPIDeviceIndex();
|
|
m_settings.m_reverseAPIChannelIndex = dialog.getReverseAPIChannelIndex();
|
|
|
|
setWindowTitle(m_settings.m_title);
|
|
setTitle(m_channelMarker.getTitle());
|
|
setTitleColor(m_settings.m_rgbColor);
|
|
|
|
if (m_deviceUISet->m_deviceMIMOEngine)
|
|
{
|
|
m_settings.m_streamIndex = dialog.getSelectedStreamIndex();
|
|
m_channelMarker.clearStreamIndexes();
|
|
m_channelMarker.addStreamIndex(m_settings.m_streamIndex);
|
|
updateIndexLabel();
|
|
}
|
|
|
|
applySettings();
|
|
}
|
|
|
|
resetContextMenuType();
|
|
}
|
|
|
|
void ADSBDemodGUI::updateChannelList()
|
|
{
|
|
std::vector<ChannelAPI*> channels = MainCore::instance()->getChannels("sdrangel.channel.amdemod");
|
|
|
|
ui->amDemod->blockSignals(true);
|
|
ui->amDemod->clear();
|
|
|
|
for (const auto channel : channels) {
|
|
ui->amDemod->addItem(QString("R%1:%2").arg(channel->getDeviceSetIndex()).arg(channel->getIndexInDeviceSet()));
|
|
}
|
|
|
|
// Select current setting, if exists
|
|
// If not, make sure nothing selected, as channel may be created later on
|
|
int idx = ui->amDemod->findText(m_settings.m_amDemod);
|
|
if (idx >= 0) {
|
|
ui->amDemod->setCurrentIndex(idx);
|
|
} else {
|
|
ui->amDemod->setCurrentIndex(-1);
|
|
}
|
|
|
|
ui->amDemod->blockSignals(false);
|
|
|
|
// If no current settting, select first channel
|
|
if (m_settings.m_amDemod.isEmpty())
|
|
{
|
|
ui->amDemod->setCurrentIndex(0);
|
|
on_amDemod_currentIndexChanged(0);
|
|
}
|
|
}
|
|
|
|
void ADSBDemodGUI::on_amDemod_currentIndexChanged(int index)
|
|
{
|
|
if (index >= 0)
|
|
{
|
|
m_settings.m_amDemod = ui->amDemod->currentText();
|
|
applySettings();
|
|
}
|
|
}
|
|
|
|
QString ADSBDemodGUI::get3DModel(const QString &aircraftType, const QString &operatorICAO) const
|
|
{
|
|
QString aircraftTypeOperator = aircraftType + "_" + operatorICAO;
|
|
if (m_3DModels.contains(aircraftTypeOperator)) {
|
|
return m_3DModels.value(aircraftTypeOperator);
|
|
}
|
|
if (m_settings.m_verboseModelMatching) {
|
|
qDebug() << "ADS-B: No livery for " << aircraftTypeOperator;
|
|
}
|
|
return "";
|
|
}
|
|
|
|
QString ADSBDemodGUI::get3DModel(const QString &aircraftType)
|
|
{
|
|
if (m_3DModelsByType.contains(aircraftType))
|
|
{
|
|
// Choose a random livery
|
|
QStringList models = m_3DModelsByType.value(aircraftType);
|
|
int size = models.size();
|
|
int idx = m_random.bounded(size);
|
|
return models[idx];
|
|
}
|
|
if (m_settings.m_verboseModelMatching) {
|
|
qDebug() << "ADS-B: No aircraft for " << aircraftType;
|
|
}
|
|
return "";
|
|
}
|
|
|
|
void ADSBDemodGUI::get3DModel(Aircraft *aircraft)
|
|
{
|
|
QString model;
|
|
if (aircraft->m_aircraftInfo && !aircraft->m_aircraftInfo->m_model.isEmpty())
|
|
{
|
|
QString aircraftType;
|
|
for (auto mm : m_3DModelMatch)
|
|
{
|
|
if (mm->match(aircraft->m_aircraftInfo->m_model, aircraft->m_aircraftInfo->m_manufacturerName, aircraftType))
|
|
{
|
|
// Look for operator specific livery
|
|
if (!aircraft->m_aircraftInfo->m_operatorICAO.isEmpty()) {
|
|
model = get3DModel(aircraftType, aircraft->m_aircraftInfo->m_operatorICAO);
|
|
}
|
|
if (model.isEmpty()) {
|
|
// Try for aircraft with out specific livery
|
|
model = get3DModel(aircraftType);
|
|
}
|
|
if (!model.isEmpty())
|
|
{
|
|
aircraft->m_aircraft3DModel = model;
|
|
if (m_modelAltitudeOffset.contains(aircraftType))
|
|
{
|
|
aircraft->m_modelAltitudeOffset = m_modelAltitudeOffset.value(aircraftType);
|
|
aircraft->m_labelAltitudeOffset = m_labelAltitudeOffset.value(aircraftType);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (m_settings.m_verboseModelMatching)
|
|
{
|
|
if (model.isEmpty()) {
|
|
qDebug() << "ADS-B: No 3D model for " << aircraft->m_aircraftInfo->m_model << " " << aircraft->m_aircraftInfo->m_operatorICAO << " for " << aircraft->m_icaoHex;
|
|
} else {
|
|
qDebug() << "ADS-B: Matched " << aircraft->m_aircraftInfo->m_model << " " << aircraft->m_aircraftInfo->m_operatorICAO << " to " << model << " for " << aircraft->m_icaoHex;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void ADSBDemodGUI::get3DModelBasedOnCategory(Aircraft *aircraft)
|
|
{
|
|
QString aircraftType;
|
|
|
|
if (!aircraft->m_emitterCategory.compare("Heavy"))
|
|
{
|
|
static const QStringList heavy = {"B744", "B77W", "B788", "A388"};
|
|
aircraftType = heavy[m_random.bounded(heavy.size())];
|
|
}
|
|
else if (!aircraft->m_emitterCategory.compare("Large"))
|
|
{
|
|
static const QStringList large = {"A319", "A320", "A321", "B737", "B738", "B739"};
|
|
aircraftType = large[m_random.bounded(large.size())];
|
|
}
|
|
else if (!aircraft->m_emitterCategory.compare("Small"))
|
|
{
|
|
aircraftType = "LJ45";
|
|
}
|
|
else if (!aircraft->m_emitterCategory.compare("Rotorcraft"))
|
|
{
|
|
aircraft->m_aircraftCat3DModel = "helicopter.glb";
|
|
aircraft->m_modelAltitudeOffset = 4.0f;
|
|
aircraft->m_labelAltitudeOffset = 4.0f;
|
|
}
|
|
else if (!aircraft->m_emitterCategory.compare("High performance"))
|
|
{
|
|
aircraft->m_aircraftCat3DModel = "f15.glb";
|
|
aircraft->m_modelAltitudeOffset = 1.0f;
|
|
aircraft->m_labelAltitudeOffset = 6.0f;
|
|
}
|
|
else if (!aircraft->m_emitterCategory.compare("Light"))
|
|
{
|
|
aircraftType = "C172";
|
|
}
|
|
else if (!aircraft->m_emitterCategory.compare("Ultralight"))
|
|
{
|
|
aircraft->m_aircraftCat3DModel = "ultralight.glb";
|
|
aircraft->m_modelAltitudeOffset = 0.55f;
|
|
aircraft->m_labelAltitudeOffset = 0.75f;
|
|
}
|
|
else if (!aircraft->m_emitterCategory.compare("Glider/sailplane"))
|
|
{
|
|
aircraft->m_aircraftCat3DModel = "glider.glb";
|
|
aircraft->m_modelAltitudeOffset = 1.0f;
|
|
aircraft->m_labelAltitudeOffset = 1.5f;
|
|
}
|
|
else if (!aircraft->m_emitterCategory.compare("Space vehicle"))
|
|
{
|
|
aircraft->m_aircraftCat3DModel = "atlas_v.glb";
|
|
aircraft->m_labelAltitudeOffset = 16.0f;
|
|
}
|
|
else if (!aircraft->m_emitterCategory.compare("UAV"))
|
|
{
|
|
aircraft->m_aircraftCat3DModel = "drone.glb";
|
|
aircraft->m_labelAltitudeOffset = 1.0f;
|
|
}
|
|
else if (!aircraft->m_emitterCategory.compare("Emergency vehicle"))
|
|
{
|
|
aircraft->m_aircraftCat3DModel = "fire_truck.glb";
|
|
aircraft->m_modelAltitudeOffset = 0.3f;
|
|
aircraft->m_labelAltitudeOffset = 2.5f;
|
|
}
|
|
else if (!aircraft->m_emitterCategory.compare("Service vehicle"))
|
|
{
|
|
aircraft->m_aircraftCat3DModel = "airport_truck.glb";
|
|
aircraft->m_labelAltitudeOffset = 3.0f;
|
|
}
|
|
else
|
|
{
|
|
aircraftType = "A320";
|
|
}
|
|
|
|
if (!aircraftType.isEmpty())
|
|
{
|
|
aircraft->m_aircraftCat3DModel = "";
|
|
if (aircraft->m_aircraftInfo) {
|
|
aircraft->m_aircraftCat3DModel = get3DModel(aircraftType, aircraft->m_aircraftInfo->m_operatorICAO);
|
|
}
|
|
if (aircraft->m_aircraftCat3DModel.isEmpty()) {
|
|
aircraft->m_aircraftCat3DModel = get3DModel(aircraftType, aircraft->m_callsign.left(3));
|
|
}
|
|
if (aircraft->m_aircraftCat3DModel.isEmpty()) {
|
|
aircraft->m_aircraftCat3DModel = get3DModel(aircraftType);
|
|
}
|
|
if (m_modelAltitudeOffset.contains(aircraftType))
|
|
{
|
|
aircraft->m_modelAltitudeOffset = m_modelAltitudeOffset.value(aircraftType);
|
|
aircraft->m_labelAltitudeOffset = m_labelAltitudeOffset.value(aircraftType);
|
|
}
|
|
}
|
|
}
|
|
|
|
void ADSBDemodGUI::update3DModels()
|
|
{
|
|
// Look for all aircraft gltfs in 3d directory
|
|
QString modelDir = getDataDir() + "/3d";
|
|
static const QStringList subDirs = {"BB_Airbus_png", "BB_Boeing_png", "BB_Jets_png", "BB_Props_png", "BB_GA_png", "BB_Mil_png", "BB_Heli_png"};
|
|
|
|
for (auto subDir : subDirs)
|
|
{
|
|
QString dirName = modelDir + "/" + subDir;
|
|
QDir dir(dirName);
|
|
QStringList aircrafts = dir.entryList(QDir::AllDirs | QDir::NoDotAndDotDot);
|
|
for (auto aircraft : aircrafts)
|
|
{
|
|
if (m_settings.m_verboseModelMatching) {
|
|
qDebug() << "Aircraft " << aircraft;
|
|
}
|
|
QDir aircraftDir(dir.filePath(aircraft));
|
|
QStringList gltfs = aircraftDir.entryList({"*.gltf"});
|
|
QStringList allAircraft;
|
|
for (auto gltf : gltfs)
|
|
{
|
|
QStringList filenameParts = gltf.split(".")[0].split("_");
|
|
if (filenameParts.size() == 2)
|
|
{
|
|
QString livery = filenameParts[1];
|
|
if (m_settings.m_verboseModelMatching) {
|
|
qDebug() << "Aircraft " << aircraft << "Livery " << livery;
|
|
}
|
|
// Only use relative path, as Map feature will add the prefix
|
|
QString filename = subDir + "/" + aircraft + "/" + gltf;
|
|
m_3DModels.insert(aircraft + "_" + livery, filename);
|
|
allAircraft.append(filename);
|
|
}
|
|
}
|
|
if (gltfs.size() > 0) {
|
|
m_3DModelsByType.insert(aircraft, allAircraft);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Vertical offset so undercarriage isn't underground, because 0,0,0 is in the middle of the model
|
|
// rather than at the bottom
|
|
m_modelAltitudeOffset.insert("A306", 4.6f);
|
|
m_modelAltitudeOffset.insert("A310", 4.6f);
|
|
m_modelAltitudeOffset.insert("A318", 3.7f);
|
|
m_modelAltitudeOffset.insert("A319", 3.5f);
|
|
m_modelAltitudeOffset.insert("A320", 3.5f);
|
|
m_modelAltitudeOffset.insert("A321", 3.5f);
|
|
m_modelAltitudeOffset.insert("A332", 5.52f);
|
|
m_modelAltitudeOffset.insert("A333", 5.52f);
|
|
m_modelAltitudeOffset.insert("A334", 5.52f);
|
|
m_modelAltitudeOffset.insert("A343", 4.65f);
|
|
m_modelAltitudeOffset.insert("A345", 4.65f);
|
|
m_modelAltitudeOffset.insert("A346", 4.65f);
|
|
m_modelAltitudeOffset.insert("A388", 5.75f);
|
|
m_modelAltitudeOffset.insert("B717", 0.0f);
|
|
m_modelAltitudeOffset.insert("B733", 3.1f);
|
|
m_modelAltitudeOffset.insert("B734", 3.27f);
|
|
m_modelAltitudeOffset.insert("B737", 3.0f);
|
|
m_modelAltitudeOffset.insert("B738", 3.31f);
|
|
m_modelAltitudeOffset.insert("B739", 3.32f);
|
|
m_modelAltitudeOffset.insert("B74F", 5.3f);
|
|
m_modelAltitudeOffset.insert("B744", 5.25f);
|
|
m_modelAltitudeOffset.insert("B752", 3.6f);
|
|
m_modelAltitudeOffset.insert("B763", 4.44f);
|
|
m_modelAltitudeOffset.insert("B772", 5.57f);
|
|
m_modelAltitudeOffset.insert("B773", 5.6f);
|
|
m_modelAltitudeOffset.insert("B77L", 5.57f);
|
|
m_modelAltitudeOffset.insert("B77W", 5.57f);
|
|
m_modelAltitudeOffset.insert("B788", 4.1f);
|
|
m_modelAltitudeOffset.insert("BE20", 1.48f);
|
|
m_modelAltitudeOffset.insert("C150", 1.05f);
|
|
m_modelAltitudeOffset.insert("C172", 1.16f);
|
|
m_modelAltitudeOffset.insert("C421", 1.16f);
|
|
m_modelAltitudeOffset.insert("H25B", 1.45f);
|
|
m_modelAltitudeOffset.insert("LJ45", 1.27f);
|
|
m_modelAltitudeOffset.insert("B462", 1.8f);
|
|
m_modelAltitudeOffset.insert("B463", 1.9f);
|
|
m_modelAltitudeOffset.insert("CRJ2", 1.3f);
|
|
m_modelAltitudeOffset.insert("CRJ7", 1.66f);
|
|
m_modelAltitudeOffset.insert("CRJ9", 2.27f);
|
|
m_modelAltitudeOffset.insert("CRJX", 2.49f);
|
|
m_modelAltitudeOffset.insert("DC10", 5.2f);
|
|
m_modelAltitudeOffset.insert("E135", 1.88f);
|
|
m_modelAltitudeOffset.insert("E145", 1.86f);
|
|
m_modelAltitudeOffset.insert("E170", 2.3f);
|
|
m_modelAltitudeOffset.insert("E190", 3.05f);
|
|
m_modelAltitudeOffset.insert("E195", 2.97f);
|
|
m_modelAltitudeOffset.insert("F28", 2.34f);
|
|
m_modelAltitudeOffset.insert("F70", 2.43f);
|
|
m_modelAltitudeOffset.insert("F100", 2.23f);
|
|
m_modelAltitudeOffset.insert("J328", 1.01f);
|
|
m_modelAltitudeOffset.insert("MD11", 5.22f);
|
|
m_modelAltitudeOffset.insert("MD83", 2.71f);
|
|
m_modelAltitudeOffset.insert("MD90", 2.62f);
|
|
m_modelAltitudeOffset.insert("AT42", 1.75f);
|
|
m_modelAltitudeOffset.insert("AT72", 1.83f);
|
|
m_modelAltitudeOffset.insert("D328", 0.99f);
|
|
m_modelAltitudeOffset.insert("DH8D", 1.65f);
|
|
m_modelAltitudeOffset.insert("F50", 2.16f);
|
|
m_modelAltitudeOffset.insert("JS41", 1.9f);
|
|
m_modelAltitudeOffset.insert("L410", 1.1f);
|
|
m_modelAltitudeOffset.insert("SB20", 2.0f);
|
|
m_modelAltitudeOffset.insert("SF34", 1.89f);
|
|
|
|
// Label offsets (from bottom of aircraft)
|
|
m_labelAltitudeOffset.insert("A306", 10.0f);
|
|
m_labelAltitudeOffset.insert("A310", 15.0f);
|
|
m_labelAltitudeOffset.insert("A318", 10.0f);
|
|
m_labelAltitudeOffset.insert("A319", 10.0f);
|
|
m_labelAltitudeOffset.insert("A320", 10.0f);
|
|
m_labelAltitudeOffset.insert("A321", 10.0f);
|
|
m_labelAltitudeOffset.insert("A332", 14.0f);
|
|
m_labelAltitudeOffset.insert("A333", 14.0f);
|
|
m_labelAltitudeOffset.insert("A334", 14.0f);
|
|
m_labelAltitudeOffset.insert("A343", 14.0f);
|
|
m_labelAltitudeOffset.insert("A345", 14.0f);
|
|
m_labelAltitudeOffset.insert("A346", 14.0f);
|
|
m_labelAltitudeOffset.insert("A388", 20.0f);
|
|
m_labelAltitudeOffset.insert("B717", 7.5f);
|
|
m_labelAltitudeOffset.insert("B733", 10.0f);
|
|
m_labelAltitudeOffset.insert("B734", 10.0f);
|
|
m_labelAltitudeOffset.insert("B737", 10.0f);
|
|
m_labelAltitudeOffset.insert("B738", 10.0f);
|
|
m_labelAltitudeOffset.insert("B739", 10.0f);
|
|
m_labelAltitudeOffset.insert("B74F", 15.0f);
|
|
m_labelAltitudeOffset.insert("B744", 15.0f);
|
|
m_labelAltitudeOffset.insert("B752", 12.0f);
|
|
m_labelAltitudeOffset.insert("B763", 14.0f);
|
|
m_labelAltitudeOffset.insert("B772", 14.0f);
|
|
m_labelAltitudeOffset.insert("B773", 14.0f);
|
|
m_labelAltitudeOffset.insert("B77L", 14.0f);
|
|
m_labelAltitudeOffset.insert("B77W", 14.0f);
|
|
m_labelAltitudeOffset.insert("B788", 14.0f);
|
|
m_labelAltitudeOffset.insert("BE20", 4.0f);
|
|
m_labelAltitudeOffset.insert("C150", 3.0f);
|
|
m_labelAltitudeOffset.insert("C172", 3.0f);
|
|
m_labelAltitudeOffset.insert("C421", 4.0f);
|
|
m_labelAltitudeOffset.insert("H25B", 5.0f);
|
|
m_labelAltitudeOffset.insert("LJ45", 5.0f);
|
|
m_labelAltitudeOffset.insert("B462", 7.0f);
|
|
m_labelAltitudeOffset.insert("B463", 7.0f);
|
|
m_labelAltitudeOffset.insert("CRJ2", 5.5f);
|
|
m_labelAltitudeOffset.insert("CRJ7", 6.0f);
|
|
m_labelAltitudeOffset.insert("CRJ9", 6.0f);
|
|
m_labelAltitudeOffset.insert("CRJX", 6.0f);
|
|
m_labelAltitudeOffset.insert("DC10", 15.0f);
|
|
m_labelAltitudeOffset.insert("E135", 5.0f);
|
|
m_labelAltitudeOffset.insert("E145", 5.0f);
|
|
m_labelAltitudeOffset.insert("E170", 8.0f);
|
|
m_labelAltitudeOffset.insert("E190", 8.5f);
|
|
m_labelAltitudeOffset.insert("E195", 8.5f);
|
|
m_labelAltitudeOffset.insert("F28", 7.0f);
|
|
m_labelAltitudeOffset.insert("F70", 6.5f);
|
|
m_labelAltitudeOffset.insert("F100", 6.5f);
|
|
m_labelAltitudeOffset.insert("J328", 5.0f); // Check
|
|
m_labelAltitudeOffset.insert("MD11", 15.0f);
|
|
m_labelAltitudeOffset.insert("MD83", 7.5f);
|
|
m_labelAltitudeOffset.insert("MD90", 7.5f);
|
|
m_labelAltitudeOffset.insert("AT42", 7.0f);
|
|
m_labelAltitudeOffset.insert("AT72", 7.0f);
|
|
m_labelAltitudeOffset.insert("D328", 6.0f);
|
|
m_labelAltitudeOffset.insert("DH8D", 6.5f);
|
|
m_labelAltitudeOffset.insert("F50", 7.0f);
|
|
m_labelAltitudeOffset.insert("JS41", 5.0f);
|
|
m_labelAltitudeOffset.insert("L410", 5.0f);
|
|
m_labelAltitudeOffset.insert("SB20", 6.5f);
|
|
m_labelAltitudeOffset.insert("SF34", 6.0f);
|
|
|
|
// Map from database names to 3D model names
|
|
m_3DModelMatch.append(new ModelMatch("A300.*", "A306")); // A300 B4 is A300-600, but use for others as closest match
|
|
m_3DModelMatch.append(new ModelMatch("A310.*", "A310"));
|
|
m_3DModelMatch.append(new ModelMatch("A318.*", "A318"));
|
|
m_3DModelMatch.append(new ModelMatch("A.?319.*", "A319"));
|
|
m_3DModelMatch.append(new ModelMatch("A.?320.*", "A320"));
|
|
m_3DModelMatch.append(new ModelMatch("A.?321.*", "A321"));
|
|
m_3DModelMatch.append(new ModelMatch("A330.2.*", "A332"));
|
|
m_3DModelMatch.append(new ModelMatch("A330.3.*", "A333"));
|
|
m_3DModelMatch.append(new ModelMatch("A330.4.*", "A342"));
|
|
m_3DModelMatch.append(new ModelMatch("A340.3.*", "A343"));
|
|
m_3DModelMatch.append(new ModelMatch("A340.5.*", "A345"));
|
|
m_3DModelMatch.append(new ModelMatch("A340.6.*", "A346"));
|
|
m_3DModelMatch.append(new ModelMatch("A350.*", "A333")); // No A350 model - use 330 as twin engine
|
|
m_3DModelMatch.append(new ModelMatch("A380.*", "A388"));
|
|
|
|
m_3DModelMatch.append(new ModelMatch("737.2.*", "B733")); // No 200 model
|
|
m_3DModelMatch.append(new ModelMatch("737.3.*", "B733"));
|
|
m_3DModelMatch.append(new ModelMatch("737.4.*", "B734"));
|
|
m_3DModelMatch.append(new ModelMatch("737.5.*", "B734")); // No 500 model
|
|
m_3DModelMatch.append(new ModelMatch("737.6.*", "B737")); // No 600 model
|
|
m_3DModelMatch.append(new ModelMatch("737NG.6.*", "B737"));
|
|
m_3DModelMatch.append(new ModelMatch("737.7.*", "B737"));
|
|
m_3DModelMatch.append(new ModelMatch("737NG.7.*", "B737"));
|
|
m_3DModelMatch.append(new ModelMatch("737.8.*", "B738"));
|
|
m_3DModelMatch.append(new ModelMatch("737NG.8.*", "B738")); // No Max model yet
|
|
m_3DModelMatch.append(new ModelMatch("737MAX.8.*", "B738"));
|
|
m_3DModelMatch.append(new ModelMatch("737.9", "B739"));
|
|
m_3DModelMatch.append(new ModelMatch("737NG.9", "B739"));
|
|
m_3DModelMatch.append(new ModelMatch("737MAX.9", "B739"));
|
|
m_3DModelMatch.append(new ModelMatch("B747.*F", "B74F"));
|
|
m_3DModelMatch.append(new ModelMatch("B747.*\\(F\\)", "B74F"));
|
|
m_3DModelMatch.append(new ModelMatch("747.*", "B744"));
|
|
m_3DModelMatch.append(new ModelMatch("757.*", "B752"));
|
|
m_3DModelMatch.append(new ModelMatch("767.*", "B763"));
|
|
m_3DModelMatch.append(new ModelMatch("777.2.*LR.*", "B77L"));
|
|
m_3DModelMatch.append(new ModelMatch("777.2.*", "B772"));
|
|
m_3DModelMatch.append(new ModelMatch("777.3.*ER.*", "B77W"));
|
|
m_3DModelMatch.append(new ModelMatch("777.3.*", "B773"));
|
|
m_3DModelMatch.append(new ModelMatch("777.*", "B772"));
|
|
m_3DModelMatch.append(new ModelMatch("787.*", "B788"));
|
|
m_3DModelMatch.append(new ModelMatch("717.*", "B717"));
|
|
// No 727 model
|
|
|
|
// Jets
|
|
m_3DModelMatch.append(new ModelMatch(".*EMB.135.*", "E135"));
|
|
m_3DModelMatch.append(new ModelMatch(".*ERJ.135.*", "E135"));
|
|
m_3DModelMatch.append(new ModelMatch("Embraer 135.*", "E135"));
|
|
m_3DModelMatch.append(new ModelMatch(".*EMB.145.*", "E145"));
|
|
m_3DModelMatch.append(new ModelMatch(".*ERJ.145.*", "E145"));
|
|
m_3DModelMatch.append(new ModelMatch("Embraer 145.*", "E145"));
|
|
m_3DModelMatch.append(new ModelMatch(".*EMB.170.*", "E170"));
|
|
m_3DModelMatch.append(new ModelMatch(".*ERJ.170.*", "E170"));
|
|
m_3DModelMatch.append(new ModelMatch("Embraer 170.*", "E170"));
|
|
m_3DModelMatch.append(new ModelMatch(".*EMB.190.*", "E190"));
|
|
m_3DModelMatch.append(new ModelMatch(".*ERJ.190.*", "E190"));
|
|
m_3DModelMatch.append(new ModelMatch("Embraer 190.*", "E190"));
|
|
m_3DModelMatch.append(new ModelMatch(".*EMB.195.*", "E195"));
|
|
m_3DModelMatch.append(new ModelMatch(".*ERJ.195.*", "E195"));
|
|
m_3DModelMatch.append(new ModelMatch("Embraer 195.*", "E195"));
|
|
|
|
m_3DModelMatch.append(new ModelMatch(".*CRJ.200.*", "CRJ2"));
|
|
m_3DModelMatch.append(new ModelMatch(".*CRJ.700.*", "CRJ7"));
|
|
m_3DModelMatch.append(new ModelMatch(".*CRJ.900.*", "CRJ9"));
|
|
m_3DModelMatch.append(new ModelMatch(".*CRJ.1000.*", "CRJX"));
|
|
|
|
// PNGs missing
|
|
//m_3DModelMatch.append(new ModelMatch("(BAE )?146.2.*", "B462"));
|
|
//m_3DModelMatch.append(new ModelMatch("(BAE )?146.3.*", "B463"));
|
|
|
|
m_3DModelMatch.append(new ModelMatch("DC-10.*", "DC10"));
|
|
|
|
m_3DModelMatch.append(new ModelMatch(".*MD.11.*", "MD11"));
|
|
m_3DModelMatch.append(new ModelMatch(".*MD.83.*", "MD83"));
|
|
m_3DModelMatch.append(new ModelMatch(".*MD.90.*", "MD90"));
|
|
|
|
m_3DModelMatch.append(new ModelMatch(".*F28.*", "F28"));
|
|
m_3DModelMatch.append(new ModelMatch(".*F70.*", "F70"));
|
|
m_3DModelMatch.append(new ModelMatch(".*F100.*", "F100"));
|
|
|
|
// GA
|
|
m_3DModelMatch.append(new ModelMatch(".*B200.*", "BE20"));
|
|
m_3DModelMatch.append(new ManufacturerModelMatch(".*200.*", ".*Beech.*", "BE20"));
|
|
m_3DModelMatch.append(new ModelMatch(".*150.*", "C150"));
|
|
m_3DModelMatch.append(new ModelMatch(".*172.*", "C172"));
|
|
m_3DModelMatch.append(new ModelMatch(".*421.*", "C421"));
|
|
m_3DModelMatch.append(new ModelMatch(".*125.*", "H25B"));
|
|
m_3DModelMatch.append(new ManufacturerModelMatch(".*400.*", "Hawker.*", "H25B"));
|
|
m_3DModelMatch.append(new ManufacturerModelMatch(".*400.*", "Raytheon.*", "H25B"));
|
|
m_3DModelMatch.append(new ModelMatch(".*Learjet.*", "LJ45"));
|
|
|
|
// Props
|
|
m_3DModelMatch.append(new ModelMatch("ATR.*42.*", "AT42"));
|
|
m_3DModelMatch.append(new ModelMatch("ATR.*72.*", "AT72"));
|
|
m_3DModelMatch.append(new ModelMatch("Do 328.*", "D328"));
|
|
m_3DModelMatch.append(new ModelMatch("DHC-8.*", "DH8D"));
|
|
m_3DModelMatch.append(new ModelMatch(".*F50.*", "F50"));
|
|
m_3DModelMatch.append(new ModelMatch("Jetstream 41.*", "JS41"));
|
|
m_3DModelMatch.append(new ModelMatch(".*L.410.*", "L410"));
|
|
m_3DModelMatch.append(new ModelMatch("SAAB.2000.*", "SB20"));
|
|
m_3DModelMatch.append(new ManufacturerModelMatch(".*340.*", "Saab.*", "SF34"));
|
|
}
|
|
|
|
void ADSBDemodGUI::updateAirports()
|
|
{
|
|
if (!m_airportInfo) {
|
|
return;
|
|
}
|
|
|
|
m_airportModel.removeAllAirports();
|
|
QHash<int, AirportInformation *>::const_iterator i = m_airportInfo->begin();
|
|
AzEl azEl = m_azEl;
|
|
|
|
while (i != m_airportInfo->end())
|
|
{
|
|
const AirportInformation *airportInfo = i.value();
|
|
|
|
// Calculate distance and az/el to airport from My Position
|
|
azEl.setTarget(airportInfo->m_latitude, airportInfo->m_longitude, Units::feetToMetres(airportInfo->m_elevation));
|
|
azEl.calculate();
|
|
|
|
// Only display airport if in range
|
|
if (azEl.getDistance() <= m_settings.m_airportRange*1000.0f)
|
|
{
|
|
// Only display the airport if it's large enough
|
|
if (airportInfo->m_type >= (AirportInformation::AirportType)m_settings.m_airportMinimumSize)
|
|
{
|
|
// Only display heliports if enabled
|
|
if (m_settings.m_displayHeliports || (airportInfo->m_type != AirportInformation::AirportType::Heliport))
|
|
{
|
|
m_airportModel.addAirport(airportInfo, azEl.getAzimuth(), azEl.getElevation(), azEl.getDistance());
|
|
}
|
|
}
|
|
}
|
|
++i;
|
|
}
|
|
// Save settings we've just used so we know if they've changed
|
|
m_currentAirportMinimumSize = m_settings.m_airportMinimumSize;
|
|
m_currentDisplayHeliports = m_settings.m_displayHeliports;
|
|
}
|
|
|
|
void ADSBDemodGUI::updateAirspaces()
|
|
{
|
|
AzEl azEl = m_azEl;
|
|
m_airspaceModel.removeAllAirspaces();
|
|
for (const auto airspace: *m_airspaces)
|
|
{
|
|
if (m_settings.m_airspaces.contains(airspace->m_category))
|
|
{
|
|
// Calculate distance to airspace from My Position
|
|
azEl.setTarget(airspace->m_center.y(), airspace->m_center.x(), 0);
|
|
azEl.calculate();
|
|
|
|
// Only display airport if in range
|
|
if (azEl.getDistance() <= m_settings.m_airspaceRange*1000.0f) {
|
|
m_airspaceModel.addAirspace(airspace);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void ADSBDemodGUI::updateNavAids()
|
|
{
|
|
AzEl azEl = m_azEl;
|
|
m_navAidModel.removeAllNavAids();
|
|
if (m_settings.m_displayNavAids)
|
|
{
|
|
for (const auto navAid: *m_navAids)
|
|
{
|
|
// Calculate distance to NavAid from My Position
|
|
azEl.setTarget(navAid->m_latitude, navAid->m_longitude, Units::feetToMetres(navAid->m_elevation));
|
|
azEl.calculate();
|
|
|
|
// Only display NavAid if in range
|
|
if (azEl.getDistance() <= m_settings.m_airspaceRange*1000.0f) {
|
|
m_navAidModel.addNavAid(navAid);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Set a static target, such as an airport
|
|
void ADSBDemodGUI::target(const QString& name, float az, float el, float range)
|
|
{
|
|
if (m_trackAircraft)
|
|
{
|
|
// Restore colour of current target
|
|
m_trackAircraft->m_isTarget = false;
|
|
m_aircraftModel.aircraftUpdated(m_trackAircraft);
|
|
m_trackAircraft = nullptr;
|
|
}
|
|
m_adsbDemod->setTarget(name, az, el, range);
|
|
}
|
|
|
|
void ADSBDemodGUI::targetAircraft(Aircraft *aircraft)
|
|
{
|
|
if (aircraft != m_trackAircraft)
|
|
{
|
|
if (m_trackAircraft)
|
|
{
|
|
// Restore colour of current target
|
|
m_trackAircraft->m_isTarget = false;
|
|
m_aircraftModel.aircraftUpdated(m_trackAircraft);
|
|
}
|
|
// Track this aircraft
|
|
m_trackAircraft = aircraft;
|
|
if (aircraft->m_positionValid)
|
|
m_adsbDemod->setTarget(aircraft->targetName(), aircraft->m_azimuth, aircraft->m_elevation, aircraft->m_range);
|
|
// Change colour of new target
|
|
aircraft->m_isTarget = true;
|
|
m_aircraftModel.aircraftUpdated(aircraft);
|
|
}
|
|
}
|
|
|
|
void ADSBDemodGUI::updatePhotoText(Aircraft *aircraft)
|
|
{
|
|
if (m_settings.m_displayPhotos)
|
|
{
|
|
QString callsign = aircraft->m_callsignItem->text().trimmed();
|
|
QString reg = aircraft->m_registrationItem->text().trimmed();
|
|
if (!callsign.isEmpty() && !reg.isEmpty()) {
|
|
ui->photoHeader->setText(QString("%1 - %2").arg(callsign).arg(reg));
|
|
} else if (!callsign.isEmpty()) {
|
|
ui->photoHeader->setText(QString("%1").arg(callsign));
|
|
} else if (!reg.isEmpty()) {
|
|
ui->photoHeader->setText(QString("%1").arg(reg));
|
|
}
|
|
|
|
QIcon icon = aircraft->m_countryItem->icon();
|
|
QList<QSize> sizes = icon.availableSizes();
|
|
if (sizes.size() > 0) {
|
|
ui->photoFlag->setPixmap(icon.pixmap(sizes[0]));
|
|
} else {
|
|
ui->photoFlag->setPixmap(QPixmap());
|
|
}
|
|
|
|
updatePhotoFlightInformation(aircraft);
|
|
|
|
QString aircraftDetails = "<table width=200>"; // Note, Qt seems to make the table bigger than this so text is cropped, not wrapped
|
|
QString manufacturer = aircraft->m_manufacturerNameItem->text();
|
|
if (!manufacturer.isEmpty()) {
|
|
aircraftDetails.append(QString("<tr><th align=left>Manufacturer:<td>%1").arg(manufacturer));
|
|
}
|
|
QString model = aircraft->m_modelItem->text();
|
|
if (!model.isEmpty()) {
|
|
aircraftDetails.append(QString("<tr><th align=left>Aircraft:<td>%1").arg(model));
|
|
}
|
|
QString owner = aircraft->m_ownerItem->text();
|
|
if (!owner.isEmpty()) {
|
|
aircraftDetails.append(QString("<tr><th align=left>Owner:<td>%1").arg(owner));
|
|
}
|
|
QString operatorICAO = aircraft->m_operatorICAOItem->text();
|
|
if (!operatorICAO.isEmpty()) {
|
|
aircraftDetails.append(QString("<tr><th align=left>Operator:<td>%1").arg(operatorICAO));
|
|
}
|
|
QString registered = aircraft->m_registeredItem->text();
|
|
if (!registered.isEmpty()) {
|
|
aircraftDetails.append(QString("<tr><th align=left>Registered:<td>%1").arg(registered));
|
|
}
|
|
aircraftDetails.append("</table>");
|
|
ui->aircraftDetails->setText(aircraftDetails);
|
|
}
|
|
}
|
|
|
|
void ADSBDemodGUI::updatePhotoFlightInformation(Aircraft *aircraft)
|
|
{
|
|
if (m_settings.m_displayPhotos)
|
|
{
|
|
QString dep = aircraft->m_depItem->text();
|
|
QString arr = aircraft->m_arrItem->text();
|
|
QString std = aircraft->m_stdItem->text();
|
|
QString etd = aircraft->m_etdItem->text();
|
|
QString atd = aircraft->m_atdItem->text();
|
|
QString sta = aircraft->m_staItem->text();
|
|
QString eta = aircraft->m_etaItem->text();
|
|
QString ata = aircraft->m_ataItem->text();
|
|
QString flightDetails;
|
|
if (!dep.isEmpty() && !arr.isEmpty())
|
|
{
|
|
flightDetails = QString("<center><table width=200><tr><th colspan=4>%1 - %2").arg(dep).arg(arr);
|
|
if (!std.isEmpty() && !sta.isEmpty()) {
|
|
flightDetails.append(QString("<tr><td>STD<td>%1<td>STA<td>%2").arg(std).arg(sta));
|
|
}
|
|
if ((!atd.isEmpty() || !etd.isEmpty()) && (!ata.isEmpty() || !eta.isEmpty()))
|
|
{
|
|
if (!atd.isEmpty()) {
|
|
flightDetails.append(QString("<tr><td>Actual<td>%1").arg(atd));
|
|
} else if (!etd.isEmpty()) {
|
|
flightDetails.append(QString("<tr><td>Estimated<td>%1").arg(etd));
|
|
}
|
|
if (!ata.isEmpty()) {
|
|
flightDetails.append(QString("<td>Actual<td>%1").arg(ata));
|
|
} else if (!eta.isEmpty()) {
|
|
flightDetails.append(QString("<td>Estimated<td>%1").arg(eta));
|
|
}
|
|
}
|
|
flightDetails.append("</center>");
|
|
}
|
|
ui->flightDetails->setText(flightDetails);
|
|
}
|
|
}
|
|
|
|
void ADSBDemodGUI::highlightAircraft(Aircraft *aircraft)
|
|
{
|
|
if (aircraft != m_highlightAircraft)
|
|
{
|
|
// Hide photo of old aircraft
|
|
ui->photoHeader->setVisible(false);
|
|
ui->photoFlag->setVisible(false);
|
|
ui->photo->setVisible(false);
|
|
ui->flightDetails->setVisible(false);
|
|
ui->aircraftDetails->setVisible(false);
|
|
if (m_highlightAircraft)
|
|
{
|
|
// Restore colour
|
|
m_highlightAircraft->m_isHighlighted = false;
|
|
m_aircraftModel.aircraftUpdated(m_highlightAircraft);
|
|
}
|
|
// Highlight this aircraft
|
|
m_highlightAircraft = aircraft;
|
|
if (aircraft)
|
|
{
|
|
aircraft->m_isHighlighted = true;
|
|
m_aircraftModel.aircraftUpdated(aircraft);
|
|
if (m_settings.m_displayPhotos)
|
|
{
|
|
// Download photo
|
|
updatePhotoText(aircraft);
|
|
m_planeSpotters.getAircraftPhoto(aircraft->m_icaoHex);
|
|
}
|
|
}
|
|
}
|
|
if (aircraft)
|
|
{
|
|
// Highlight the row in the table - always do this, as it can become
|
|
// unselected
|
|
ui->adsbData->selectRow(aircraft->m_icaoItem->row());
|
|
}
|
|
else
|
|
{
|
|
ui->adsbData->clearSelection();
|
|
}
|
|
}
|
|
|
|
// Show feed dialog
|
|
void ADSBDemodGUI::feedSelect(const QPoint& p)
|
|
{
|
|
ADSBDemodFeedDialog dialog(&m_settings);
|
|
dialog.move(p);
|
|
|
|
if (dialog.exec() == QDialog::Accepted)
|
|
{
|
|
applySettings();
|
|
applyImportSettings();
|
|
}
|
|
}
|
|
|
|
// Show display settings dialog
|
|
void ADSBDemodGUI::on_displaySettings_clicked()
|
|
{
|
|
bool oldSiUnits = m_settings.m_siUnits;
|
|
ADSBDemodDisplayDialog dialog(&m_settings);
|
|
if (dialog.exec() == QDialog::Accepted)
|
|
{
|
|
bool unitsChanged = m_settings.m_siUnits != oldSiUnits;
|
|
if (unitsChanged) {
|
|
m_aircraftModel.allAircraftUpdated();
|
|
}
|
|
displaySettings();
|
|
applySettings();
|
|
}
|
|
}
|
|
|
|
void ADSBDemodGUI::applyMapSettings()
|
|
{
|
|
Real stationLatitude = MainCore::instance()->getSettings().getLatitude();
|
|
Real stationLongitude = MainCore::instance()->getSettings().getLongitude();
|
|
Real stationAltitude = MainCore::instance()->getSettings().getAltitude();
|
|
|
|
QQuickItem *item = ui->map->rootObject();
|
|
if (!item)
|
|
{
|
|
qCritical("ADSBDemodGUI::applyMapSettings: Map not found. Are all required Qt plugins installed?");
|
|
return;
|
|
}
|
|
|
|
QObject *object = item->findChild<QObject*>("map");
|
|
QGeoCoordinate coords;
|
|
double zoom;
|
|
if (object != nullptr)
|
|
{
|
|
// Save existing position of map
|
|
coords = object->property("center").value<QGeoCoordinate>();
|
|
zoom = object->property("zoomLevel").value<double>();
|
|
}
|
|
else
|
|
{
|
|
// Center on my location when map is first opened
|
|
coords.setLatitude(stationLatitude);
|
|
coords.setLongitude(stationLongitude);
|
|
coords.setAltitude(stationAltitude);
|
|
zoom = 10.0;
|
|
}
|
|
|
|
// Create the map using the specified provider
|
|
QQmlProperty::write(item, "smoothing", MainCore::instance()->getSettings().getMapSmoothing());
|
|
QQmlProperty::write(item, "aircraftMinZoomLevel", m_settings.m_aircraftMinZoom);
|
|
QQmlProperty::write(item, "mapProvider", m_settings.m_mapProvider);
|
|
QVariantMap parameters;
|
|
QString mapType;
|
|
|
|
if (m_settings.m_mapProvider == "osm")
|
|
{
|
|
// Use our repo, so we can append API key and redefine transmit maps
|
|
parameters["osm.mapping.providersrepository.address"] = QString("http://127.0.0.1:%1/").arg(m_osmPort);
|
|
// Use ADS-B specific cache, as we use different transmit maps
|
|
QString cachePath = QStandardPaths::writableLocation(QStandardPaths::GenericCacheLocation) + "/QtLocation/5.8/tiles/osm/sdrangel_adsb";
|
|
parameters["osm.mapping.cache.directory"] = cachePath;
|
|
// On Linux, we need to create the directory
|
|
QDir dir(cachePath);
|
|
if (!dir.exists()) {
|
|
dir.mkpath(cachePath);
|
|
}
|
|
switch (m_settings.m_mapType)
|
|
{
|
|
case ADSBDemodSettings::AVIATION_LIGHT:
|
|
mapType = "Transit Map";
|
|
break;
|
|
case ADSBDemodSettings::AVIATION_DARK:
|
|
mapType = "Night Transit Map";
|
|
break;
|
|
case ADSBDemodSettings::STREET:
|
|
mapType = "Street Map";
|
|
break;
|
|
case ADSBDemodSettings::SATELLITE:
|
|
mapType = "Satellite Map";
|
|
break;
|
|
}
|
|
}
|
|
else if (m_settings.m_mapProvider == "mapboxgl")
|
|
{
|
|
switch (m_settings.m_mapType)
|
|
{
|
|
case ADSBDemodSettings::AVIATION_LIGHT:
|
|
mapType = "mapbox://styles/mapbox/light-v9";
|
|
break;
|
|
case ADSBDemodSettings::AVIATION_DARK:
|
|
mapType = "mapbox://styles/mapbox/dark-v9";
|
|
break;
|
|
case ADSBDemodSettings::STREET:
|
|
mapType = "mapbox://styles/mapbox/streets-v10";
|
|
break;
|
|
case ADSBDemodSettings::SATELLITE:
|
|
mapType = "mapbox://styles/mapbox/satellite-v9";
|
|
break;
|
|
}
|
|
}
|
|
|
|
QVariant retVal;
|
|
if (!QMetaObject::invokeMethod(item, "createMap", Qt::DirectConnection,
|
|
Q_RETURN_ARG(QVariant, retVal),
|
|
Q_ARG(QVariant, QVariant::fromValue(parameters)),
|
|
Q_ARG(QVariant, mapType),
|
|
Q_ARG(QVariant, QVariant::fromValue(this))))
|
|
{
|
|
qCritical() << "ADSBDemodGUI::applyMapSettings - Failed to invoke createMap";
|
|
}
|
|
QObject *newMap = retVal.value<QObject *>();
|
|
|
|
// Restore position of map
|
|
if (newMap != nullptr)
|
|
{
|
|
if (coords.isValid())
|
|
{
|
|
newMap->setProperty("zoomLevel", QVariant::fromValue(zoom));
|
|
newMap->setProperty("center", QVariant::fromValue(coords));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
qDebug() << "ADSBDemodGUI::applyMapSettings - createMap returned a nullptr";
|
|
}
|
|
|
|
// Move antenna icon to My Position
|
|
QObject *stationObject = newMap->findChild<QObject*>("station");
|
|
if(stationObject != NULL)
|
|
{
|
|
QGeoCoordinate coords = stationObject->property("coordinate").value<QGeoCoordinate>();
|
|
coords.setLatitude(stationLatitude);
|
|
coords.setLongitude(stationLongitude);
|
|
coords.setAltitude(stationAltitude);
|
|
stationObject->setProperty("coordinate", QVariant::fromValue(coords));
|
|
stationObject->setProperty("stationName", QVariant::fromValue(MainCore::instance()->getSettings().getStationName()));
|
|
}
|
|
else
|
|
{
|
|
qDebug() << "ADSBDemodGUI::applyMapSettings - Couldn't find station";
|
|
}
|
|
}
|
|
|
|
// Called from QML when empty space clicked
|
|
void ADSBDemodGUI::clearHighlighted()
|
|
{
|
|
highlightAircraft(nullptr);
|
|
}
|
|
|
|
ADSBDemodGUI::ADSBDemodGUI(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, BasebandSampleSink *rxChannel, QWidget* parent) :
|
|
ChannelGUI(parent),
|
|
ui(new Ui::ADSBDemodGUI),
|
|
m_pluginAPI(pluginAPI),
|
|
m_deviceUISet(deviceUISet),
|
|
m_channelMarker(this),
|
|
m_deviceCenterFrequency(0),
|
|
m_basebandSampleRate(1),
|
|
m_basicSettingsShown(false),
|
|
m_doApplySettings(true),
|
|
m_tickCount(0),
|
|
m_aircraftInfo(nullptr),
|
|
m_airportModel(this),
|
|
m_airspaceModel(this),
|
|
m_trackAircraft(nullptr),
|
|
m_highlightAircraft(nullptr),
|
|
m_speech(nullptr),
|
|
m_progressDialog(nullptr),
|
|
m_loadingData(false)
|
|
{
|
|
setAttribute(Qt::WA_DeleteOnClose, true);
|
|
m_helpURL = "plugins/channelrx/demodadsb/readme.md";
|
|
RollupContents *rollupContents = getRollupContents();
|
|
ui->setupUi(rollupContents);
|
|
setSizePolicy(rollupContents->sizePolicy());
|
|
rollupContents->arrangeRollups();
|
|
connect(rollupContents, SIGNAL(widgetRolled(QWidget*,bool)), this, SLOT(onWidgetRolled(QWidget*,bool)));
|
|
|
|
// Enable MSAA antialiasing on 2D map
|
|
// This can be much faster than using layer.smooth in the QML, when there are many items
|
|
// However, only seems to work when set to 16, and doesn't seem to be supported on all graphics cards
|
|
int multisamples = MainCore::instance()->getSettings().getMapMultisampling();
|
|
if (multisamples > 0)
|
|
{
|
|
QSurfaceFormat format;
|
|
format.setSamples(multisamples);
|
|
ui->map->setFormat(format);
|
|
}
|
|
|
|
m_osmPort = 0; // Pick a free port
|
|
m_templateServer = new ADSBOSMTemplateServer("q2RVNAe3eFKCH4XsrE3r", m_osmPort);
|
|
|
|
ui->map->setAttribute(Qt::WA_AcceptTouchEvents, true);
|
|
|
|
ui->map->rootContext()->setContextProperty("aircraftModel", &m_aircraftModel);
|
|
ui->map->rootContext()->setContextProperty("airportModel", &m_airportModel);
|
|
ui->map->rootContext()->setContextProperty("airspaceModel", &m_airspaceModel);
|
|
ui->map->rootContext()->setContextProperty("navAidModel", &m_navAidModel);
|
|
ui->map->setSource(QUrl(QStringLiteral("qrc:/map/map.qml")));
|
|
|
|
connect(this, SIGNAL(customContextMenuRequested(const QPoint &)), this, SLOT(onMenuDialogCalled(const QPoint &)));
|
|
|
|
m_adsbDemod = reinterpret_cast<ADSBDemod*>(rxChannel); //new ADSBDemod(m_deviceUISet->m_deviceSourceAPI);
|
|
m_adsbDemod->setMessageQueueToGUI(getInputMessageQueue());
|
|
|
|
connect(&MainCore::instance()->getMasterTimer(), SIGNAL(timeout()), this, SLOT(tick()));
|
|
|
|
CRightClickEnabler *feedRightClickEnabler = new CRightClickEnabler(ui->feed);
|
|
connect(feedRightClickEnabler, SIGNAL(rightClick(const QPoint &)), this, SLOT(feedSelect(const QPoint &)));
|
|
|
|
ui->channelPowerMeter->setColorTheme(LevelMeterSignalDB::ColorGreenAndBlue);
|
|
|
|
ui->warning->setVisible(false);
|
|
ui->warning->setStyleSheet("QLabel { background-color: red; }");
|
|
|
|
ui->deltaFrequencyLabel->setText(QString("%1f").arg(QChar(0x94, 0x03)));
|
|
ui->deltaFrequency->setColorMapper(ColorMapper(ColorMapper::GrayGold));
|
|
ui->deltaFrequency->setValueRange(false, 7, -9999999, 9999999);
|
|
|
|
m_channelMarker.blockSignals(true);
|
|
m_channelMarker.setColor(Qt::red);
|
|
m_channelMarker.setBandwidth(5000);
|
|
m_channelMarker.setCenterFrequency(0);
|
|
m_channelMarker.setTitle("ADS-B Demodulator");
|
|
m_channelMarker.blockSignals(false);
|
|
m_channelMarker.setVisible(true); // activate signal on the last setting only
|
|
|
|
m_settings.setChannelMarker(&m_channelMarker);
|
|
m_settings.setRollupState(&m_rollupState);
|
|
|
|
m_deviceUISet->addChannelMarker(&m_channelMarker);
|
|
|
|
connect(&m_channelMarker, SIGNAL(changedByCursor()), this, SLOT(channelMarkerChangedByCursor()));
|
|
connect(&m_channelMarker, SIGNAL(highlightedByCursor()), this, SLOT(channelMarkerHighlightedByCursor()));
|
|
|
|
connect(getInputMessageQueue(), SIGNAL(messageEnqueued()), this, SLOT(handleInputMessages()));
|
|
|
|
// Set size of airline icons
|
|
ui->adsbData->setIconSize(QSize(85, 20));
|
|
// Resize the table using dummy data
|
|
resizeTable();
|
|
// Allow user to reorder columns
|
|
ui->adsbData->horizontalHeader()->setSectionsMovable(true);
|
|
// Allow user to sort table by clicking on headers
|
|
ui->adsbData->setSortingEnabled(true);
|
|
// Add context menu to allow hiding/showing of columns
|
|
menu = new QMenu(ui->adsbData);
|
|
for (int i = 0; i < ui->adsbData->horizontalHeader()->count(); i++)
|
|
{
|
|
QString text = ui->adsbData->horizontalHeaderItem(i)->text();
|
|
menu->addAction(createCheckableItem(text, i, true));
|
|
}
|
|
ui->adsbData->horizontalHeader()->setContextMenuPolicy(Qt::CustomContextMenu);
|
|
connect(ui->adsbData->horizontalHeader(), SIGNAL(customContextMenuRequested(QPoint)), SLOT(columnSelectMenu(QPoint)));
|
|
// Get signals when columns change
|
|
connect(ui->adsbData->horizontalHeader(), SIGNAL(sectionMoved(int, int, int)), SLOT(adsbData_sectionMoved(int, int, int)));
|
|
connect(ui->adsbData->horizontalHeader(), SIGNAL(sectionResized(int, int, int)), SLOT(adsbData_sectionResized(int, int, int)));
|
|
// Context menu
|
|
ui->adsbData->setContextMenuPolicy(Qt::CustomContextMenu);
|
|
connect(ui->adsbData, SIGNAL(customContextMenuRequested(QPoint)), SLOT(adsbData_customContextMenuRequested(QPoint)));
|
|
TableTapAndHold *tableTapAndHold = new TableTapAndHold(ui->adsbData);
|
|
connect(tableTapAndHold, &TableTapAndHold::tapAndHold, this, &ADSBDemodGUI::adsbData_customContextMenuRequested);
|
|
|
|
ui->photoHeader->setVisible(false);
|
|
ui->photoFlag->setVisible(false);
|
|
ui->photo->setVisible(false);
|
|
ui->flightDetails->setVisible(false);
|
|
ui->aircraftDetails->setVisible(false);
|
|
|
|
// Read aircraft information database, if it has previously been downloaded
|
|
AircraftInformation::init();
|
|
connect(&m_osnDB, &OsnDB::downloadingURL, this, &ADSBDemodGUI::downloadingURL);
|
|
connect(&m_osnDB, &OsnDB::downloadError, this, &ADSBDemodGUI::downloadError);
|
|
connect(&m_osnDB, &OsnDB::downloadProgress, this, &ADSBDemodGUI::downloadProgress);
|
|
connect(&m_osnDB, &OsnDB::downloadAircraftInformationFinished, this, &ADSBDemodGUI::downloadAircraftInformationFinished);
|
|
m_aircraftInfo = OsnDB::getAircraftInformation();
|
|
|
|
// Read airport information database, if it has previously been downloaded
|
|
connect(&m_ourAirportsDB, &OurAirportsDB::downloadingURL, this, &ADSBDemodGUI::downloadingURL);
|
|
connect(&m_ourAirportsDB, &OurAirportsDB::downloadError, this, &ADSBDemodGUI::downloadError);
|
|
connect(&m_ourAirportsDB, &OurAirportsDB::downloadProgress, this, &ADSBDemodGUI::downloadProgress);
|
|
connect(&m_ourAirportsDB, &OurAirportsDB::downloadAirportInformationFinished, this, &ADSBDemodGUI::downloadAirportInformationFinished);
|
|
m_airportInfo = OurAirportsDB::getAirportsById();
|
|
|
|
// Read airspaces and NAVAIDs
|
|
connect(&m_openAIP, &OpenAIP::downloadingURL, this, &ADSBDemodGUI::downloadingURL);
|
|
connect(&m_openAIP, &OpenAIP::downloadError, this, &ADSBDemodGUI::downloadError);
|
|
connect(&m_openAIP, &OpenAIP::downloadAirspaceFinished, this, &ADSBDemodGUI::downloadAirspaceFinished);
|
|
connect(&m_openAIP, &OpenAIP::downloadNavAidsFinished, this, &ADSBDemodGUI::downloadNavAidsFinished);
|
|
m_airspaces = OpenAIP::getAirspaces();
|
|
m_navAids = OpenAIP::getNavAids();
|
|
|
|
// Get station position
|
|
Real stationLatitude = MainCore::instance()->getSettings().getLatitude();
|
|
Real stationLongitude = MainCore::instance()->getSettings().getLongitude();
|
|
Real stationAltitude = MainCore::instance()->getSettings().getAltitude();
|
|
m_azEl.setLocation(stationLatitude, stationLongitude, stationAltitude);
|
|
|
|
// These are the default values in sdrbase/settings/preferences.cpp
|
|
if ((stationLatitude == 49.012423) && (stationLongitude == 8.418125)) {
|
|
ui->warning->setText("Please set your antenna location under Preferences > My Position");
|
|
}
|
|
|
|
// Get updated when position changes
|
|
connect(&MainCore::instance()->getSettings(), &MainSettings::preferenceChanged, this, &ADSBDemodGUI::preferenceChanged);
|
|
|
|
// Get airport weather when requested
|
|
connect(&m_airportModel, &AirportModel::requestMetar, this, &ADSBDemodGUI::requestMetar);
|
|
|
|
// Add airports within range of My Position
|
|
updateAirports();
|
|
updateAirspaces();
|
|
updateNavAids();
|
|
update3DModels();
|
|
|
|
m_flightInformation = nullptr;
|
|
m_aviationWeather = nullptr;
|
|
|
|
connect(&m_planeSpotters, &PlaneSpotters::aircraftPhoto, this, &ADSBDemodGUI::aircraftPhoto);
|
|
connect(ui->photo, &ClickableLabel::clicked, this, &ADSBDemodGUI::photoClicked);
|
|
|
|
// Update demod list when channels are added or removed
|
|
connect(MainCore::instance(), &MainCore::channelAdded, this, &ADSBDemodGUI::updateChannelList);
|
|
connect(MainCore::instance(), &MainCore::channelRemoved, this, &ADSBDemodGUI::updateChannelList);
|
|
|
|
updateChannelList();
|
|
displaySettings();
|
|
makeUIConnections();
|
|
applySettings(true);
|
|
|
|
connect(&m_importTimer, &QTimer::timeout, this, &ADSBDemodGUI::import);
|
|
m_networkManager = new QNetworkAccessManager();
|
|
QObject::connect(
|
|
m_networkManager,
|
|
&QNetworkAccessManager::finished,
|
|
this,
|
|
&ADSBDemodGUI::handleImportReply
|
|
);
|
|
applyImportSettings();
|
|
|
|
connect(&m_redrawMapTimer, &QTimer::timeout, this, &ADSBDemodGUI::redrawMap);
|
|
m_redrawMapTimer.setSingleShot(true);
|
|
ui->map->installEventFilter(this);
|
|
DialPopup::addPopupsToChildDials(this);
|
|
}
|
|
|
|
ADSBDemodGUI::~ADSBDemodGUI()
|
|
{
|
|
if (m_templateServer)
|
|
{
|
|
m_templateServer->close();
|
|
delete m_templateServer;
|
|
}
|
|
disconnect(&m_openAIP, &OpenAIP::downloadingURL, this, &ADSBDemodGUI::downloadingURL);
|
|
disconnect(&m_openAIP, &OpenAIP::downloadError, this, &ADSBDemodGUI::downloadError);
|
|
disconnect(&m_openAIP, &OpenAIP::downloadAirspaceFinished, this, &ADSBDemodGUI::downloadAirspaceFinished);
|
|
disconnect(&m_openAIP, &OpenAIP::downloadNavAidsFinished, this, &ADSBDemodGUI::downloadNavAidsFinished);
|
|
disconnect(&m_planeSpotters, &PlaneSpotters::aircraftPhoto, this, &ADSBDemodGUI::aircraftPhoto);
|
|
disconnect(&m_redrawMapTimer, &QTimer::timeout, this, &ADSBDemodGUI::redrawMap);
|
|
disconnect(&MainCore::instance()->getMasterTimer(), &QTimer::timeout, this, &ADSBDemodGUI::tick);
|
|
m_redrawMapTimer.stop();
|
|
// Remove aircraft from Map feature
|
|
QHash<int, Aircraft *>::iterator i = m_aircraft.begin();
|
|
while (i != m_aircraft.end())
|
|
{
|
|
Aircraft *aircraft = i.value();
|
|
clearFromMap(QString("%1").arg(aircraft->m_icao, 0, 16));
|
|
++i;
|
|
}
|
|
delete ui;
|
|
qDeleteAll(m_aircraft);
|
|
if (m_flightInformation)
|
|
{
|
|
disconnect(m_flightInformation, &FlightInformation::flightUpdated, this, &ADSBDemodGUI::flightInformationUpdated);
|
|
delete m_flightInformation;
|
|
}
|
|
delete m_aviationWeather;
|
|
qDeleteAll(m_3DModelMatch);
|
|
delete m_networkManager;
|
|
}
|
|
|
|
void ADSBDemodGUI::applySettings(bool force)
|
|
{
|
|
if (m_doApplySettings)
|
|
{
|
|
qDebug() << "ADSBDemodGUI::applySettings";
|
|
|
|
ADSBDemod::MsgConfigureADSBDemod* message = ADSBDemod::MsgConfigureADSBDemod::create(m_settings, force);
|
|
m_adsbDemod->getInputMessageQueue()->push(message);
|
|
}
|
|
}
|
|
|
|
void ADSBDemodGUI::displaySettings()
|
|
{
|
|
m_channelMarker.blockSignals(true);
|
|
m_channelMarker.setCenterFrequency(m_settings.m_inputFrequencyOffset);
|
|
m_channelMarker.setBandwidth(m_settings.m_rfBandwidth);
|
|
m_channelMarker.setTitle(m_settings.m_title);
|
|
m_channelMarker.blockSignals(false);
|
|
m_channelMarker.setColor(m_settings.m_rgbColor);
|
|
|
|
setTitleColor(m_settings.m_rgbColor);
|
|
setWindowTitle(m_channelMarker.getTitle());
|
|
setTitle(m_channelMarker.getTitle());
|
|
|
|
blockApplySettings(true);
|
|
|
|
ui->deltaFrequency->setValue(m_channelMarker.getCenterFrequency());
|
|
|
|
ui->rfBWText->setText(QString("%1M").arg(m_settings.m_rfBandwidth / 1000000.0, 0, 'f', 1));
|
|
ui->rfBW->setValue((int)m_settings.m_rfBandwidth);
|
|
|
|
ui->spb->setCurrentIndex(m_settings.m_samplesPerBit/2-1);
|
|
ui->correlateFullPreamble->setChecked(m_settings.m_correlateFullPreamble);
|
|
ui->demodModeS->setChecked(m_settings.m_demodModeS);
|
|
|
|
ui->thresholdText->setText(QString("%1").arg(m_settings.m_correlationThreshold, 0, 'f', 1));
|
|
ui->threshold->setValue((int)(m_settings.m_correlationThreshold*10.0f));
|
|
|
|
ui->phaseStepsText->setText(QString("%1").arg(m_settings.m_interpolatorPhaseSteps));
|
|
ui->phaseSteps->setValue(m_settings.m_interpolatorPhaseSteps);
|
|
ui->tapsPerPhaseText->setText(QString("%1").arg(m_settings.m_interpolatorTapsPerPhase, 0, 'f', 1));
|
|
ui->tapsPerPhase->setValue((int)(m_settings.m_interpolatorTapsPerPhase*10.0f));
|
|
// Enable these controls only for developers
|
|
if (1)
|
|
{
|
|
ui->phaseStepsText->setVisible(false);
|
|
ui->phaseSteps->setVisible(false);
|
|
ui->tapsPerPhaseText->setVisible(false);
|
|
ui->tapsPerPhase->setVisible(false);
|
|
}
|
|
ui->feed->setChecked(m_settings.m_feedEnabled);
|
|
|
|
ui->flightPaths->setChecked(m_settings.m_flightPaths);
|
|
m_aircraftModel.setFlightPaths(m_settings.m_flightPaths);
|
|
ui->allFlightPaths->setChecked(m_settings.m_allFlightPaths);
|
|
m_aircraftModel.setAllFlightPaths(m_settings.m_allFlightPaths);
|
|
|
|
m_aircraftModel.setSettings(&m_settings);
|
|
|
|
ui->logFilename->setToolTip(QString(".csv log filename: %1").arg(m_settings.m_logFilename));
|
|
ui->logEnable->setChecked(m_settings.m_logEnabled);
|
|
|
|
updateIndexLabel();
|
|
|
|
QFont font(m_settings.m_tableFontName, m_settings.m_tableFontSize);
|
|
ui->adsbData->setFont(font);
|
|
|
|
// Set units in column headers
|
|
if (m_settings.m_siUnits)
|
|
{
|
|
ui->adsbData->horizontalHeaderItem(ADSB_COL_ALTITUDE)->setText("Alt (m)");
|
|
ui->adsbData->horizontalHeaderItem(ADSB_COL_VERTICALRATE)->setText("VR (m/s)");
|
|
ui->adsbData->horizontalHeaderItem(ADSB_COL_SEL_ALTITUDE)->setText("Sel Alt (m)");
|
|
ui->adsbData->horizontalHeaderItem(ADSB_COL_GROUND_SPEED)->setText("GS (kph)");
|
|
ui->adsbData->horizontalHeaderItem(ADSB_COL_TRUE_AIRSPEED)->setText("TAS (kph)");
|
|
ui->adsbData->horizontalHeaderItem(ADSB_COL_INDICATED_AIRSPEED)->setText("IAS (kph)");
|
|
ui->adsbData->horizontalHeaderItem(ADSB_COL_HEADWIND)->setText("H Wnd (kph)");
|
|
ui->adsbData->horizontalHeaderItem(ADSB_COL_WIND_SPEED)->setText("Wnd (kph)");
|
|
}
|
|
else
|
|
{
|
|
ui->adsbData->horizontalHeaderItem(ADSB_COL_ALTITUDE)->setText("Alt (ft)");
|
|
ui->adsbData->horizontalHeaderItem(ADSB_COL_VERTICALRATE)->setText("VR (ft/m)");
|
|
ui->adsbData->horizontalHeaderItem(ADSB_COL_SEL_ALTITUDE)->setText("Sel Alt (ft)");
|
|
ui->adsbData->horizontalHeaderItem(ADSB_COL_GROUND_SPEED)->setText("GS (kn)");
|
|
ui->adsbData->horizontalHeaderItem(ADSB_COL_TRUE_AIRSPEED)->setText("TAS (kn)");
|
|
ui->adsbData->horizontalHeaderItem(ADSB_COL_INDICATED_AIRSPEED)->setText("IAS (kn)");
|
|
ui->adsbData->horizontalHeaderItem(ADSB_COL_HEADWIND)->setText("H Wnd (kn)");
|
|
ui->adsbData->horizontalHeaderItem(ADSB_COL_WIND_SPEED)->setText("Wnd (kn)");
|
|
}
|
|
|
|
// Order and size columns
|
|
QHeaderView *header = ui->adsbData->horizontalHeader();
|
|
for (int i = 0; i < ADSBDEMOD_COLUMNS; i++)
|
|
{
|
|
bool hidden = m_settings.m_columnSizes[i] == 0;
|
|
header->setSectionHidden(i, hidden);
|
|
menu->actions().at(i)->setChecked(!hidden);
|
|
if (m_settings.m_columnSizes[i] > 0)
|
|
ui->adsbData->setColumnWidth(i, m_settings.m_columnSizes[i]);
|
|
header->moveSection(header->visualIndex(i), m_settings.m_columnIndexes[i]);
|
|
}
|
|
|
|
// Only update airports on map if settings have changed
|
|
if ((m_airportInfo != nullptr)
|
|
&& ((m_settings.m_airportRange != m_currentAirportRange)
|
|
|| (m_settings.m_airportMinimumSize != m_currentAirportMinimumSize)
|
|
|| (m_settings.m_displayHeliports != m_currentDisplayHeliports)))
|
|
updateAirports();
|
|
|
|
updateAirspaces();
|
|
updateNavAids();
|
|
|
|
if (!m_settings.m_displayDemodStats)
|
|
ui->stats->setText("");
|
|
|
|
initFlightInformation();
|
|
initAviationWeather();
|
|
|
|
applyMapSettings();
|
|
applyImportSettings();
|
|
|
|
getRollupContents()->restoreState(m_rollupState);
|
|
blockApplySettings(false);
|
|
enableSpeechIfNeeded();
|
|
}
|
|
|
|
void ADSBDemodGUI::leaveEvent(QEvent* event)
|
|
{
|
|
m_channelMarker.setHighlighted(false);
|
|
ChannelGUI::leaveEvent(event);
|
|
}
|
|
|
|
void ADSBDemodGUI::enterEvent(EnterEventType* event)
|
|
{
|
|
m_channelMarker.setHighlighted(true);
|
|
ChannelGUI::enterEvent(event);
|
|
}
|
|
|
|
void ADSBDemodGUI::blockApplySettings(bool block)
|
|
{
|
|
m_doApplySettings = !block;
|
|
}
|
|
|
|
void ADSBDemodGUI::tick()
|
|
{
|
|
double magsqAvg, magsqPeak;
|
|
int nbMagsqSamples;
|
|
m_adsbDemod->getMagSqLevels(magsqAvg, magsqPeak, nbMagsqSamples);
|
|
double powDbAvg = CalcDb::dbPower(magsqAvg);
|
|
double powDbPeak = CalcDb::dbPower(magsqPeak);
|
|
|
|
ui->channelPowerMeter->levelChanged(
|
|
(100.0f + powDbAvg) / 100.0f,
|
|
(100.0f + powDbPeak) / 100.0f,
|
|
nbMagsqSamples);
|
|
|
|
if (m_tickCount % 4 == 0) {
|
|
ui->channelPower->setText(tr("%1 dB").arg(powDbAvg, 0, 'f', 1));
|
|
}
|
|
|
|
m_tickCount++;
|
|
|
|
// Tick is called 20x a second - lets check this every 10 seconds
|
|
if (m_tickCount % (20*10) == 0)
|
|
{
|
|
// Remove aircraft that haven't been heard of for a user-defined time, as probably out of range
|
|
QDateTime now = QDateTime::currentDateTime();
|
|
qint64 nowSecs = now.toSecsSinceEpoch();
|
|
QHash<int, Aircraft *>::iterator i = m_aircraft.begin();
|
|
|
|
while (i != m_aircraft.end())
|
|
{
|
|
Aircraft *aircraft = i.value();
|
|
qint64 secondsSinceLastFrame = nowSecs - aircraft->m_time.toSecsSinceEpoch();
|
|
|
|
if (secondsSinceLastFrame >= m_settings.m_removeTimeout)
|
|
{
|
|
// Don't try to track it anymore
|
|
if (m_trackAircraft == aircraft)
|
|
{
|
|
m_adsbDemod->clearTarget();
|
|
m_trackAircraft = nullptr;
|
|
}
|
|
|
|
// Remove map model
|
|
m_aircraftModel.removeAircraft(aircraft);
|
|
// Remove row from table
|
|
ui->adsbData->removeRow(aircraft->m_icaoItem->row());
|
|
// Remove aircraft from hash
|
|
i = m_aircraft.erase(i);
|
|
// Remove from map feature
|
|
clearFromMap(QString("%1").arg(aircraft->m_icao, 0, 16));
|
|
|
|
// And finally free its memory
|
|
delete aircraft;
|
|
}
|
|
else
|
|
{
|
|
++i;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Create and send aircraft report every second for WebAPI
|
|
if (m_tickCount % (20*1) == 0) {
|
|
sendAircraftReport();
|
|
}
|
|
}
|
|
|
|
void ADSBDemodGUI::sendAircraftReport()
|
|
{
|
|
ADSBDemod::MsgAircraftReport* message = ADSBDemod::MsgAircraftReport::create();
|
|
|
|
QList<ADSBDemod::MsgAircraftReport::AircraftReport>& report = message->getReport();
|
|
report.reserve(m_aircraft.size());
|
|
|
|
QHash<int, Aircraft *>::iterator i = m_aircraft.begin();
|
|
while (i != m_aircraft.end())
|
|
{
|
|
Aircraft *aircraft = i.value();
|
|
|
|
ADSBDemod::MsgAircraftReport::AircraftReport aircraftReport {
|
|
aircraft->m_icaoHex,
|
|
aircraft->m_callsign,
|
|
aircraft->m_latitude,
|
|
aircraft->m_longitude,
|
|
aircraft->m_altitude,
|
|
aircraft->m_groundspeed
|
|
};
|
|
|
|
report.append(aircraftReport);
|
|
|
|
++i;
|
|
}
|
|
|
|
m_adsbDemod->getInputMessageQueue()->push(message);
|
|
}
|
|
|
|
void ADSBDemodGUI::resizeTable()
|
|
{
|
|
// Fill table with a row of dummy data that will size the columns nicely
|
|
int row = ui->adsbData->rowCount();
|
|
ui->adsbData->setRowCount(row + 1);
|
|
ui->adsbData->setItem(row, ADSB_COL_ICAO, new QTableWidgetItem("ICAO ID"));
|
|
ui->adsbData->setItem(row, ADSB_COL_CALLSIGN, new QTableWidgetItem("Callsign--"));
|
|
ui->adsbData->setItem(row, ADSB_COL_ATC_CALLSIGN, new QTableWidgetItem("ATC Callsign-"));
|
|
ui->adsbData->setItem(row, ADSB_COL_MODEL, new QTableWidgetItem("Aircraft12345"));
|
|
ui->adsbData->setItem(row, ADSB_COL_AIRLINE, new QTableWidgetItem("airbrigdecargo1"));
|
|
ui->adsbData->setItem(row, ADSB_COL_ALTITUDE, new QTableWidgetItem("Alt (ft)"));
|
|
ui->adsbData->setItem(row, ADSB_COL_HEADING, new QTableWidgetItem("Hd (o)"));
|
|
ui->adsbData->setItem(row, ADSB_COL_VERTICALRATE, new QTableWidgetItem("VR (ft/m)"));
|
|
ui->adsbData->setItem(row, ADSB_COL_RANGE, new QTableWidgetItem("D (km)"));
|
|
ui->adsbData->setItem(row, ADSB_COL_AZEL, new QTableWidgetItem("Az/El (o)"));
|
|
ui->adsbData->setItem(row, ADSB_COL_LATITUDE, new QTableWidgetItem("-90.00000"));
|
|
ui->adsbData->setItem(row, ADSB_COL_LONGITUDE, new QTableWidgetItem("-180.000000"));
|
|
ui->adsbData->setItem(row, ADSB_COL_CATEGORY, new QTableWidgetItem("Heavy"));
|
|
ui->adsbData->setItem(row, ADSB_COL_STATUS, new QTableWidgetItem("No emergency"));
|
|
ui->adsbData->setItem(row, ADSB_COL_SQUAWK, new QTableWidgetItem("Squawk"));
|
|
ui->adsbData->setItem(row, ADSB_COL_REGISTRATION, new QTableWidgetItem("G-12345"));
|
|
ui->adsbData->setItem(row, ADSB_COL_COUNTRY, new QTableWidgetItem("Country"));
|
|
ui->adsbData->setItem(row, ADSB_COL_REGISTERED, new QTableWidgetItem("Registered"));
|
|
ui->adsbData->setItem(row, ADSB_COL_MANUFACTURER, new QTableWidgetItem("The Boeing Company"));
|
|
ui->adsbData->setItem(row, ADSB_COL_OWNER, new QTableWidgetItem("British Airways"));
|
|
ui->adsbData->setItem(row, ADSB_COL_OPERATOR_ICAO, new QTableWidgetItem("Operator"));
|
|
ui->adsbData->setItem(row, ADSB_COL_TIME, new QTableWidgetItem("99:99:99"));
|
|
ui->adsbData->setItem(row, ADSB_COL_FRAMECOUNT, new QTableWidgetItem("Frames"));
|
|
ui->adsbData->setItem(row, ADSB_COL_CORRELATION, new QTableWidgetItem("0.001/0.001/0.001"));
|
|
ui->adsbData->setItem(row, ADSB_COL_RSSI, new QTableWidgetItem("-100.0"));
|
|
ui->adsbData->setItem(row, ADSB_COL_FLIGHT_STATUS, new QTableWidgetItem("scheduled"));
|
|
ui->adsbData->setItem(row, ADSB_COL_DEP, new QTableWidgetItem("WWWW"));
|
|
ui->adsbData->setItem(row, ADSB_COL_ARR, new QTableWidgetItem("WWWW"));
|
|
ui->adsbData->setItem(row, ADSB_COL_STD, new QTableWidgetItem("12:00 -1"));
|
|
ui->adsbData->setItem(row, ADSB_COL_ETD, new QTableWidgetItem("12:00 -1"));
|
|
ui->adsbData->setItem(row, ADSB_COL_ATD, new QTableWidgetItem("12:00 -1"));
|
|
ui->adsbData->setItem(row, ADSB_COL_STA, new QTableWidgetItem("12:00 +1"));
|
|
ui->adsbData->setItem(row, ADSB_COL_ETA, new QTableWidgetItem("12:00 +1"));
|
|
ui->adsbData->setItem(row, ADSB_COL_ATA, new QTableWidgetItem("12:00 +1"));
|
|
ui->adsbData->setItem(row, ADSB_COL_SEL_ALTITUDE, new QTableWidgetItem("Sel Alt (ft)"));
|
|
ui->adsbData->setItem(row, ADSB_COL_SEL_HEADING, new QTableWidgetItem("Sel Hd (o)"));
|
|
ui->adsbData->setItem(row, ADSB_COL_BARO, new QTableWidgetItem("Baro (mb)"));
|
|
ui->adsbData->setItem(row, ADSB_COL_AP, new QTableWidgetItem("AP"));
|
|
ui->adsbData->setItem(row, ADSB_COL_V_MODE, new QTableWidgetItem("V Mode"));
|
|
ui->adsbData->setItem(row, ADSB_COL_L_MODE, new QTableWidgetItem("L Mode"));
|
|
ui->adsbData->setItem(row, ADSB_COL_TRUE_AIRSPEED, new QTableWidgetItem("TAS (kn)"));
|
|
ui->adsbData->setItem(row, ADSB_COL_INDICATED_AIRSPEED, new QTableWidgetItem("IAS (kn)"));
|
|
ui->adsbData->setItem(row, ADSB_COL_MACH, new QTableWidgetItem("0.999"));
|
|
ui->adsbData->setItem(row, ADSB_COL_HEADWIND, new QTableWidgetItem("H Wnd (kn)"));
|
|
ui->adsbData->setItem(row, ADSB_COL_EST_AIR_TEMP, new QTableWidgetItem("OAT (C)"));
|
|
ui->adsbData->setItem(row, ADSB_COL_WIND_SPEED, new QTableWidgetItem("Wnd (kn)"));
|
|
ui->adsbData->setItem(row, ADSB_COL_WIND_DIR, new QTableWidgetItem("Wnd (o)"));
|
|
ui->adsbData->setItem(row, ADSB_COL_STATIC_PRESSURE, new QTableWidgetItem("P (hPa)"));
|
|
ui->adsbData->setItem(row, ADSB_COL_STATIC_AIR_TEMP, new QTableWidgetItem("T (C)"));
|
|
ui->adsbData->setItem(row, ADSB_COL_HUMIDITY, new QTableWidgetItem("U (%)"));
|
|
ui->adsbData->setItem(row, ADSB_COL_TIS_B, new QTableWidgetItem("TIS-B"));
|
|
ui->adsbData->resizeColumnsToContents();
|
|
ui->adsbData->setRowCount(row);
|
|
}
|
|
|
|
Aircraft* ADSBDemodGUI::findAircraftByFlight(const QString& flight)
|
|
{
|
|
QHash<int, Aircraft *>::iterator i = m_aircraft.begin();
|
|
while (i != m_aircraft.end())
|
|
{
|
|
Aircraft *aircraft = i.value();
|
|
if (aircraft->m_flight == flight) {
|
|
return aircraft;
|
|
}
|
|
++i;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
// Convert to hh:mm (+/-days)
|
|
QString ADSBDemodGUI::dataTimeToShortString(QDateTime dt)
|
|
{
|
|
if (dt.isValid())
|
|
{
|
|
QDate currentDate = QDateTime::currentDateTimeUtc().date();
|
|
if (dt.date() == currentDate)
|
|
{
|
|
return dt.time().toString("hh:mm");
|
|
}
|
|
else
|
|
{
|
|
int days = currentDate.daysTo(dt.date());
|
|
if (days >= 0) {
|
|
return QString("%1 +%2").arg(dt.time().toString("hh:mm")).arg(days);
|
|
} else {
|
|
return QString("%1 %2").arg(dt.time().toString("hh:mm")).arg(days);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return "";
|
|
}
|
|
}
|
|
|
|
void ADSBDemodGUI::initFlightInformation()
|
|
{
|
|
if (m_flightInformation)
|
|
{
|
|
disconnect(m_flightInformation, &FlightInformation::flightUpdated, this, &ADSBDemodGUI::flightInformationUpdated);
|
|
delete m_flightInformation;
|
|
m_flightInformation = nullptr;
|
|
}
|
|
if (!m_settings.m_aviationstackAPIKey.isEmpty())
|
|
{
|
|
m_flightInformation = FlightInformation::create(m_settings.m_aviationstackAPIKey);
|
|
if (m_flightInformation) {
|
|
connect(m_flightInformation, &FlightInformation::flightUpdated, this, &ADSBDemodGUI::flightInformationUpdated);
|
|
}
|
|
}
|
|
}
|
|
|
|
void ADSBDemodGUI::flightInformationUpdated(const FlightInformation::Flight& flight)
|
|
{
|
|
Aircraft* aircraft = findAircraftByFlight(flight.m_flightICAO);
|
|
if (aircraft)
|
|
{
|
|
aircraft->m_flightStatusItem->setText(flight.m_flightStatus);
|
|
aircraft->m_depItem->setText(flight.m_departureICAO);
|
|
aircraft->m_arrItem->setText(flight.m_arrivalICAO);
|
|
aircraft->m_stdItem->setText(dataTimeToShortString(flight.m_departureScheduled));
|
|
aircraft->m_etdItem->setText(dataTimeToShortString(flight.m_departureEstimated));
|
|
aircraft->m_atdItem->setText(dataTimeToShortString(flight.m_departureActual));
|
|
aircraft->m_staItem->setText(dataTimeToShortString(flight.m_arrivalScheduled));
|
|
aircraft->m_etaItem->setText(dataTimeToShortString(flight.m_arrivalEstimated));
|
|
aircraft->m_ataItem->setText(dataTimeToShortString(flight.m_arrivalActual));
|
|
if (aircraft->m_positionValid) {
|
|
m_aircraftModel.aircraftUpdated(aircraft);
|
|
}
|
|
updatePhotoFlightInformation(aircraft);
|
|
}
|
|
else
|
|
{
|
|
qDebug() << "ADSBDemodGUI::flightInformationUpdated - Flight not found in ADS-B table: " << flight.m_flightICAO;
|
|
}
|
|
}
|
|
|
|
void ADSBDemodGUI::aircraftPhoto(const PlaneSpottersPhoto *photo)
|
|
{
|
|
// Make sure the photo is for the currently highlighted aircraft, as it may
|
|
// have taken a while to download
|
|
if (!photo->m_pixmap.isNull() && m_highlightAircraft && (m_highlightAircraft->m_icaoItem->text() == photo->m_id))
|
|
{
|
|
ui->photo->setPixmap(photo->m_pixmap);
|
|
ui->photo->setToolTip(QString("Photographer: %1").arg(photo->m_photographer)); // Required by terms of use
|
|
ui->photoHeader->setVisible(true);
|
|
ui->photoFlag->setVisible(true);
|
|
ui->photo->setVisible(true);
|
|
ui->flightDetails->setVisible(true);
|
|
ui->aircraftDetails->setVisible(true);
|
|
m_photoLink = photo->m_link;
|
|
}
|
|
}
|
|
|
|
void ADSBDemodGUI::photoClicked()
|
|
{
|
|
// Photo needs to link back to PlaneSpotters, as per terms of use
|
|
if (m_highlightAircraft)
|
|
{
|
|
if (m_photoLink.isEmpty())
|
|
{
|
|
QString icaoUpper = QString("%1").arg(m_highlightAircraft->m_icao, 1, 16).toUpper();
|
|
QDesktopServices::openUrl(QUrl(QString("https://www.planespotters.net/hex/%1").arg(icaoUpper)));
|
|
}
|
|
else
|
|
{
|
|
QDesktopServices::openUrl(QUrl(m_photoLink));
|
|
}
|
|
}
|
|
}
|
|
|
|
void ADSBDemodGUI::on_logEnable_clicked(bool checked)
|
|
{
|
|
m_settings.m_logEnabled = checked;
|
|
applySettings();
|
|
}
|
|
|
|
void ADSBDemodGUI::on_logFilename_clicked()
|
|
{
|
|
// Get filename to save to
|
|
QFileDialog fileDialog(nullptr, "Select file to log received frames to", "", "*.csv");
|
|
fileDialog.setAcceptMode(QFileDialog::AcceptSave);
|
|
if (fileDialog.exec())
|
|
{
|
|
QStringList fileNames = fileDialog.selectedFiles();
|
|
if (fileNames.size() > 0)
|
|
{
|
|
m_settings.m_logFilename = fileNames[0];
|
|
ui->logFilename->setToolTip(QString(".csv log filename: %1").arg(m_settings.m_logFilename));
|
|
applySettings();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Read .csv log and process as received frames
|
|
void ADSBDemodGUI::on_logOpen_clicked()
|
|
{
|
|
QFileDialog fileDialog(nullptr, "Select .csv log file to read", "", "*.csv");
|
|
if (fileDialog.exec())
|
|
{
|
|
QStringList fileNames = fileDialog.selectedFiles();
|
|
if (fileNames.size() > 0)
|
|
{
|
|
QFile file(fileNames[0]);
|
|
if (file.open(QIODevice::ReadOnly | QIODevice::Text))
|
|
{
|
|
QDateTime startTime = QDateTime::currentDateTime();
|
|
m_loadingData = true;
|
|
ui->adsbData->blockSignals(true);
|
|
QTextStream in(&file);
|
|
QString error;
|
|
QHash<QString, int> colIndexes = CSV::readHeader(in, {"Data", "Correlation"}, error);
|
|
if (error.isEmpty())
|
|
{
|
|
int dataCol = colIndexes.value("Data");
|
|
int correlationCol = colIndexes.value("Correlation");
|
|
int maxCol = std::max(dataCol, correlationCol);
|
|
|
|
QMessageBox dialog(this);
|
|
dialog.setText("Reading ADS-B data");
|
|
dialog.addButton(QMessageBox::Cancel);
|
|
dialog.show();
|
|
QApplication::processEvents();
|
|
int count = 0;
|
|
int countOtherDF = 0;
|
|
bool cancelled = false;
|
|
QStringList cols;
|
|
crcadsb crc;
|
|
while (!cancelled && CSV::readRow(in, &cols))
|
|
{
|
|
if (cols.size() > maxCol)
|
|
{
|
|
QDateTime dateTime = QDateTime::currentDateTime(); // So they aren't removed immediately as too old
|
|
QByteArray bytes = QByteArray::fromHex(cols[dataCol].toLatin1());
|
|
float correlation = cols[correlationCol].toFloat();
|
|
int df = (bytes[0] >> 3) & ADS_B_DF_MASK; // Downlink format
|
|
if ((df == 4) || (df == 5) || (df == 17) || (df == 18) || (df == 20) || (df == 21))
|
|
{
|
|
int crcCalc = 0;
|
|
if ((df == 4) || (df == 5) || (df == 20) || (df == 21)) // handleADSB requires calculated CRC for Mode-S frames
|
|
{
|
|
crc.init();
|
|
crc.calculate((const uint8_t *)bytes.data(), bytes.size()-3);
|
|
crcCalc = crc.get();
|
|
}
|
|
//qDebug() << "bytes.szie " << bytes.size() << " crc " << Qt::hex << crcCalc;
|
|
handleADSB(bytes, dateTime, correlation, correlation, crcCalc, false);
|
|
if ((count > 0) && (count % 100000 == 0))
|
|
{
|
|
dialog.setText(QString("Reading ADS-B data\n%1 (Skipped %2)").arg(count).arg(countOtherDF));
|
|
QApplication::processEvents();
|
|
if (dialog.clickedButton()) {
|
|
cancelled = true;
|
|
}
|
|
}
|
|
count++;
|
|
}
|
|
else
|
|
{
|
|
countOtherDF++;
|
|
}
|
|
}
|
|
}
|
|
m_aircraftModel.allAircraftUpdated();
|
|
dialog.close();
|
|
}
|
|
else
|
|
{
|
|
QMessageBox::critical(this, "ADS-B", error);
|
|
}
|
|
ui->adsbData->blockSignals(false);
|
|
m_loadingData = false;
|
|
if (m_settings.m_autoResizeTableColumns)
|
|
ui->adsbData->resizeColumnsToContents();
|
|
ui->adsbData->setSortingEnabled(true);
|
|
QDateTime finishTime = QDateTime::currentDateTime();
|
|
qDebug() << "Read CSV in " << startTime.secsTo(finishTime);
|
|
}
|
|
else
|
|
{
|
|
QMessageBox::critical(this, "ADS-B", QString("Failed to open file %1").arg(fileNames[0]));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void ADSBDemodGUI::downloadingURL(const QString& url)
|
|
{
|
|
if (m_progressDialog)
|
|
{
|
|
m_progressDialog->setLabelText(QString("Downloading %1.").arg(url));
|
|
m_progressDialog->setValue(m_progressDialog->value() + 1);
|
|
}
|
|
}
|
|
|
|
void ADSBDemodGUI::downloadProgress(qint64 bytesRead, qint64 totalBytes)
|
|
{
|
|
if (m_progressDialog)
|
|
{
|
|
m_progressDialog->setMaximum(totalBytes);
|
|
m_progressDialog->setValue(bytesRead);
|
|
}
|
|
}
|
|
|
|
void ADSBDemodGUI::downloadError(const QString& error)
|
|
{
|
|
QMessageBox::critical(this, "ADS-B", error);
|
|
if (m_progressDialog)
|
|
{
|
|
m_progressDialog->close();
|
|
delete m_progressDialog;
|
|
m_progressDialog = nullptr;
|
|
}
|
|
}
|
|
|
|
void ADSBDemodGUI::downloadAirspaceFinished()
|
|
{
|
|
if (m_progressDialog) {
|
|
m_progressDialog->setLabelText("Reading airspaces.");
|
|
}
|
|
m_airspaces = OpenAIP::getAirspaces();
|
|
updateAirspaces();
|
|
m_openAIP.downloadNavAids();
|
|
}
|
|
|
|
void ADSBDemodGUI::downloadNavAidsFinished()
|
|
{
|
|
if (m_progressDialog) {
|
|
m_progressDialog->setLabelText("Reading NAVAIDs.");
|
|
}
|
|
m_navAids = OpenAIP::getNavAids();
|
|
updateNavAids();
|
|
if (m_progressDialog)
|
|
{
|
|
m_progressDialog->close();
|
|
delete m_progressDialog;
|
|
m_progressDialog = nullptr;
|
|
}
|
|
}
|
|
|
|
void ADSBDemodGUI::downloadAircraftInformationFinished()
|
|
{
|
|
if (m_progressDialog)
|
|
{
|
|
delete m_progressDialog;
|
|
m_progressDialog = new QProgressDialog("Reading Aircraft Information.", "", 0, 1, this);
|
|
m_progressDialog->setCancelButton(nullptr);
|
|
m_progressDialog->setWindowFlag(Qt::WindowCloseButtonHint, false);
|
|
m_progressDialog->setWindowModality(Qt::WindowModal);
|
|
m_progressDialog->show();
|
|
QApplication::processEvents();
|
|
}
|
|
m_aircraftInfo = OsnDB::getAircraftInformation();
|
|
m_aircraftModel.updateAircraftInformation(m_aircraftInfo);
|
|
if (m_progressDialog)
|
|
{
|
|
m_progressDialog->close();
|
|
delete m_progressDialog;
|
|
m_progressDialog = nullptr;
|
|
}
|
|
}
|
|
|
|
void ADSBDemodGUI::downloadAirportInformationFinished()
|
|
{
|
|
if (m_progressDialog)
|
|
{
|
|
delete m_progressDialog;
|
|
m_progressDialog = new QProgressDialog("Reading Airport Information.", "", 0, 1, this);
|
|
m_progressDialog->setCancelButton(nullptr);
|
|
m_progressDialog->setWindowFlag(Qt::WindowCloseButtonHint, false);
|
|
m_progressDialog->setWindowModality(Qt::WindowModal);
|
|
m_progressDialog->show();
|
|
QApplication::processEvents();
|
|
}
|
|
m_airportInfo = OurAirportsDB::getAirportsById();
|
|
updateAirports();
|
|
if (m_progressDialog)
|
|
{
|
|
m_progressDialog->close();
|
|
delete m_progressDialog;
|
|
m_progressDialog = nullptr;
|
|
}
|
|
}
|
|
|
|
int ADSBDemodGUI::squawkDecode(int modeA) const
|
|
{
|
|
int a, b, c, d;
|
|
c = ((modeA >> 12) & 1) | ((modeA >> (10-1)) & 0x2) | ((modeA >> (8-2)) & 0x4);
|
|
a = ((modeA >> 11) & 1) | ((modeA >> (9-1)) & 0x2) | ((modeA >> (7-2)) & 0x4);
|
|
b = ((modeA >> 5) & 1) | ((modeA >> (3-1)) & 0x2) | ((modeA << (1)) & 0x4);
|
|
d = ((modeA >> 4) & 1) | ((modeA >> (2-1)) & 0x2) | ((modeA << (2)) & 0x4);
|
|
return a*1000 + b*100 + c*10 + d;
|
|
}
|
|
|
|
// https://en.wikipedia.org/wiki/Gillham_code
|
|
int ADSBDemodGUI::gillhamToFeet(int n) const
|
|
{
|
|
int c1 = (n >> 10) & 1;
|
|
int a1 = (n >> 9) & 1;
|
|
int c2 = (n >> 8) & 1;
|
|
int a2 = (n >> 7) & 1;
|
|
int c4 = (n >> 6) & 1;
|
|
int a4 = (n >> 5) & 1;
|
|
int b1 = (n >> 4) & 1;
|
|
int b2 = (n >> 3) & 1;
|
|
int d2 = (n >> 2) & 1;
|
|
int b4 = (n >> 1) & 1;
|
|
int d4 = n & 1;
|
|
|
|
int n500 = grayToBinary((d2 << 7) | (d4 << 6) | (a1 << 5) | (a2 << 4) | (a4 << 3) | (b1 << 2) | (b2 << 1) | b4, 4);
|
|
int n100 = grayToBinary((c1 << 2) | (c2 << 1) | c4, 3) - 1;
|
|
|
|
if (n100 == 6) {
|
|
n100 = 4;
|
|
}
|
|
if (n500 %2 != 0) {
|
|
n100 = 4 - n100;
|
|
}
|
|
|
|
return -1200 + n500*500 + n100*100;
|
|
}
|
|
|
|
int ADSBDemodGUI::grayToBinary(int gray, int bits) const
|
|
{
|
|
int binary = 0;
|
|
for (int i = bits - 1; i >= 0; i--) {
|
|
binary = binary | ((((1 << (i+1)) & binary) >> 1) ^ ((1 << i) & gray));
|
|
}
|
|
return binary;
|
|
}
|
|
|
|
void ADSBDemodGUI::redrawMap()
|
|
{
|
|
// An awful workaround for https://bugreports.qt.io/browse/QTBUG-100333
|
|
// Also used in Map feature
|
|
QQuickItem *item = ui->map->rootObject();
|
|
if (item)
|
|
{
|
|
QObject *object = item->findChild<QObject*>("map");
|
|
if (object)
|
|
{
|
|
double zoom = object->property("zoomLevel").value<double>();
|
|
object->setProperty("zoomLevel", QVariant::fromValue(zoom+1));
|
|
object->setProperty("zoomLevel", QVariant::fromValue(zoom));
|
|
}
|
|
}
|
|
}
|
|
|
|
void ADSBDemodGUI::showEvent(QShowEvent *event)
|
|
{
|
|
if (!event->spontaneous())
|
|
{
|
|
// Workaround for https://bugreports.qt.io/browse/QTBUG-100333
|
|
// MapQuickItems can be in wrong position when window is first displayed
|
|
m_redrawMapTimer.start(500);
|
|
}
|
|
ChannelGUI::showEvent(event);
|
|
}
|
|
|
|
bool ADSBDemodGUI::eventFilter(QObject *obj, QEvent *event)
|
|
{
|
|
if (obj == ui->map)
|
|
{
|
|
if (event->type() == QEvent::Resize)
|
|
{
|
|
// Workaround for https://bugreports.qt.io/browse/QTBUG-100333
|
|
// MapQuickItems can be in wrong position after vertical resize
|
|
QResizeEvent *resizeEvent = static_cast<QResizeEvent *>(event);
|
|
QSize oldSize = resizeEvent->oldSize();
|
|
QSize size = resizeEvent->size();
|
|
if (oldSize.height() != size.height()) {
|
|
redrawMap();
|
|
}
|
|
}
|
|
}
|
|
return ChannelGUI::eventFilter(obj, event);
|
|
}
|
|
|
|
void ADSBDemodGUI::applyImportSettings()
|
|
{
|
|
m_importTimer.setInterval(m_settings.m_importPeriod * 1000);
|
|
if (m_settings.m_feedEnabled && m_settings.m_importEnabled) {
|
|
m_importTimer.start();
|
|
} else {
|
|
m_importTimer.stop();
|
|
}
|
|
}
|
|
|
|
// Import ADS-B data from opensky-network via an API call
|
|
void ADSBDemodGUI::import()
|
|
{
|
|
QString urlString = "https://";
|
|
if (!m_settings.m_importUsername.isEmpty() && !m_settings.m_importPassword.isEmpty()) {
|
|
urlString = urlString + m_settings.m_importUsername + ":" + m_settings.m_importPassword + "@";
|
|
}
|
|
urlString = urlString + m_settings.m_importHost + "/api/states/all";
|
|
QChar join = '?';
|
|
if (!m_settings.m_importParameters.isEmpty())
|
|
{
|
|
urlString = urlString + join + m_settings.m_importParameters;
|
|
join = '&';
|
|
}
|
|
if (!m_settings.m_importMinLatitude.isEmpty())
|
|
{
|
|
urlString = urlString + join + "lamin=" + m_settings.m_importMinLatitude;
|
|
join = '&';
|
|
}
|
|
if (!m_settings.m_importMaxLatitude.isEmpty())
|
|
{
|
|
urlString = urlString + join + "lamax=" + m_settings.m_importMaxLatitude;
|
|
join = '&';
|
|
}
|
|
if (!m_settings.m_importMinLongitude.isEmpty())
|
|
{
|
|
urlString = urlString + join + "lomin=" + m_settings.m_importMinLongitude;
|
|
join = '&';
|
|
}
|
|
if (!m_settings.m_importMaxLongitude.isEmpty())
|
|
{
|
|
urlString = urlString + join + "lomax=" + m_settings.m_importMaxLongitude;
|
|
join = '&';
|
|
}
|
|
m_networkManager->get(QNetworkRequest(QUrl(urlString)));
|
|
}
|
|
|
|
// Handle opensky-network API call reply
|
|
void ADSBDemodGUI::handleImportReply(QNetworkReply* reply)
|
|
{
|
|
if (reply)
|
|
{
|
|
if (!reply->error())
|
|
{
|
|
QJsonDocument document = QJsonDocument::fromJson(reply->readAll());
|
|
if (document.isObject())
|
|
{
|
|
QJsonObject obj = document.object();
|
|
if (obj.contains("time") && obj.contains("states"))
|
|
{
|
|
int seconds = obj.value("time").toInt();
|
|
QDateTime dateTime = QDateTime::fromSecsSinceEpoch(seconds);
|
|
QJsonArray states = obj.value("states").toArray();
|
|
for (int i = 0; i < states.size(); i++)
|
|
{
|
|
QJsonArray state = states[i].toArray();
|
|
int icao = state[0].toString().toInt(nullptr, 16);
|
|
|
|
bool newAircraft;
|
|
Aircraft *aircraft = getAircraft(icao, newAircraft);
|
|
|
|
QString callsign = state[1].toString().trimmed();
|
|
if (!callsign.isEmpty())
|
|
{
|
|
aircraft->m_callsign = callsign;
|
|
aircraft->m_callsignItem->setText(aircraft->m_callsign);
|
|
atcCallsign(aircraft);
|
|
}
|
|
|
|
QDateTime timePosition = dateTime;
|
|
if (state[3].isNull()) {
|
|
timePosition = dateTime.addSecs(-15); // At least 15 seconds old
|
|
} else {
|
|
timePosition = QDateTime::fromSecsSinceEpoch(state[3].toInt());
|
|
}
|
|
aircraft->m_time = QDateTime::fromSecsSinceEpoch(state[4].toInt());
|
|
QTime time = aircraft->m_time.time();
|
|
aircraft->m_timeItem->setText(QString("%1:%2:%3").arg(time.hour(), 2, 10, QLatin1Char('0')).arg(time.minute(), 2, 10, QLatin1Char('0')).arg(time.second(), 2, 10, QLatin1Char('0')));
|
|
aircraft->m_adsbFrameCount++;
|
|
aircraft->m_adsbFrameCountItem->setData(Qt::DisplayRole, aircraft->m_adsbFrameCount);
|
|
|
|
if (timePosition > aircraft->m_positionDateTime)
|
|
{
|
|
if (!state[5].isNull() && !state[6].isNull())
|
|
{
|
|
aircraft->m_longitude = state[5].toDouble();
|
|
aircraft->m_latitude = state[6].toDouble();
|
|
aircraft->m_longitudeItem->setData(Qt::DisplayRole, aircraft->m_longitude);
|
|
aircraft->m_latitudeItem->setData(Qt::DisplayRole, aircraft->m_latitude);
|
|
updatePosition(aircraft);
|
|
aircraft->m_cprValid[0] = false;
|
|
aircraft->m_cprValid[1] = false;
|
|
}
|
|
if (!state[7].isNull())
|
|
{
|
|
aircraft->m_altitude = (int)Units::metresToFeet(state[7].toDouble());
|
|
aircraft->m_altitudeValid = true;
|
|
aircraft->m_altitudeGNSS = false;
|
|
aircraft->m_altitudeItem->setData(Qt::DisplayRole, aircraft->m_altitude);
|
|
}
|
|
if (!state[5].isNull() && !state[6].isNull() && !state[7].isNull())
|
|
{
|
|
QGeoCoordinate coord(aircraft->m_latitude, aircraft->m_longitude, aircraft->m_altitude);
|
|
aircraft->m_coordinates.push_back(QVariant::fromValue(coord));
|
|
aircraft->m_coordinateDateTimes.push_back(dateTime);
|
|
}
|
|
aircraft->m_positionDateTime = timePosition;
|
|
}
|
|
aircraft->m_onSurface = state[8].toBool(false);
|
|
if (!state[9].isNull())
|
|
{
|
|
aircraft->m_groundspeed = (int)state[9].toDouble();
|
|
aircraft->m_groundspeedItem->setData(Qt::DisplayRole, aircraft->m_groundspeed);
|
|
aircraft->m_groundspeedValid = true;
|
|
}
|
|
if (!state[10].isNull())
|
|
{
|
|
aircraft->m_heading = (float)state[10].toDouble();
|
|
aircraft->m_headingItem->setData(Qt::DisplayRole, std::round(aircraft->m_heading));
|
|
aircraft->m_headingValid = true;
|
|
aircraft->m_headingDateTime = aircraft->m_time;
|
|
}
|
|
if (!state[11].isNull())
|
|
{
|
|
aircraft->m_verticalRate = (int)state[10].toDouble();
|
|
aircraft->m_verticalRateItem->setData(Qt::DisplayRole, aircraft->m_verticalRate);
|
|
aircraft->m_verticalRateValid = true;
|
|
}
|
|
if (!state[14].isNull())
|
|
{
|
|
aircraft->m_squawk = state[14].toString().toInt();
|
|
aircraft->m_squawkItem->setText(QString("%1").arg(aircraft->m_squawk, 4, 10, QLatin1Char('0')));
|
|
}
|
|
|
|
// Update aircraft in map
|
|
if (aircraft->m_positionValid)
|
|
{
|
|
// Check to see if we need to start any animations
|
|
QList<SWGSDRangel::SWGMapAnimation *> *animations = animate(dateTime, aircraft);
|
|
|
|
// Update map displayed in channel
|
|
m_aircraftModel.aircraftUpdated(aircraft);
|
|
|
|
// Send to Map feature
|
|
sendToMap(aircraft, animations);
|
|
}
|
|
|
|
// Check to see if we need to emit a notification about this aircraft
|
|
checkDynamicNotification(aircraft);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
qDebug() << "ADSBDemodGUI::handleImportReply: Document object does not contain time and states: " << document;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
qDebug() << "ADSBDemodGUI::handleImportReply: Document is not an object: " << document;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
qDebug() << "ADSBDemodGUI::handleImportReply: error " << reply->error();
|
|
}
|
|
reply->deleteLater();
|
|
}
|
|
}
|
|
|
|
void ADSBDemodGUI::preferenceChanged(int elementType)
|
|
{
|
|
Preferences::ElementType pref = (Preferences::ElementType)elementType;
|
|
if ((pref == Preferences::Latitude) || (pref == Preferences::Longitude) || (pref == Preferences::Altitude))
|
|
{
|
|
Real stationLatitude = MainCore::instance()->getSettings().getLatitude();
|
|
Real stationLongitude = MainCore::instance()->getSettings().getLongitude();
|
|
Real stationAltitude = MainCore::instance()->getSettings().getAltitude();
|
|
|
|
QGeoCoordinate stationPosition(stationLatitude, stationLongitude, stationAltitude);
|
|
QGeoCoordinate previousPosition(m_azEl.getLocationSpherical().m_latitude, m_azEl.getLocationSpherical().m_longitude, m_azEl.getLocationSpherical().m_altitude);
|
|
|
|
if (stationPosition != previousPosition)
|
|
{
|
|
m_azEl.setLocation(stationLatitude, stationLongitude, stationAltitude);
|
|
|
|
// Update distances and what is visible, but only do it if position has changed significantly
|
|
if (!m_lastFullUpdatePosition.isValid() || (stationPosition.distanceTo(m_lastFullUpdatePosition) >= 1000))
|
|
{
|
|
updateAirports();
|
|
updateAirspaces();
|
|
updateNavAids();
|
|
m_lastFullUpdatePosition = stationPosition;
|
|
}
|
|
|
|
// Update icon position on Map
|
|
QQuickItem *item = ui->map->rootObject();
|
|
QObject *map = item->findChild<QObject*>("map");
|
|
if (map != nullptr)
|
|
{
|
|
QObject *stationObject = map->findChild<QObject*>("station");
|
|
if(stationObject != NULL)
|
|
{
|
|
QGeoCoordinate coords = stationObject->property("coordinate").value<QGeoCoordinate>();
|
|
coords.setLatitude(stationLatitude);
|
|
coords.setLongitude(stationLongitude);
|
|
coords.setAltitude(stationAltitude);
|
|
stationObject->setProperty("coordinate", QVariant::fromValue(coords));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (pref == Preferences::StationName)
|
|
{
|
|
// Update icon label on Map
|
|
QQuickItem *item = ui->map->rootObject();
|
|
QObject *map = item->findChild<QObject*>("map");
|
|
if (map != nullptr)
|
|
{
|
|
QObject *stationObject = map->findChild<QObject*>("station");
|
|
if(stationObject != NULL) {
|
|
stationObject->setProperty("stationName", QVariant::fromValue(MainCore::instance()->getSettings().getStationName()));
|
|
}
|
|
}
|
|
}
|
|
else if (pref == Preferences::MapSmoothing)
|
|
{
|
|
QQuickItem *item = ui->map->rootObject();
|
|
QQmlProperty::write(item, "smoothing", MainCore::instance()->getSettings().getMapSmoothing());
|
|
}
|
|
}
|
|
|
|
void ADSBDemodGUI::initAviationWeather()
|
|
{
|
|
if (m_aviationWeather)
|
|
{
|
|
disconnect(m_aviationWeather, &AviationWeather::weatherUpdated, this, &ADSBDemodGUI::weatherUpdated);
|
|
delete m_aviationWeather;
|
|
m_aviationWeather = nullptr;
|
|
}
|
|
if (!m_settings.m_checkWXAPIKey.isEmpty())
|
|
{
|
|
m_aviationWeather = AviationWeather::create(m_settings.m_checkWXAPIKey);
|
|
if (m_aviationWeather) {
|
|
connect(m_aviationWeather, &AviationWeather::weatherUpdated, this, &ADSBDemodGUI::weatherUpdated);
|
|
}
|
|
}
|
|
}
|
|
|
|
void ADSBDemodGUI::requestMetar(const QString& icao)
|
|
{
|
|
if (m_aviationWeather) {
|
|
m_aviationWeather->getWeather(icao);
|
|
}
|
|
}
|
|
|
|
void ADSBDemodGUI::weatherUpdated(const AviationWeather::METAR &metar)
|
|
{
|
|
m_airportModel.updateWeather(metar.m_icao, metar.m_text, metar.decoded());
|
|
}
|
|
|
|
void ADSBDemodGUI::makeUIConnections()
|
|
{
|
|
QObject::connect(ui->deltaFrequency, &ValueDialZ::changed, this, &ADSBDemodGUI::on_deltaFrequency_changed);
|
|
QObject::connect(ui->rfBW, &QSlider::valueChanged, this, &ADSBDemodGUI::on_rfBW_valueChanged);
|
|
QObject::connect(ui->threshold, &QDial::valueChanged, this, &ADSBDemodGUI::on_threshold_valueChanged);
|
|
QObject::connect(ui->phaseSteps, &QDial::valueChanged, this, &ADSBDemodGUI::on_phaseSteps_valueChanged);
|
|
QObject::connect(ui->tapsPerPhase, &QDial::valueChanged, this, &ADSBDemodGUI::on_tapsPerPhase_valueChanged);
|
|
QObject::connect(ui->adsbData, &QTableWidget::cellClicked, this, &ADSBDemodGUI::on_adsbData_cellClicked);
|
|
QObject::connect(ui->adsbData, &QTableWidget::cellDoubleClicked, this, &ADSBDemodGUI::on_adsbData_cellDoubleClicked);
|
|
QObject::connect(ui->spb, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &ADSBDemodGUI::on_spb_currentIndexChanged);
|
|
QObject::connect(ui->correlateFullPreamble, &ButtonSwitch::clicked, this, &ADSBDemodGUI::on_correlateFullPreamble_clicked);
|
|
QObject::connect(ui->demodModeS, &ButtonSwitch::clicked, this, &ADSBDemodGUI::on_demodModeS_clicked);
|
|
QObject::connect(ui->feed, &ButtonSwitch::clicked, this, &ADSBDemodGUI::on_feed_clicked);
|
|
QObject::connect(ui->notifications, &QToolButton::clicked, this, &ADSBDemodGUI::on_notifications_clicked);
|
|
QObject::connect(ui->flightInfo, &QToolButton::clicked, this, &ADSBDemodGUI::on_flightInfo_clicked);
|
|
QObject::connect(ui->findOnMapFeature, &QToolButton::clicked, this, &ADSBDemodGUI::on_findOnMapFeature_clicked);
|
|
QObject::connect(ui->getOSNDB, &QToolButton::clicked, this, &ADSBDemodGUI::on_getOSNDB_clicked);
|
|
QObject::connect(ui->getAirportDB, &QToolButton::clicked, this, &ADSBDemodGUI::on_getAirportDB_clicked);
|
|
QObject::connect(ui->getAirspacesDB, &QToolButton::clicked, this, &ADSBDemodGUI::on_getAirspacesDB_clicked);
|
|
QObject::connect(ui->flightPaths, &ButtonSwitch::clicked, this, &ADSBDemodGUI::on_flightPaths_clicked);
|
|
QObject::connect(ui->allFlightPaths, &ButtonSwitch::clicked, this, &ADSBDemodGUI::on_allFlightPaths_clicked);
|
|
QObject::connect(ui->atcLabels, &ButtonSwitch::clicked, this, &ADSBDemodGUI::on_atcLabels_clicked);
|
|
QObject::connect(ui->amDemod, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &ADSBDemodGUI::on_amDemod_currentIndexChanged);
|
|
QObject::connect(ui->displaySettings, &QToolButton::clicked, this, &ADSBDemodGUI::on_displaySettings_clicked);
|
|
QObject::connect(ui->logEnable, &ButtonSwitch::clicked, this, &ADSBDemodGUI::on_logEnable_clicked);
|
|
QObject::connect(ui->logFilename, &QToolButton::clicked, this, &ADSBDemodGUI::on_logFilename_clicked);
|
|
QObject::connect(ui->logOpen, &QToolButton::clicked, this, &ADSBDemodGUI::on_logOpen_clicked);
|
|
}
|
|
|
|
void ADSBDemodGUI::updateAbsoluteCenterFrequency()
|
|
{
|
|
setStatusFrequency(m_deviceCenterFrequency + m_settings.m_inputFrequencyOffset);
|
|
}
|
|
|