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.
 
 
 
 
 
 

1133 lines
43 KiB

///////////////////////////////////////////////////////////////////////////////////
// Copyright (C) 2026 Jon Beniston, M7RCE <jon@beniston.com> //
// Some code by AI //
// //
// 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 "droneiddemod.h"
#include <algorithm>
#include <limits>
#include <QDebug>
#include <QNetworkAccessManager>
#include <QNetworkReply>
#include <QBuffer>
#include <QThread>
#include "SWGChannelSettings.h"
#include "SWGChannelReport.h"
#include "SWGWorkspaceInfo.h"
#include "SWGMapItem.h"
#include "SWGMapAnimation.h"
#include "dsp/dspcommands.h"
#include "util/db.h"
#include "util/droneid.h"
#include "settings/serializable.h"
#include "device/deviceapi.h"
#include "channel/channelwebapiutils.h"
#include "maincore.h"
MESSAGE_CLASS_DEFINITION(DroneIDDemod::MsgConfigureDroneIDDemod, Message)
MESSAGE_CLASS_DEFINITION(DroneIDDemod::MsgBurstResult, Message)
const char * const DroneIDDemod::m_channelIdURI = "sdrangel.channel.droneiddemod";
const char * const DroneIDDemod::m_channelId = "DroneIDDemod";
DroneIDDemod::DroneIDDemod(DeviceAPI *deviceAPI) :
ChannelAPI(m_channelIdURI, ChannelAPI::StreamSingleSink),
m_deviceAPI(deviceAPI),
m_basebandSampleRate(0),
m_centerFrequency(0),
m_burstsDecoded(0),
m_dronesTracked(0),
m_scanPosition(0),
m_scanFrequency(0),
m_scanTuneTime(0),
m_scanBurstTime(-1),
m_scanLocked(false)
{
setObjectName(m_channelId);
m_thread.setObjectName("DroneIDDeBB");
m_basebandSink = new DroneIDDemodBaseband(this);
m_basebandSink->setMessageQueueToChannel(getInputMessageQueue());
m_basebandSink->setChannel(this);
m_basebandSink->moveToThread(&m_thread);
applySettings(QStringList(), m_settings, true);
m_deviceAPI->addChannelSink(this);
m_deviceAPI->addChannelSinkAPI(this);
m_networkManager = new QNetworkAccessManager();
QObject::connect(
m_networkManager,
&QNetworkAccessManager::finished,
this,
&DroneIDDemod::networkManagerFinished
);
QObject::connect(
this,
&ChannelAPI::indexInDeviceSetChanged,
this,
&DroneIDDemod::handleIndexInDeviceSetChanged
);
connect(&m_mapTimer, &QTimer::timeout, this, &DroneIDDemod::removeOldDrones);
m_mapTimer.start(10 * 1000);
connect(&m_scanTimer, &QTimer::timeout, this, &DroneIDDemod::scanTimeout);
}
DroneIDDemod::~DroneIDDemod()
{
qDebug("DroneIDDemod::~DroneIDDemod");
m_mapTimer.stop();
m_scanTimer.stop();
for (auto it = m_drones.begin(); it != m_drones.end(); ++it)
{
if (it->m_onMap) {
clearFromMap(it.key());
}
}
QObject::disconnect(
m_networkManager,
&QNetworkAccessManager::finished,
this,
&DroneIDDemod::networkManagerFinished
);
delete m_networkManager;
m_deviceAPI->removeChannelSinkAPI(this);
m_deviceAPI->removeChannelSink(this, true);
if (m_basebandSink->isRunning()) {
stop();
}
delete m_basebandSink;
}
void DroneIDDemod::setDeviceAPI(DeviceAPI *deviceAPI)
{
if (deviceAPI != m_deviceAPI)
{
m_deviceAPI->removeChannelSinkAPI(this);
m_deviceAPI->removeChannelSink(this, false);
m_deviceAPI = deviceAPI;
m_deviceAPI->addChannelSink(this);
m_deviceAPI->addChannelSinkAPI(this);
}
}
uint32_t DroneIDDemod::getNumberOfDeviceStreams() const
{
return m_deviceAPI->getNbSourceStreams();
}
void DroneIDDemod::feed(const SampleVector::const_iterator& begin, const SampleVector::const_iterator& end, bool firstOfBurst)
{
(void) firstOfBurst;
m_basebandSink->feed(begin, end);
}
void DroneIDDemod::start()
{
qDebug("DroneIDDemod::start");
m_basebandSink->reset();
m_basebandSink->startWork();
m_thread.start();
DSPSignalNotification *dspMsg = new DSPSignalNotification(m_basebandSampleRate, m_centerFrequency);
m_basebandSink->getInputMessageQueue()->push(dspMsg);
DroneIDDemodBaseband::MsgConfigureDroneIDDemodBaseband *msg = DroneIDDemodBaseband::MsgConfigureDroneIDDemodBaseband::create(QStringList(), m_settings, true);
m_basebandSink->getInputMessageQueue()->push(msg);
}
void DroneIDDemod::stop()
{
qDebug("DroneIDDemod::stop");
m_basebandSink->stopWork();
m_thread.quit();
m_thread.wait();
}
bool DroneIDDemod::handleMessage(const Message& cmd)
{
if (MsgConfigureDroneIDDemod::match(cmd))
{
MsgConfigureDroneIDDemod& cfg = (MsgConfigureDroneIDDemod&) cmd;
qDebug() << "DroneIDDemod::handleMessage: MsgConfigureDroneIDDemod";
applySettings(cfg.getSettingsKeys(), cfg.getSettings(), cfg.getForce());
return true;
}
else if (DSPSignalNotification::match(cmd))
{
DSPSignalNotification& notif = (DSPSignalNotification&) cmd;
m_basebandSampleRate = notif.getSampleRate();
m_centerFrequency = notif.getCenterFrequency();
// Forward to the sink
DSPSignalNotification* rep = new DSPSignalNotification(notif); // make a copy
qDebug() << "DroneIDDemod::handleMessage: DSPSignalNotification";
m_basebandSink->getInputMessageQueue()->push(rep);
// Forward to GUI if any
if (getMessageQueueToGUI()) {
getMessageQueueToGUI()->push(new DSPSignalNotification(notif));
}
return true;
}
else if (MsgBurstResult::match(cmd))
{
handleBurstResult((const MsgBurstResult&) cmd);
return true;
}
else if (MainCore::MsgChannelDemodQuery::match(cmd))
{
qDebug() << "DroneIDDemod::handleMessage: MsgChannelDemodQuery";
sendSampleRateToDemodAnalyzer();
return true;
}
else
{
return false;
}
}
void DroneIDDemod::handleBurstResult(const MsgBurstResult& result)
{
if (result.getDetected() && m_scanTimer.isActive())
{
qint64 now = m_scanClock.elapsed();
if (now - m_scanTuneTime >= m_scanSettleTime)
{
m_scanBurstTime = now;
// Remember frequency, so it's searched first in future
qint64 frequency = scanFrequencyMatch(result.getFrequency());
if (frequency != 0)
{
m_scanHistory.removeAll(frequency);
m_scanHistory.prepend(frequency);
}
}
}
// Forward bursts with DroneID sync to GUI, so it can display SNR even if not decoded.
// Other detections (E.g. from video link) aren't forwarded, as they can occur at a high rate.
if (result.getDetected() && getMessageQueueToGUI()) {
getMessageQueueToGUI()->push(new MsgBurstResult(result));
}
if (!result.getDecoded() || result.getMessage().isEmpty()) {
return;
}
m_burstsDecoded++;
const QByteArray& bytes = result.getMessage();
DroneIDMessage *msg = DroneIDMessage::decode(bytes);
// Forward to packet consumers (E.g. MCP)
QList<ObjectPipe*> packetPipes;
MainCore::instance()->getMessagePipes().getMessagePipes(this, "packets", packetPipes);
for (const auto& pipe : packetPipes)
{
MessageQueue *messageQueue = qobject_cast<MessageQueue*>(pipe->m_element);
messageQueue->push(MainCore::MsgPacket::create(this, bytes, result.getDateTime()));
}
// Forward via UDP
if (m_settings.m_udpEnabled) {
m_udpSocket.writeDatagram(bytes.data(), bytes.size(), QHostAddress(m_settings.m_udpAddress), m_settings.m_udpPort);
}
logMessage(result, msg);
if (msg)
{
if (!msg->m_serial.isEmpty())
{
Drone& drone = m_drones[msg->m_serial];
m_dronesTracked = m_drones.size();
drone.m_lastUpdate = QDateTime::currentDateTime();
drone.m_lastSeen = result.getDateTime().isValid() ? result.getDateTime() : drone.m_lastUpdate;
if (msg->isFlightInformation())
{
sendToMap(msg, result.getDateTime(), drone);
drone.m_onMap = true;
}
}
delete msg;
}
}
void DroneIDDemod::logMessage(const MsgBurstResult& result, const DroneIDMessage *msg)
{
if (!m_logFile.isOpen()) {
return;
}
m_logStream << result.getDateTime().date().toString() << ","
<< result.getDateTime().time().toString() << ","
<< result.getMessage().toHex() << ",";
if (msg && msg->isFlightInformation())
{
m_logStream << msg->m_serial << ","
<< msg->getProductTypeName() << ","
<< msg->m_sequence << ","
<< QString::number(msg->m_latitude, 'f', 7) << ","
<< QString::number(msg->m_longitude, 'f', 7) << ","
<< msg->m_altitude << ","
<< msg->m_height << ","
<< msg->getSpeed() << ","
<< msg->m_vUp << ","
<< msg->m_yaw << ","
<< QString::number(msg->m_pilotLatitude, 'f', 7) << ","
<< QString::number(msg->m_pilotLongitude, 'f', 7) << ","
<< QString::number(msg->m_homeLatitude, 'f', 7) << ","
<< QString::number(msg->m_homeLongitude, 'f', 7) << ","
<< msg->m_uuid << ","
<< (msg->m_crcValid ? "OK" : "Bad") << ",";
}
else if (msg)
{
m_logStream << msg->m_serial << ",,,,,,,,,,,,,,," << (msg->m_crcValid ? "OK" : "Bad") << ",";
}
else
{
m_logStream << ",,,,,,,,,,,,,,,,";
}
m_logStream << result.getSNR() << "," << result.getCFO() << ","
<< QString::number(result.getFrequency() / 1e6, 'f', 3) << "\n";
}
// If model is specified, it is displayed on the 3D map, oriented by imageRotation.
// If animation is specified, that animation in the model is started (or stopped if stopAnimation is true).
// altitudeReference is 0 for altitude above WGS84 ellipsoid, 1 to clamp to ground, 2 for height above ground
// or 3 for altitude above WGS84 ellipsoid, but not below ground.
void DroneIDDemod::sendMapItem(const QString& name, double latitude, double longitude, float altitude, int altitudeReference,
const QString& image, float imageRotation, const QString& label, const QString& text, const QDateTime& dateTime,
const QString& model, const QString& animation, bool stopAnimation)
{
QList<ObjectPipe*> mapPipes;
MainCore::instance()->getMessagePipes().getMessagePipes(this, "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->setLatitude(latitude);
swgMapItem->setLongitude(longitude);
swgMapItem->setAltitude(altitude);
swgMapItem->setAltitudeReference(altitudeReference);
swgMapItem->setPositionDateTime(new QString(dateTime.toString(Qt::ISODateWithMs)));
swgMapItem->setFixedPosition(false);
swgMapItem->setImage(new QString(image));
swgMapItem->setImageRotation(imageRotation);
swgMapItem->setLabel(new QString(label));
swgMapItem->setText(new QString(text));
if (!model.isEmpty())
{
swgMapItem->setModel(new QString(model));
swgMapItem->setOrientation(1); // Use heading, rather than velocity calculated from positions
swgMapItem->setHeading(imageRotation);
swgMapItem->setPitch(0.0f);
swgMapItem->setRoll(0.0f);
swgMapItem->setOrientationDateTime(new QString(dateTime.toString(Qt::ISODateWithMs)));
swgMapItem->setLabelAltitudeOffset(1.0f);
if (!animation.isEmpty())
{
// Each map item owns and deletes its animations, so create for each pipe
SWGSDRangel::SWGMapAnimation *swgAnimation = new SWGSDRangel::SWGMapAnimation();
swgAnimation->setName(new QString(animation));
swgAnimation->setStartDateTime(new QString(dateTime.toString(Qt::ISODateWithMs)));
swgAnimation->setReverse(0);
swgAnimation->setLoop(1);
swgAnimation->setMultiplier(1.0f);
swgAnimation->setStop(stopAnimation ? 1 : 0);
QList<SWGSDRangel::SWGMapAnimation *> *animations = new QList<SWGSDRangel::SWGMapAnimation *>();
animations->append(swgAnimation);
swgMapItem->setAnimations(animations);
}
}
MainCore::MsgMapItem *msg = MainCore::MsgMapItem::create(this, swgMapItem);
messageQueue->push(msg);
}
}
void DroneIDDemod::sendToMap(const DroneIDMessage *msg, const QDateTime& dateTime, Drone& drone)
{
const QString model = msg->getProductTypeName();
if (msg->hasPosition())
{
QString text = QString("DroneID\nSerial: %1\nModel: %2\nAltitude: %3 m (WGS84)\nHeight: %4 m (above take-off)\nSpeed: %5 m/s\nVertical speed: %6 m/s\nYaw: %7%8")
.arg(msg->m_serial)
.arg(model)
.arg(msg->m_altitude)
.arg(msg->m_height)
.arg(msg->getSpeed(), 0, 'f', 1)
.arg(msg->m_vUp, 0, 'f', 1)
.arg(msg->m_yaw, 0, 'f', 0)
.arg(QChar(0xb0));
// Yaw is -180 to 180
float heading = msg->m_yaw < 0.0f ? msg->m_yaw + 360.0f : msg->m_yaw;
float altitude;
int altitudeReference;
if (m_settings.m_mapAltitude == DroneIDDemodSettings::MAP_ALTITUDE)
{
// Altitude appears to be GPS height above the WGS84 ellipsoid (not MSL), as used by the 3D map.
// GPS error can put it slightly below ground on take-off and landing, so clip to ground.
altitude = msg->m_altitude;
altitudeReference = 3;
}
else
{
// Height above take-off point, displayed relative to the ground at the drone's position.
// This is never below ground, but is offset by any difference in ground height from the take-off point.
altitude = std::max(msg->m_height, 0.0f);
altitudeReference = 2;
}
// Spin propellers in 3D model while motors are on. Animations are only sent when this changes.
bool motorsOn = (msg->m_stateInfo & DroneIDMessage::MotorsOn) != 0;
QString animation;
if (motorsOn != drone.m_propellersSpinning)
{
animation = "Take 01";
drone.m_propellersSpinning = motorsOn;
}
sendMapItem(msg->m_serial, msg->m_latitude, msg->m_longitude, altitude, altitudeReference,
"qrc:///droneiddemod/map/drone.png", heading, model, text, dateTime, "drone.glb", animation, !motorsOn);
}
if (msg->hasPilotPosition())
{
QString text = QString("DroneID Pilot\nSerial: %1\nModel: %2").arg(msg->m_serial).arg(model);
sendMapItem(msg->m_serial + " Pilot", msg->m_pilotLatitude, msg->m_pilotLongitude, 0.0f, 1,
"qrc:///droneiddemod/map/pilot.png", 0.0f, QString("%1 Pilot").arg(model), text, dateTime);
}
if (msg->hasHomePosition())
{
QString text = QString("DroneID Home\nSerial: %1\nModel: %2").arg(msg->m_serial).arg(model);
sendMapItem(msg->m_serial + " Home", msg->m_homeLatitude, msg->m_homeLongitude, 0.0f, 1,
"qrc:///droneiddemod/map/home.png", 0.0f, QString("%1 Home").arg(model), text, dateTime);
}
}
void DroneIDDemod::clearFromMap(const QString& serial)
{
QList<ObjectPipe*> mapPipes;
MainCore::instance()->getMessagePipes().getMessagePipes(this, "mapitems", mapPipes);
for (const auto& pipe : mapPipes)
{
MessageQueue *messageQueue = qobject_cast<MessageQueue*>(pipe->m_element);
for (const auto& name : {serial, serial + " Pilot", serial + " Home"})
{
SWGSDRangel::SWGMapItem *swgMapItem = new SWGSDRangel::SWGMapItem();
swgMapItem->setName(new QString(name));
swgMapItem->setImage(new QString(""));
MainCore::MsgMapItem *msg = MainCore::MsgMapItem::create(this, swgMapItem);
messageQueue->push(msg);
}
}
}
void DroneIDDemod::removeOldDrones()
{
if (m_settings.m_mapTimeout <= 0) {
return;
}
// When playing a recording faster or slower than real time, the message times from the file
// determine whether a drone has stopped transmitting. Wall clock time is always also checked,
// so drones are removed when the recording or transmissions stop
QDateTime latest;
for (const auto& drone : m_drones)
{
if (!latest.isValid() || (drone.m_lastSeen > latest)) {
latest = drone.m_lastSeen;
}
}
QDateTime now = QDateTime::currentDateTime();
for (auto it = m_drones.begin(); it != m_drones.end(); )
{
bool expired = it->m_lastUpdate.secsTo(now) > m_settings.m_mapTimeout;
if (m_settings.m_useFileTime) {
expired = expired || (it->m_lastSeen.secsTo(latest) > m_settings.m_mapTimeout);
}
if (expired)
{
if (it->m_onMap) {
clearFromMap(it.key());
}
it = m_drones.erase(it);
}
else
{
++it;
}
}
m_dronesTracked = m_drones.size();
}
void DroneIDDemod::setCenterFrequency(qint64 frequency)
{
DroneIDDemodSettings settings = m_settings;
settings.m_inputFrequencyOffset = frequency;
applySettings(QStringList("inputFrequencyOffset"), settings, false);
if (m_guiMessageQueue) // forward to GUI if any
{
MsgConfigureDroneIDDemod *msgToGUI = MsgConfigureDroneIDDemod::create(QStringList("inputFrequencyOffset"), settings, false);
m_guiMessageQueue->push(msgToGUI);
}
}
void DroneIDDemod::applySettings(const QStringList& settingsKeys, const DroneIDDemodSettings& settings, bool force)
{
qDebug() << "DroneIDDemod::applySettings:" << settings.getDebugString(settingsKeys, force);
if (settingsKeys.contains("streamIndex") && (m_settings.m_streamIndex != settings.m_streamIndex))
{
if (m_deviceAPI->getSampleMIMO()) // change of stream is possible for MIMO devices only
{
m_deviceAPI->removeChannelSinkAPI(this);
m_deviceAPI->removeChannelSink(this, m_settings.m_streamIndex);
m_deviceAPI->addChannelSink(this, settings.m_streamIndex);
m_deviceAPI->addChannelSinkAPI(this);
m_settings.m_streamIndex = settings.m_streamIndex; // make sure ChannelAPI::getStreamIndex() is consistent
emit streamIndexChanged(settings.m_streamIndex);
}
}
DroneIDDemodBaseband::MsgConfigureDroneIDDemodBaseband *msg = DroneIDDemodBaseband::MsgConfigureDroneIDDemodBaseband::create(settingsKeys, settings, force);
m_basebandSink->getInputMessageQueue()->push(msg);
if (settings.m_useReverseAPI)
{
bool fullUpdate = ((settingsKeys.contains("useReverseAPI") && (m_settings.m_useReverseAPI != settings.m_useReverseAPI)) && settings.m_useReverseAPI) ||
(settingsKeys.contains("reverseAPIAddress") && (m_settings.m_reverseAPIAddress != settings.m_reverseAPIAddress)) ||
(settingsKeys.contains("reverseAPIPort") && (m_settings.m_reverseAPIPort != settings.m_reverseAPIPort)) ||
(settingsKeys.contains("reverseAPIDeviceIndex") && (m_settings.m_reverseAPIDeviceIndex != settings.m_reverseAPIDeviceIndex)) ||
(settingsKeys.contains("reverseAPIChannelIndex") && (m_settings.m_reverseAPIChannelIndex != settings.m_reverseAPIChannelIndex));
webapiReverseSendSettings(settingsKeys, settings, fullUpdate || force);
}
if ((settingsKeys.contains("logEnabled") && (settings.m_logEnabled != m_settings.m_logEnabled))
|| (settingsKeys.contains("logFilename") && (settings.m_logFilename != m_settings.m_logFilename))
|| force)
{
if (m_logFile.isOpen())
{
m_logStream.flush();
m_logFile.close();
}
if (settings.m_logEnabled && !settings.m_logFilename.isEmpty())
{
m_logFile.setFileName(settings.m_logFilename);
if (m_logFile.open(QIODevice::WriteOnly | QIODevice::Append | QIODevice::Text))
{
qDebug() << "DroneIDDemod::applySettings - Logging to: " << settings.m_logFilename;
bool newFile = m_logFile.size() == 0;
m_logStream.setDevice(&m_logFile);
if (newFile)
{
// Write header
m_logStream << "Date,Time,Data,Serial,Model,Seq,Lat,Lon,Alt (m),Height (m),Speed (m/s),V/S (m/s),Yaw,Pilot Lat,Pilot Lon,Home Lat,Home Lon,UUID,CRC,SNR (dB),CFO (Hz),Frequency (MHz)\n";
}
}
else
{
qDebug() << "DroneIDDemod::applySettings - Unable to open log file: " << settings.m_logFilename;
}
}
}
bool scanChanged = (settingsKeys.contains("scan") && (settings.m_scan != m_settings.m_scan))
|| (settingsKeys.contains("scanBand") && (settings.m_scanBand != m_settings.m_scanBand))
|| force;
if (force) {
m_settings = settings;
} else {
m_settings.applySettings(settingsKeys, settings);
}
if (scanChanged)
{
if (m_settings.m_scan) {
startScan();
} else {
stopScan();
}
}
}
// Scanning steps the device center frequency through the DroneID channels, so that the channel
// is on each of them for m_scanDwell seconds. When a burst with DroneID sync is detected, the scan
// pauses until no bursts have been detected for m_scanHold seconds.
// Each pass through the channels starts with those that bursts have previously been detected on,
// most recent first, as drones often reuse channels, followed by the remainder in frequency order.
void DroneIDDemod::startScan()
{
m_scanFrequencies = DroneIDDemodSettings::getScanFrequencies(m_settings.m_scanBand);
m_scanClock.start();
m_scanBurstTime = -1;
m_scanLocked = false;
// Start on the current channel, if it's one of those being scanned
m_scanFrequency = scanFrequencyMatch(m_centerFrequency + m_settings.m_inputFrequencyOffset);
scanNewPass();
if (m_scanFrequency != 0) {
m_scanTuneTime = m_scanClock.elapsed() - m_scanSettleTime;
} else {
m_scanTuneTime = std::numeric_limits<qint64>::min() / 2; // Tune on first timeout when device is running
}
m_scanTimer.start(m_scanTimerInterval);
}
void DroneIDDemod::stopScan()
{
m_scanTimer.stop();
m_scanLocked = false;
}
// Returns the scanned frequency that matches the given frequency, or 0 if none
qint64 DroneIDDemod::scanFrequencyMatch(qint64 frequency) const
{
for (const auto f : m_scanFrequencies)
{
// Allow for small differences due to LO correction or tuning resolution
if (std::abs(f - frequency) <= 1000) {
return f;
}
}
return 0;
}
// Create order of frequencies to visit: previously used frequencies first, then the rest.
// The current frequency is visited last, as we've just been listening to it.
void DroneIDDemod::scanNewPass()
{
m_scanOrder.clear();
for (const auto f : m_scanHistory)
{
if (m_scanFrequencies.contains(f) && (f != m_scanFrequency)) {
m_scanOrder.append(f);
}
}
for (const auto f : m_scanFrequencies)
{
if (!m_scanOrder.contains(f) && (f != m_scanFrequency)) {
m_scanOrder.append(f);
}
}
if (m_scanFrequency != 0) {
m_scanOrder.append(m_scanFrequency);
}
m_scanPosition = 0;
}
void DroneIDDemod::scanTune(qint64 frequency)
{
qint64 centerFrequency = frequency - m_settings.m_inputFrequencyOffset;
m_scanFrequency = frequency;
m_scanTuneTime = m_scanClock.elapsed();
if (!ChannelWebAPIUtils::setCenterFrequency(getDeviceSetIndex(), centerFrequency)) {
qWarning() << "DroneIDDemod::scanTune: Failed to set device center frequency to" << centerFrequency;
}
}
void DroneIDDemod::scanTimeout()
{
if (m_scanOrder.isEmpty()) {
return;
}
qint64 now = m_scanClock.elapsed();
bool locked = (m_scanBurstTime >= 0) && (now - m_scanBurstTime < (qint64) (m_settings.m_scanHold * 1000.0f));
m_scanLocked = locked;
// Don't retune while device isn't running, as no bursts can be received
if (locked || !m_basebandSink->isRunning()) {
return;
}
if (m_scanBurstTime >= 0)
{
// Bursts have stopped on this channel. Start a new pass, so other previously used channels are searched first
m_scanBurstTime = -1;
scanNewPass();
}
else if (now - m_scanTuneTime < (qint64) (m_settings.m_scanDwell * 1000.0f))
{
return;
}
if (m_scanPosition >= m_scanOrder.size()) {
scanNewPass();
}
scanTune(m_scanOrder[m_scanPosition++]);
}
QByteArray DroneIDDemod::serialize() const
{
return m_settings.serialize();
}
bool DroneIDDemod::deserialize(const QByteArray& data)
{
if (m_settings.deserialize(data))
{
MsgConfigureDroneIDDemod *msg = MsgConfigureDroneIDDemod::create(QStringList(), m_settings, true);
m_inputMessageQueue.push(msg);
return true;
}
else
{
m_settings.resetToDefaults();
MsgConfigureDroneIDDemod *msg = MsgConfigureDroneIDDemod::create(QStringList(), m_settings, true);
m_inputMessageQueue.push(msg);
return false;
}
}
void DroneIDDemod::sendSampleRateToDemodAnalyzer()
{
QList<ObjectPipe*> reportPipes;
MainCore::instance()->getMessagePipes().getMessagePipes(this, "reportdemod", reportPipes);
for (const auto& pipe : reportPipes)
{
MessageQueue *messageQueue = qobject_cast<MessageQueue*>(pipe->m_element);
MainCore::MsgChannelDemodReport *msg = MainCore::MsgChannelDemodReport::create(
this,
DroneIDDemodSettings::DRONEIDDEMOD_CHANNEL_SAMPLE_RATE
);
messageQueue->push(msg);
}
}
int DroneIDDemod::webapiSettingsGet(
SWGSDRangel::SWGChannelSettings& response,
QString& errorMessage)
{
(void) errorMessage;
response.setDroneIdDemodSettings(new SWGSDRangel::SWGDroneIDDemodSettings());
response.getDroneIdDemodSettings()->init();
webapiFormatChannelSettings(response, m_settings);
return 200;
}
int DroneIDDemod::webapiWorkspaceGet(
SWGSDRangel::SWGWorkspaceInfo& response,
QString& errorMessage)
{
(void) errorMessage;
response.setIndex(m_settings.m_workspaceIndex);
return 200;
}
int DroneIDDemod::webapiReportGet(
SWGSDRangel::SWGChannelReport& response,
QString& errorMessage)
{
(void) errorMessage;
response.setDroneIdDemodReport(new SWGSDRangel::SWGDroneIDDemodReport());
response.getDroneIdDemodReport()->init();
webapiFormatChannelReport(response);
return 200;
}
void DroneIDDemod::webapiFormatChannelReport(SWGSDRangel::SWGChannelReport& response)
{
double magsqAvg, magsqPeak;
int nbMagsqSamples;
getMagSqLevels(magsqAvg, magsqPeak, nbMagsqSamples);
response.getDroneIdDemodReport()->setChannelPowerDb(CalcDb::dbPower(magsqAvg));
response.getDroneIdDemodReport()->setChannelSampleRate(m_basebandSink->getChannelSampleRate());
response.getDroneIdDemodReport()->setBurstsDetected(getBurstsDetected());
response.getDroneIdDemodReport()->setBurstsDecoded(getBurstsDecoded());
response.getDroneIdDemodReport()->setBurstsDropped(getBurstsDropped());
response.getDroneIdDemodReport()->setDronesTracked(getDronesTracked());
response.getDroneIdDemodReport()->setScanLocked(isScanLocked() ? 1 : 0);
}
int DroneIDDemod::webapiSettingsPutPatch(
bool force,
const QStringList& channelSettingsKeys,
SWGSDRangel::SWGChannelSettings& response,
QString& errorMessage)
{
(void) errorMessage;
DroneIDDemodSettings settings = m_settings;
webapiUpdateChannelSettings(settings, channelSettingsKeys, response);
MsgConfigureDroneIDDemod *msg = MsgConfigureDroneIDDemod::create(channelSettingsKeys, settings, force);
m_inputMessageQueue.push(msg);
qDebug("DroneIDDemod::webapiSettingsPutPatch: forward to GUI: %p", m_guiMessageQueue);
if (m_guiMessageQueue) // forward to GUI if any
{
MsgConfigureDroneIDDemod *msgToGUI = MsgConfigureDroneIDDemod::create(channelSettingsKeys, settings, force);
m_guiMessageQueue->push(msgToGUI);
}
webapiFormatChannelSettings(response, settings);
return 200;
}
void DroneIDDemod::webapiUpdateChannelSettings(
DroneIDDemodSettings& settings,
const QStringList& channelSettingsKeys,
SWGSDRangel::SWGChannelSettings& response)
{
if (channelSettingsKeys.contains("inputFrequencyOffset")) {
settings.m_inputFrequencyOffset = response.getDroneIdDemodSettings()->getInputFrequencyOffset();
}
if (channelSettingsKeys.contains("detectionThreshold")) {
settings.m_detectionThreshold = std::clamp(response.getDroneIdDemodSettings()->getDetectionThreshold(), 0.05f, 0.95f);
}
if (channelSettingsKeys.contains("turboIterations")) {
settings.m_turboIterations = std::clamp(response.getDroneIdDemodSettings()->getTurboIterations(), 1, 16);
}
if (channelSettingsKeys.contains("filterSerial")) {
settings.m_filterSerial = *response.getDroneIdDemodSettings()->getFilterSerial();
}
if (channelSettingsKeys.contains("mapTimeout")) {
settings.m_mapTimeout = std::clamp(response.getDroneIdDemodSettings()->getMapTimeout(), 0, 3600);
}
if (channelSettingsKeys.contains("mapAltitude")) {
settings.m_mapAltitude = (DroneIDDemodSettings::MapAltitude) std::clamp(response.getDroneIdDemodSettings()->getMapAltitude(),
(int) DroneIDDemodSettings::MAP_ALTITUDE, (int) DroneIDDemodSettings::MAP_HEIGHT);
}
if (channelSettingsKeys.contains("scan")) {
settings.m_scan = response.getDroneIdDemodSettings()->getScan() != 0;
}
if (channelSettingsKeys.contains("scanBand")) {
settings.m_scanBand = (DroneIDDemodSettings::ScanBand) std::clamp(response.getDroneIdDemodSettings()->getScanBand(),
(int) DroneIDDemodSettings::BAND_2_4_GHZ, (int) DroneIDDemodSettings::BAND_2_4_AND_5_8_GHZ);
}
if (channelSettingsKeys.contains("scanDwell")) {
settings.m_scanDwell = std::clamp(response.getDroneIdDemodSettings()->getScanDwell(), 0.5f, 60.0f);
}
if (channelSettingsKeys.contains("scanHold")) {
settings.m_scanHold = std::clamp(response.getDroneIdDemodSettings()->getScanHold(), 0.5f, 600.0f);
}
if (channelSettingsKeys.contains("udpEnabled")) {
settings.m_udpEnabled = response.getDroneIdDemodSettings()->getUdpEnabled();
}
if (channelSettingsKeys.contains("udpAddress")) {
settings.m_udpAddress = *response.getDroneIdDemodSettings()->getUdpAddress();
}
if (channelSettingsKeys.contains("udpPort")) {
settings.m_udpPort = response.getDroneIdDemodSettings()->getUdpPort();
}
if (channelSettingsKeys.contains("logFilename")) {
settings.m_logFilename = *response.getDroneIdDemodSettings()->getLogFilename();
}
if (channelSettingsKeys.contains("logEnabled")) {
settings.m_logEnabled = response.getDroneIdDemodSettings()->getLogEnabled();
}
if (channelSettingsKeys.contains("useFileTime")) {
settings.m_useFileTime = response.getDroneIdDemodSettings()->getUseFileTime();
}
if (channelSettingsKeys.contains("rgbColor")) {
settings.m_rgbColor = response.getDroneIdDemodSettings()->getRgbColor();
}
if (channelSettingsKeys.contains("title")) {
settings.m_title = *response.getDroneIdDemodSettings()->getTitle();
}
if (channelSettingsKeys.contains("streamIndex")) {
settings.m_streamIndex = response.getDroneIdDemodSettings()->getStreamIndex();
}
if (channelSettingsKeys.contains("useReverseAPI")) {
settings.m_useReverseAPI = response.getDroneIdDemodSettings()->getUseReverseApi() != 0;
}
if (channelSettingsKeys.contains("reverseAPIAddress")) {
settings.m_reverseAPIAddress = *response.getDroneIdDemodSettings()->getReverseApiAddress();
}
if (channelSettingsKeys.contains("reverseAPIPort")) {
settings.m_reverseAPIPort = response.getDroneIdDemodSettings()->getReverseApiPort();
}
if (channelSettingsKeys.contains("reverseAPIDeviceIndex")) {
settings.m_reverseAPIDeviceIndex = response.getDroneIdDemodSettings()->getReverseApiDeviceIndex();
}
if (channelSettingsKeys.contains("reverseAPIChannelIndex")) {
settings.m_reverseAPIChannelIndex = response.getDroneIdDemodSettings()->getReverseApiChannelIndex();
}
if (settings.m_channelMarker && channelSettingsKeys.contains("channelMarker")) {
settings.m_channelMarker->updateFrom(channelSettingsKeys, response.getDroneIdDemodSettings()->getChannelMarker());
}
if (settings.m_rollupState && channelSettingsKeys.contains("rollupState")) {
settings.m_rollupState->updateFrom(channelSettingsKeys, response.getDroneIdDemodSettings()->getRollupState());
}
}
void DroneIDDemod::setString(QString *(SWGSDRangel::SWGDroneIDDemodSettings::*get)(), void (SWGSDRangel::SWGDroneIDDemodSettings::*set)(QString*),
SWGSDRangel::SWGDroneIDDemodSettings *swg, const QString& value)
{
if ((swg->*get)()) {
*(swg->*get)() = value;
} else {
(swg->*set)(new QString(value));
}
}
void DroneIDDemod::webapiFormatChannelSettings(SWGSDRangel::SWGChannelSettings& response, const DroneIDDemodSettings& settings)
{
SWGSDRangel::SWGDroneIDDemodSettings *swg = response.getDroneIdDemodSettings();
swg->setInputFrequencyOffset(settings.m_inputFrequencyOffset);
swg->setDetectionThreshold(settings.m_detectionThreshold);
swg->setTurboIterations(settings.m_turboIterations);
setString(&SWGSDRangel::SWGDroneIDDemodSettings::getFilterSerial, &SWGSDRangel::SWGDroneIDDemodSettings::setFilterSerial, swg, settings.m_filterSerial);
swg->setMapTimeout(settings.m_mapTimeout);
swg->setMapAltitude((int) settings.m_mapAltitude);
swg->setScan(settings.m_scan ? 1 : 0);
swg->setScanBand((int) settings.m_scanBand);
swg->setScanDwell(settings.m_scanDwell);
swg->setScanHold(settings.m_scanHold);
swg->setUdpEnabled(settings.m_udpEnabled);
setString(&SWGSDRangel::SWGDroneIDDemodSettings::getUdpAddress, &SWGSDRangel::SWGDroneIDDemodSettings::setUdpAddress, swg, settings.m_udpAddress);
swg->setUdpPort(settings.m_udpPort);
setString(&SWGSDRangel::SWGDroneIDDemodSettings::getLogFilename, &SWGSDRangel::SWGDroneIDDemodSettings::setLogFilename, swg, settings.m_logFilename);
swg->setLogEnabled(settings.m_logEnabled);
swg->setUseFileTime(settings.m_useFileTime);
swg->setRgbColor(settings.m_rgbColor);
setString(&SWGSDRangel::SWGDroneIDDemodSettings::getTitle, &SWGSDRangel::SWGDroneIDDemodSettings::setTitle, swg, settings.m_title);
swg->setStreamIndex(settings.m_streamIndex);
swg->setUseReverseApi(settings.m_useReverseAPI ? 1 : 0);
setString(&SWGSDRangel::SWGDroneIDDemodSettings::getReverseApiAddress, &SWGSDRangel::SWGDroneIDDemodSettings::setReverseApiAddress, swg, settings.m_reverseAPIAddress);
swg->setReverseApiPort(settings.m_reverseAPIPort);
swg->setReverseApiDeviceIndex(settings.m_reverseAPIDeviceIndex);
swg->setReverseApiChannelIndex(settings.m_reverseAPIChannelIndex);
if (settings.m_channelMarker)
{
if (swg->getChannelMarker())
{
settings.m_channelMarker->formatTo(swg->getChannelMarker());
}
else
{
SWGSDRangel::SWGChannelMarker *swgChannelMarker = new SWGSDRangel::SWGChannelMarker();
settings.m_channelMarker->formatTo(swgChannelMarker);
swg->setChannelMarker(swgChannelMarker);
}
}
if (settings.m_rollupState)
{
if (swg->getRollupState())
{
settings.m_rollupState->formatTo(swg->getRollupState());
}
else
{
SWGSDRangel::SWGRollupState *swgRollupState = new SWGSDRangel::SWGRollupState();
settings.m_rollupState->formatTo(swgRollupState);
swg->setRollupState(swgRollupState);
}
}
}
void DroneIDDemod::webapiReverseSendSettings(const QStringList& channelSettingsKeys, const DroneIDDemodSettings& settings, bool force)
{
SWGSDRangel::SWGChannelSettings *swgChannelSettings = new SWGSDRangel::SWGChannelSettings();
webapiFormatChannelSettings(channelSettingsKeys, swgChannelSettings, settings, force);
QString channelSettingsURL = QString("http://%1:%2/sdrangel/deviceset/%3/channel/%4/settings")
.arg(settings.m_reverseAPIAddress)
.arg(settings.m_reverseAPIPort)
.arg(settings.m_reverseAPIDeviceIndex)
.arg(settings.m_reverseAPIChannelIndex);
m_networkRequest.setUrl(QUrl(channelSettingsURL));
m_networkRequest.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
QBuffer *buffer = new QBuffer();
buffer->open((QBuffer::ReadWrite));
buffer->write(swgChannelSettings->asJson().toUtf8());
buffer->seek(0);
// Always use PATCH to avoid passing reverse API settings
QNetworkReply *reply = m_networkManager->sendCustomRequest(m_networkRequest, "PATCH", buffer);
buffer->setParent(reply);
delete swgChannelSettings;
}
void DroneIDDemod::webapiFormatChannelSettings(
const QStringList& channelSettingsKeys,
SWGSDRangel::SWGChannelSettings *swgChannelSettings,
const DroneIDDemodSettings& settings,
bool force
)
{
swgChannelSettings->setDirection(0); // Single sink (Rx)
swgChannelSettings->setOriginatorChannelIndex(getIndexInDeviceSet());
swgChannelSettings->setOriginatorDeviceSetIndex(getDeviceSetIndex());
if (swgChannelSettings->getChannelType()) {
*swgChannelSettings->getChannelType() = m_channelId;
} else {
swgChannelSettings->setChannelType(new QString(m_channelId));
}
swgChannelSettings->setDroneIdDemodSettings(new SWGSDRangel::SWGDroneIDDemodSettings());
SWGSDRangel::SWGDroneIDDemodSettings *swg = swgChannelSettings->getDroneIdDemodSettings();
// transfer data that has been modified. When force is on transfer all data except reverse API data
if (channelSettingsKeys.contains("inputFrequencyOffset") || force) {
swg->setInputFrequencyOffset(settings.m_inputFrequencyOffset);
}
if (channelSettingsKeys.contains("detectionThreshold") || force) {
swg->setDetectionThreshold(settings.m_detectionThreshold);
}
if (channelSettingsKeys.contains("turboIterations") || force) {
swg->setTurboIterations(settings.m_turboIterations);
}
if (channelSettingsKeys.contains("filterSerial") || force) {
swg->setFilterSerial(new QString(settings.m_filterSerial));
}
if (channelSettingsKeys.contains("mapTimeout") || force) {
swg->setMapTimeout(settings.m_mapTimeout);
}
if (channelSettingsKeys.contains("mapAltitude") || force) {
swg->setMapAltitude((int) settings.m_mapAltitude);
}
if (channelSettingsKeys.contains("scan") || force) {
swg->setScan(settings.m_scan ? 1 : 0);
}
if (channelSettingsKeys.contains("scanBand") || force) {
swg->setScanBand((int) settings.m_scanBand);
}
if (channelSettingsKeys.contains("scanDwell") || force) {
swg->setScanDwell(settings.m_scanDwell);
}
if (channelSettingsKeys.contains("scanHold") || force) {
swg->setScanHold(settings.m_scanHold);
}
if (channelSettingsKeys.contains("udpEnabled") || force) {
swg->setUdpEnabled(settings.m_udpEnabled);
}
if (channelSettingsKeys.contains("udpAddress") || force) {
swg->setUdpAddress(new QString(settings.m_udpAddress));
}
if (channelSettingsKeys.contains("udpPort") || force) {
swg->setUdpPort(settings.m_udpPort);
}
if (channelSettingsKeys.contains("logFilename") || force) {
swg->setLogFilename(new QString(settings.m_logFilename));
}
if (channelSettingsKeys.contains("logEnabled") || force) {
swg->setLogEnabled(settings.m_logEnabled);
}
if (channelSettingsKeys.contains("useFileTime") || force) {
swg->setUseFileTime(settings.m_useFileTime);
}
if (channelSettingsKeys.contains("rgbColor") || force) {
swg->setRgbColor(settings.m_rgbColor);
}
if (channelSettingsKeys.contains("title") || force) {
swg->setTitle(new QString(settings.m_title));
}
if (channelSettingsKeys.contains("streamIndex") || force) {
swg->setStreamIndex(settings.m_streamIndex);
}
if (settings.m_channelMarker && (channelSettingsKeys.contains("channelMarker") || force))
{
SWGSDRangel::SWGChannelMarker *swgChannelMarker = new SWGSDRangel::SWGChannelMarker();
settings.m_channelMarker->formatTo(swgChannelMarker);
swg->setChannelMarker(swgChannelMarker);
}
if (settings.m_rollupState && (channelSettingsKeys.contains("rollupState") || force))
{
SWGSDRangel::SWGRollupState *swgRollupState = new SWGSDRangel::SWGRollupState();
settings.m_rollupState->formatTo(swgRollupState);
swg->setRollupState(swgRollupState);
}
}
void DroneIDDemod::networkManagerFinished(QNetworkReply *reply)
{
QNetworkReply::NetworkError replyError = reply->error();
if (replyError)
{
qWarning() << "DroneIDDemod::networkManagerFinished:"
<< " error(" << (int) replyError
<< "): " << replyError
<< ": " << reply->errorString();
}
else
{
QString answer = reply->readAll();
answer.chop(1); // remove last \n
qDebug("DroneIDDemod::networkManagerFinished: reply:\n%s", answer.toStdString().c_str());
}
reply->deleteLater();
}
void DroneIDDemod::handleIndexInDeviceSetChanged(int index)
{
if (index < 0) {
return;
}
QString fifoLabel = QString("%1 [%2:%3]")
.arg(m_channelId)
.arg(m_deviceAPI->getDeviceSetIndex())
.arg(index);
m_basebandSink->setFifoLabel(fifoLabel);
}
int DroneIDDemod::getChannelSampleRate() const
{
return m_basebandSink ? m_basebandSink->getChannelSampleRate() : 0;
}