You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6111 lines
256 KiB
6111 lines
256 KiB
/////////////////////////////////////////////////////////////////////////////////// |
|
// 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 <QGeoServiceProvider> |
|
|
|
#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/db.h" |
|
#include "util/units.h" |
|
#include "util/morse.h" |
|
#include "gui/basicchannelsettingsdialog.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 "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; |
|
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 |
|
{ |
|
return MainCore::instance()->getChannelIds("sdrangel.channel.freqscanner"); |
|
} |
|
|
|
// 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]; |
|
unsigned int deviceSet, channelIndex; |
|
|
|
if (MainCore::getDeviceAndChannelIndexFromId(id, deviceSet, channelIndex)) |
|
{ |
|
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) |
|
{ |
|
unsigned int deviceSet, channelIndex; |
|
|
|
if (MainCore::getDeviceAndChannelIndexFromId(m_settings.m_amDemod, deviceSet, channelIndex)) |
|
{ |
|
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 character 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 airborne |
|
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))) |
|
{ |
|
// Airborne 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 airborne within 180nm/333km (C.2.6.4) or 45nm for surface |
|
|
|
// Calculate 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]); |
|
|
|
// Calculate 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) |
|
{ |
|
// Airborne 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 resetting |
|
// 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 airborne |
|
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 possibilities |
|
// 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; // Degrees |
|
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 airborne 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 highlighted 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 == 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 setting, 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); |
|
new DialogPositioner(&dialog, false); |
|
|
|
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; |
|
} |
|
|
|
// Check requested map provider is available - if not, try the other |
|
QString mapProvider = m_settings.m_mapProvider; |
|
QStringList mapProviders = QGeoServiceProvider::availableServiceProviders(); |
|
if ((mapProvider == "osm") && (!mapProviders.contains(mapProvider))) { |
|
mapProvider = "mapboxgl"; |
|
} |
|
if ((mapProvider == "mapboxgl") && (!mapProviders.contains(mapProvider))) { |
|
mapProvider = "osm"; |
|
} |
|
|
|
// 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", mapProvider); |
|
QVariantMap parameters; |
|
QString mapType; |
|
|
|
if (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 (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) |
|
{ |
|
// 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"; |
|
} |
|
|
|
#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)) |
|
newMap = newMap->findChild<QObject*>("map"); |
|
#endif |
|
if (coords.isValid()) |
|
{ |
|
newMap->setProperty("zoomLevel", QVariant::fromValue(zoom)); |
|
newMap->setProperty("center", QVariant::fromValue(coords)); |
|
} |
|
} |
|
else |
|
{ |
|
qDebug() << "ADSBDemodGUI::applyMapSettings - createMap returned a nullptr"; |
|
} |
|
} |
|
|
|
// 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); |
|
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0)) |
|
ui->map->setSource(QUrl(QStringLiteral("qrc:/map/map.qml"))); |
|
#else |
|
ui->map->setSource(QUrl(QStringLiteral("qrc:/map/map_6.qml"))); |
|
#endif |
|
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 == (float)49.012423) && (stationLongitude == (float)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); |
|
m_resizer.enableChildMouseTracking(); |
|
} |
|
|
|
ADSBDemodGUI::~ADSBDemodGUI() |
|
{ |
|
disconnect(&MainCore::instance()->getSettings(), &MainSettings::preferenceChanged, this, &ADSBDemodGUI::preferenceChanged); |
|
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.size " << 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(); |
|
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0)) |
|
QObject *map = item->findChild<QObject*>("map"); |
|
#else |
|
QObject *map = item->findChild<QObject*>("mapView"); |
|
#endif |
|
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(); |
|
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0)) |
|
QObject *map = item->findChild<QObject*>("map"); |
|
#else |
|
QObject *map = item->findChild<QObject*>("mapView"); |
|
#endif |
|
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); |
|
} |
|
|
|
|