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.
 
 
 
 
 
 

625 lines
24 KiB

///////////////////////////////////////////////////////////////////////////////////
// Copyright (C) 2026 Dan Chokola, KD2HSG //
// Based on the packet modulator plugin: //
// Copyright (C) 2020-2023 Jon Beniston, M7RCE <jon@beniston.com> //
// Copyright (C) 2020-2022 Edouard Griffiths, F4EXB <f4exb06@gmail.com> //
// //
// 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 <QBuffer>
#include <QDebug>
#include <QNetworkAccessManager>
#include <QNetworkReply>
#include <QThread>
#include <algorithm>
#include <chirpmodem.h>
#include "SWGChannelSettings.h"
#include "SWGWorkspaceInfo.h"
#include "SWGChannelReport.h"
#include "SWGChannelActions.h"
#include "SWGChirpModemModSettings.h"
#include "SWGChirpModemModReport.h"
#include "SWGChirpModemModActions.h"
#include "device/deviceapi.h"
#include "dsp/dspcommands.h"
#include "settings/serializable.h"
#include "util/db.h"
#include "maincore.h"
#include "chirpmodemmodbaseband.h"
#include "chirpmodemmod.h"
MESSAGE_CLASS_DEFINITION(ChirpModemMod::MsgConfigureChirpModemMod, Message)
const char *const ChirpModemMod::m_channelIdURI = "sdrangel.channeltx.modchirpmodem";
const char *const ChirpModemMod::m_channelId = "ChirpModemMod";
ChirpModemMod::ChirpModemMod(DeviceAPI *deviceAPI) :
ChannelAPI(m_channelIdURI, ChannelAPI::StreamSingleSource),
m_deviceAPI(deviceAPI),
m_spectrumVis(SDR_TX_SCALEF)
{
setObjectName(m_channelId);
m_thread = new QThread(this);
m_thread->setObjectName("ChirpModemMod");
m_basebandSource = new ChirpModemModBaseband();
m_basebandSource->setSpectrumSampleSink(&m_spectrumVis);
m_basebandSource->setMessageQueueToChannel(getInputMessageQueue());
m_basebandSource->moveToThread(m_thread);
applySettings(QStringList(), m_settings, true);
m_deviceAPI->addChannelSource(this);
m_deviceAPI->addChannelSourceAPI(this);
m_networkManager = new QNetworkAccessManager();
QObject::connect(m_networkManager, &QNetworkAccessManager::finished, this, &ChirpModemMod::networkManagerFinished);
}
ChirpModemMod::~ChirpModemMod()
{
QObject::disconnect(m_networkManager, &QNetworkAccessManager::finished, this, &ChirpModemMod::networkManagerFinished);
delete m_networkManager;
m_deviceAPI->removeChannelSourceAPI(this);
m_deviceAPI->removeChannelSource(this, true);
stop();
delete m_basebandSource;
delete m_thread;
}
void ChirpModemMod::setDeviceAPI(DeviceAPI *deviceAPI)
{
if (deviceAPI != m_deviceAPI)
{
m_deviceAPI->removeChannelSourceAPI(this);
m_deviceAPI->removeChannelSource(this, false);
m_deviceAPI = deviceAPI;
m_deviceAPI->addChannelSource(this);
m_deviceAPI->addChannelSourceAPI(this);
}
}
uint32_t ChirpModemMod::getNumberOfDeviceStreams() const
{
return m_deviceAPI->getNbSinkStreams();
}
void ChirpModemMod::start()
{
qDebug("ChirpModemMod::start");
{
QMutexLocker lock(&m_reportMutex);
m_status = ChirpModemModMessages::Status();
}
m_basebandSource->reset();
m_thread->start();
}
void ChirpModemMod::stop()
{
qDebug("ChirpModemMod::stop");
m_thread->exit();
m_thread->wait();
}
void ChirpModemMod::pull(SampleVector::iterator& begin, unsigned int nbSamples)
{
m_basebandSource->pull(begin, nbSamples);
}
void ChirpModemMod::transmit(const ChirpModemModMessages::TxRequest& request)
{
m_basebandSource->getInputMessageQueue()->push(ChirpModemModMessages::MsgTx::create(request));
}
bool ChirpModemMod::handleMessage(const Message& cmd)
{
if (MsgConfigureChirpModemMod::match(cmd))
{
const auto& cfg = static_cast<const MsgConfigureChirpModemMod&>(cmd);
qDebug() << "ChirpModemMod::handleMessage: MsgConfigureChirpModemMod";
applySettings(cfg.getSettingsKeys(), cfg.getSettings(), cfg.getForce());
return true;
}
else if (ChirpModemModMessages::MsgTx::match(cmd))
{
transmit(static_cast<const ChirpModemModMessages::MsgTx&>(cmd).getRequest());
return true;
}
else if (ChirpModemModMessages::MsgStatus::match(cmd))
{
const auto& status = static_cast<const ChirpModemModMessages::MsgStatus&>(cmd).getStatus();
{
QMutexLocker lock(&m_reportMutex);
m_status = status;
}
if (getMessageQueueToGUI()) {
getMessageQueueToGUI()->push(ChirpModemModMessages::MsgStatus::create(status));
}
return true;
}
else if (DSPSignalNotification::match(cmd))
{
const auto& notif = static_cast<const DSPSignalNotification&>(cmd);
qDebug() << "ChirpModemMod::handleMessage: DSPSignalNotification";
m_basebandSource->getInputMessageQueue()->push(new DSPSignalNotification(notif));
if (getMessageQueueToGUI()) {
getMessageQueueToGUI()->push(new DSPSignalNotification(notif));
}
return true;
}
else
{
return false;
}
}
void ChirpModemMod::setCenterFrequency(qint64 frequency)
{
ChirpModemModSettings settings = m_settings;
settings.m_inputFrequencyOffset = frequency;
applySettings(QStringList("inputFrequencyOffset"), settings, false);
if (m_guiMessageQueue) {
m_guiMessageQueue->push(MsgConfigureChirpModemMod::create(QStringList("inputFrequencyOffset"), settings, false));
}
}
void ChirpModemMod::applySettings(const QStringList& settingsKeys, const ChirpModemModSettings& incomingSettings, bool force)
{
ChirpModemModSettings settings = incomingSettings;
settings.normalize();
qDebug() << "ChirpModemMod::applySettings:" << settings.getDebugString(settingsKeys, force);
if ((settingsKeys.contains("streamIndex") || force) && (settings.m_streamIndex != m_settings.m_streamIndex))
{
if (m_deviceAPI->getSampleMIMO()) // change of stream is possible for MIMO devices only
{
m_deviceAPI->removeChannelSourceAPI(this);
m_deviceAPI->removeChannelSource(this, false, m_settings.m_streamIndex);
m_deviceAPI->addChannelSource(this, settings.m_streamIndex);
m_deviceAPI->addChannelSourceAPI(this);
m_settings.m_streamIndex = settings.m_streamIndex;
emit streamIndexChanged(settings.m_streamIndex);
}
}
m_basebandSource->getInputMessageQueue()->push(
ChirpModemModBaseband::MsgConfigureChirpModemModBaseband::create(settingsKeys, settings, force));
if (settings.m_useReverseAPI)
{
bool fullUpdate =
((settingsKeys.contains("useReverseAPI") && (settings.m_useReverseAPI != m_settings.m_useReverseAPI)) && settings.m_useReverseAPI) ||
(settingsKeys.contains("reverseAPIAddress") && (settings.m_reverseAPIAddress != m_settings.m_reverseAPIAddress)) ||
(settingsKeys.contains("reverseAPIPort") && (settings.m_reverseAPIPort != m_settings.m_reverseAPIPort)) ||
(settingsKeys.contains("reverseAPIDeviceIndex") && (settings.m_reverseAPIDeviceIndex != m_settings.m_reverseAPIDeviceIndex)) ||
(settingsKeys.contains("reverseAPIChannelIndex") && (settings.m_reverseAPIChannelIndex != m_settings.m_reverseAPIChannelIndex));
webapiReverseSendSettings(settingsKeys, settings, fullUpdate || force);
}
if (force) {
m_settings = settings;
} else {
m_settings.applySettings(settingsKeys, settings);
}
}
ChirpModemMod::FrameInfo ChirpModemMod::frameInfo(const ChirpModemModSettings& settings)
{
FrameInfo info;
QByteArray src = settings.m_source.toLatin1();
QByteArray dst = settings.m_destination.toLatin1();
info.m_bodyBytes = settings.m_message.toUtf8().size();
info.m_maxBody = chirpmodem_max_body(src.isEmpty() ? nullptr : src.constData(), dst.isEmpty() ? nullptr : dst.constData());
info.m_coherent = settings.m_mode == ChirpModemModSettings::ModeAuto
? chirpmodem_default_coherent(settings.m_spreadFactor, settings.m_bandwidth) != 0
: settings.m_mode == ChirpModemModSettings::ModeCoherent;
int macLen = 1 + (src.isEmpty() ? 0 : 6) + (dst.isEmpty() ? 0 : 6) + info.m_bodyBytes;
info.m_frameSeconds = chirpmodem_frame_seconds(settings.m_spreadFactor, settings.m_bandwidth, macLen, info.m_coherent ? 1 : 0);
if (settings.cwIdWarning()) {
info.m_warning = QStringLiteral("CW ID is off: identify every 10 minutes and at the end of a communication some other way (47 CFR 97.119)");
} else if (settings.m_cwId && settings.m_source.isEmpty()) {
info.m_warning = QStringLiteral("No CW ID: there is no source callsign");
}
return info;
}
QByteArray ChirpModemMod::serialize() const
{
return m_settings.serialize();
}
bool ChirpModemMod::deserialize(const QByteArray& data)
{
bool valid = m_settings.deserialize(data);
if (!valid) {
m_settings.resetToDefaults();
}
m_inputMessageQueue.push(MsgConfigureChirpModemMod::create(QStringList(), m_settings, true));
return valid;
}
int ChirpModemMod::getChannelSampleRate() const
{
return m_basebandSource ? m_basebandSource->getChannelSampleRate() : 0;
}
double ChirpModemMod::getMagSq() const
{
return m_basebandSource->getMagSq();
}
void ChirpModemMod::setLevelMeter(QObject *levelMeter)
{
connect(m_basebandSource, SIGNAL(levelChanged(qreal, qreal, int)), levelMeter, SLOT(levelChanged(qreal, qreal, int)));
}
int ChirpModemMod::webapiSettingsGet(SWGSDRangel::SWGChannelSettings& response, QString& errorMessage)
{
(void) errorMessage;
response.setChirpModemModSettings(new SWGSDRangel::SWGChirpModemModSettings());
response.getChirpModemModSettings()->init();
webapiFormatChannelSettings(response, m_settings);
return 200;
}
int ChirpModemMod::webapiWorkspaceGet(SWGSDRangel::SWGWorkspaceInfo& response, QString& errorMessage)
{
(void) errorMessage;
response.setIndex(m_settings.m_workspaceIndex);
return 200;
}
int ChirpModemMod::webapiSettingsPutPatch(bool force, const QStringList& channelSettingsKeys,
SWGSDRangel::SWGChannelSettings& response, QString& errorMessage)
{
(void) errorMessage;
ChirpModemModSettings settings = m_settings;
webapiUpdateChannelSettings(settings, channelSettingsKeys, response);
m_inputMessageQueue.push(MsgConfigureChirpModemMod::create(channelSettingsKeys, settings, force));
if (m_guiMessageQueue) {
m_guiMessageQueue->push(MsgConfigureChirpModemMod::create(channelSettingsKeys, settings, force));
}
webapiFormatChannelSettings(response, settings);
return 200;
}
int ChirpModemMod::webapiReportGet(SWGSDRangel::SWGChannelReport& response, QString& errorMessage)
{
(void) errorMessage;
response.setChirpModemModReport(new SWGSDRangel::SWGChirpModemModReport());
response.getChirpModemModReport()->init();
webapiFormatChannelReport(response);
return 200;
}
int ChirpModemMod::webapiActionsPost(const QStringList& channelActionsKeys, SWGSDRangel::SWGChannelActions& query,
QString& errorMessage)
{
SWGSDRangel::SWGChirpModemModActions *actions = query.getChirpModemModActions();
if (!actions)
{
errorMessage = "Missing ChirpModemModActions in query";
return 400;
}
if (!channelActionsKeys.contains("tx") || (actions->getTx() == 0))
{
errorMessage = "Give tx: 1 to transmit";
return 400;
}
// Values not given come from the settings. The checks, such as a source
// callsign in the licensed profile, are made when the frame is generated
// and reported in lastError.
ChirpModemModMessages::TxRequest request;
bool hasSrc = channelActionsKeys.contains("src") && actions->getSrc();
bool hasDst = channelActionsKeys.contains("dst") && actions->getDst();
bool hasMessage = channelActionsKeys.contains("message") && actions->getMessage();
if (hasSrc || hasDst || hasMessage)
{
request.m_override = true;
request.m_source = hasSrc ? *actions->getSrc() : m_settings.m_source;
request.m_destination = hasDst ? *actions->getDst() : m_settings.m_destination;
request.m_body = (hasMessage ? *actions->getMessage() : m_settings.m_message).toUtf8();
}
transmit(request);
return 202;
}
void ChirpModemMod::webapiUpdateChannelSettings(ChirpModemModSettings& settings, const QStringList& channelSettingsKeys,
SWGSDRangel::SWGChannelSettings& response)
{
auto *model = response.getChirpModemModSettings();
if (!model) {
return;
}
if (channelSettingsKeys.contains("inputFrequencyOffset")) {
settings.m_inputFrequencyOffset = model->getInputFrequencyOffset();
}
if (channelSettingsKeys.contains("spreadFactor")) {
settings.m_spreadFactor = model->getSpreadFactor();
}
if (channelSettingsKeys.contains("bandwidth")) {
settings.m_bandwidth = model->getBandwidth();
}
if (channelSettingsKeys.contains("mode")) {
settings.m_mode = model->getMode();
}
if (channelSettingsKeys.contains("profile")) {
settings.m_profile = model->getProfile();
}
if (channelSettingsKeys.contains("source") && model->getSource()) {
settings.m_source = *model->getSource();
}
if (channelSettingsKeys.contains("destination") && model->getDestination()) {
settings.m_destination = *model->getDestination();
}
if (channelSettingsKeys.contains("message") && model->getMessage()) {
settings.m_message = *model->getMessage();
}
if (channelSettingsKeys.contains("repeat")) {
settings.m_repeat = model->getRepeat();
}
if (channelSettingsKeys.contains("gap")) {
settings.m_gap = model->getGap();
}
if (channelSettingsKeys.contains("amplitude")) {
settings.m_amplitude = model->getAmplitude();
}
if (channelSettingsKeys.contains("cwId")) {
settings.m_cwId = model->getCwId() != 0;
}
if (channelSettingsKeys.contains("cwWpm")) {
settings.m_cwWpm = model->getCwWpm();
}
if (channelSettingsKeys.contains("rgbColor")) {
settings.m_rgbColor = model->getRgbColor();
}
if (channelSettingsKeys.contains("title") && model->getTitle()) {
settings.m_title = *model->getTitle();
}
if (channelSettingsKeys.contains("streamIndex")) {
settings.m_streamIndex = model->getStreamIndex();
}
if (channelSettingsKeys.contains("useReverseAPI")) {
settings.m_useReverseAPI = model->getUseReverseApi() != 0;
}
if (channelSettingsKeys.contains("reverseAPIAddress") && model->getReverseApiAddress()) {
settings.m_reverseAPIAddress = *model->getReverseApiAddress();
}
if (channelSettingsKeys.contains("reverseAPIPort")) {
settings.m_reverseAPIPort = model->getReverseApiPort();
}
if (channelSettingsKeys.contains("reverseAPIDeviceIndex")) {
settings.m_reverseAPIDeviceIndex = model->getReverseApiDeviceIndex();
}
if (channelSettingsKeys.contains("reverseAPIChannelIndex")) {
settings.m_reverseAPIChannelIndex = model->getReverseApiChannelIndex();
}
if (settings.m_channelMarker && channelSettingsKeys.contains("channelMarker") && model->getChannelMarker()) {
settings.m_channelMarker->updateFrom(channelSettingsKeys, model->getChannelMarker());
}
if (settings.m_rollupState && channelSettingsKeys.contains("rollupState") && model->getRollupState()) {
settings.m_rollupState->updateFrom(channelSettingsKeys, model->getRollupState());
}
settings.normalize();
}
void ChirpModemMod::webapiFormatChannelSettings(SWGSDRangel::SWGChannelSettings& response, const ChirpModemModSettings& settings)
{
auto *model = response.getChirpModemModSettings();
model->setInputFrequencyOffset(settings.m_inputFrequencyOffset);
model->setSpreadFactor(settings.m_spreadFactor);
model->setBandwidth(settings.m_bandwidth);
model->setMode(settings.m_mode);
model->setProfile(settings.m_profile);
model->setSource(new QString(settings.m_source));
model->setDestination(new QString(settings.m_destination));
model->setMessage(new QString(settings.m_message));
model->setRepeat(settings.m_repeat);
model->setGap(settings.m_gap);
model->setAmplitude(settings.m_amplitude);
model->setCwId(settings.m_cwId ? 1 : 0);
model->setCwWpm(settings.m_cwWpm);
model->setRgbColor(settings.m_rgbColor);
model->setTitle(new QString(settings.m_title));
model->setStreamIndex(settings.m_streamIndex);
model->setUseReverseApi(settings.m_useReverseAPI ? 1 : 0);
model->setReverseApiAddress(new QString(settings.m_reverseAPIAddress));
model->setReverseApiPort(settings.m_reverseAPIPort);
model->setReverseApiDeviceIndex(settings.m_reverseAPIDeviceIndex);
model->setReverseApiChannelIndex(settings.m_reverseAPIChannelIndex);
if (settings.m_channelMarker)
{
auto *item = new SWGSDRangel::SWGChannelMarker();
settings.m_channelMarker->formatTo(item);
model->setChannelMarker(item);
}
if (settings.m_rollupState)
{
auto *item = new SWGSDRangel::SWGRollupState();
settings.m_rollupState->formatTo(item);
model->setRollupState(item);
}
}
void ChirpModemMod::webapiFormatChannelReport(SWGSDRangel::SWGChannelReport& response)
{
auto *model = response.getChirpModemModReport();
FrameInfo info = frameInfo(m_settings);
model->setChannelPowerDb(CalcDb::dbPower(getMagSq()));
model->setFrameSeconds(info.m_frameSeconds);
model->setMaxBody(info.m_maxBody);
model->setWarning(new QString(info.m_warning));
// Read live, like other channels: the status only changes on events
model->setChannelSampleRate(getChannelSampleRate());
model->setIfOffset(m_basebandSource->getChannelFrequencyOffset());
QMutexLocker lock(&m_reportMutex);
model->setTransmitting(m_status.m_transmitting ? 1 : 0);
model->setQueueLength(m_status.m_queueLength);
model->setFramesSent(m_status.m_framesSent);
model->setTransmissions(m_status.m_transmissions);
model->setAirtime(m_status.m_airtime);
model->setLastDuration(m_status.m_lastDuration);
model->setLastEvent(new QString(m_status.m_event));
model->setLastError(new QString(m_status.m_error));
}
void ChirpModemMod::webapiReverseSendSettings(const QList<QString>& channelSettingsKeys, const ChirpModemModSettings& 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 ChirpModemMod::webapiFormatChannelSettings(const QList<QString>& channelSettingsKeys,
SWGSDRangel::SWGChannelSettings *swgChannelSettings,
const ChirpModemModSettings& settings, bool force)
{
swgChannelSettings->setDirection(1); // single source (Tx)
swgChannelSettings->setOriginatorChannelIndex(getIndexInDeviceSet());
swgChannelSettings->setOriginatorDeviceSetIndex(getDeviceSetIndex());
swgChannelSettings->setChannelType(new QString(m_channelId));
auto *model = new SWGSDRangel::SWGChirpModemModSettings();
swgChannelSettings->setChirpModemModSettings(model);
if (force || channelSettingsKeys.contains("inputFrequencyOffset")) {
model->setInputFrequencyOffset(settings.m_inputFrequencyOffset);
}
if (force || channelSettingsKeys.contains("spreadFactor")) {
model->setSpreadFactor(settings.m_spreadFactor);
}
if (force || channelSettingsKeys.contains("bandwidth")) {
model->setBandwidth(settings.m_bandwidth);
}
if (force || channelSettingsKeys.contains("mode")) {
model->setMode(settings.m_mode);
}
if (force || channelSettingsKeys.contains("profile")) {
model->setProfile(settings.m_profile);
}
if (force || channelSettingsKeys.contains("source")) {
model->setSource(new QString(settings.m_source));
}
if (force || channelSettingsKeys.contains("destination")) {
model->setDestination(new QString(settings.m_destination));
}
if (force || channelSettingsKeys.contains("message")) {
model->setMessage(new QString(settings.m_message));
}
if (force || channelSettingsKeys.contains("repeat")) {
model->setRepeat(settings.m_repeat);
}
if (force || channelSettingsKeys.contains("gap")) {
model->setGap(settings.m_gap);
}
if (force || channelSettingsKeys.contains("amplitude")) {
model->setAmplitude(settings.m_amplitude);
}
if (force || channelSettingsKeys.contains("cwId")) {
model->setCwId(settings.m_cwId ? 1 : 0);
}
if (force || channelSettingsKeys.contains("cwWpm")) {
model->setCwWpm(settings.m_cwWpm);
}
if (force || channelSettingsKeys.contains("rgbColor")) {
model->setRgbColor(settings.m_rgbColor);
}
if (force || channelSettingsKeys.contains("title")) {
model->setTitle(new QString(settings.m_title));
}
if (force || channelSettingsKeys.contains("streamIndex")) {
model->setStreamIndex(settings.m_streamIndex);
}
if (settings.m_channelMarker && (force || channelSettingsKeys.contains("channelMarker")))
{
auto *item = new SWGSDRangel::SWGChannelMarker();
settings.m_channelMarker->formatTo(item);
model->setChannelMarker(item);
}
if (settings.m_rollupState && (force || channelSettingsKeys.contains("rollupState")))
{
auto *item = new SWGSDRangel::SWGRollupState();
settings.m_rollupState->formatTo(item);
model->setRollupState(item);
}
}
void ChirpModemMod::networkManagerFinished(QNetworkReply *reply)
{
QNetworkReply::NetworkError replyError = reply->error();
if (replyError)
{
qWarning() << "ChirpModemMod::networkManagerFinished:"
<< " error(" << (int) replyError << "): " << replyError << ": " << reply->errorString();
}
else
{
QString answer = reply->readAll();
answer.chop(1); // remove last \n
qDebug("ChirpModemMod::networkManagerFinished: reply:\n%s", answer.toStdString().c_str());
}
reply->deleteLater();
}