#include <soapysdroutput.h>

Inheritance diagram for SoapySDROutput:

Collaboration diagram for SoapySDROutput:

Classes
class	MsgConfigureSoapySDROutput

class	MsgReportGainChange

class	MsgStartStop

Public Member Functions
	SoapySDROutput (DeviceAPI *deviceAPI)

virtual	~SoapySDROutput ()

virtual void	destroy ()

virtual void	init ()
	initializations to be done when all collaborating objects are created and possibly connected More...

virtual bool	start ()

virtual void	stop ()

SoapySDROutputThread *	getThread ()

void	setThread (SoapySDROutputThread *thread)

virtual QByteArray	serialize () const

virtual bool	deserialize (const QByteArray &data)

virtual void	setMessageQueueToGUI (MessageQueue *queue)

virtual const QString &	getDeviceDescription () const

virtual int	getSampleRate () const
	Sample rate exposed by the sink. More...

virtual void	setSampleRate (int sampleRate)
	For when the sink sample rate is set externally. More...

virtual quint64	getCenterFrequency () const
	Center frequency exposed by the sink. More...

virtual void	setCenterFrequency (qint64 centerFrequency)

virtual bool	handleMessage (const Message &message)

void	getFrequencyRange (uint64_t &min, uint64_t &max)

void	getGlobalGainRange (int &min, int &max)

bool	isAGCSupported ()

const SoapySDR::RangeList &	getRateRanges ()

const std::vector< std::string > &	getAntennas ()

const SoapySDR::RangeList &	getBandwidthRanges ()

const std::vector< DeviceSoapySDRParams::FrequencySetting > &	getTunableElements ()

const std::vector< DeviceSoapySDRParams::GainSetting > &	getIndividualGainsRanges ()

const SoapySDR::ArgInfoList &	getStreamArgInfoList ()

const SoapySDR::ArgInfoList &	getDeviceArgInfoList ()

void	initGainSettings (SoapySDROutputSettings &settings)

void	initTunableElementsSettings (SoapySDROutputSettings &settings)

void	initStreamArgSettings (SoapySDROutputSettings &settings)

void	initDeviceArgSettings (SoapySDROutputSettings &settings)

bool	hasDCAutoCorrection ()

bool	hasDCCorrectionValue ()

bool	hasIQAutoCorrection ()

bool	hasIQCorrectionValue ()

virtual int	webapiSettingsGet (SWGSDRangel::SWGDeviceSettings &response, QString &errorMessage)

virtual int	webapiSettingsPutPatch (bool force, const QStringList &deviceSettingsKeys, SWGSDRangel::SWGDeviceSettings &response, QString &errorMessage)

virtual int	webapiReportGet (SWGSDRangel::SWGDeviceReport &response, QString &errorMessage)

virtual int	webapiRunGet (SWGSDRangel::SWGDeviceState &response, QString &errorMessage)

virtual int	webapiRun (bool run, SWGSDRangel::SWGDeviceState &response, QString &errorMessage)

Public Member Functions inherited from DeviceSampleSink
	DeviceSampleSink ()

virtual	~DeviceSampleSink ()

MessageQueue *	getInputMessageQueue ()

MessageQueue *	getMessageQueueToGUI ()

SampleSourceFifo *	getSampleFifo ()

Private Slots
void	networkManagerFinished (QNetworkReply *reply)

Private Member Functions
bool	openDevice ()

void	closeDevice ()

SoapySDROutputThread *	findThread ()

void	moveThreadToBuddy ()

bool	applySettings (const SoapySDROutputSettings &settings, bool force=false)

bool	setDeviceCenterFrequency (SoapySDR::Device *dev, int requestedChannel, quint64 freq_hz, int loPpmTenths)

void	updateGains (SoapySDR::Device *dev, int requestedChannel, SoapySDROutputSettings &settings)

void	updateTunableElements (SoapySDR::Device *dev, int requestedChannel, SoapySDROutputSettings &settings)

void	webapiFormatDeviceSettings (SWGSDRangel::SWGDeviceSettings &response, const SoapySDROutputSettings &settings)

void	webapiFormatDeviceReport (SWGSDRangel::SWGDeviceReport &response)

QVariant	webapiVariantFromArgValue (SWGSDRangel::SWGArgValue *argValue)

void	webapiFormatArgValue (const QVariant &v, SWGSDRangel::SWGArgValue *argValue)

void	webapiFormatArgInfo (const SoapySDR::ArgInfo &arg, SWGSDRangel::SWGArgInfo *argInfo)

void	webapiReverseSendSettings (QList< QString > &deviceSettingsKeys, const SoapySDROutputSettings &settings, bool force)

void	webapiReverseSendStartStop (bool start)

Private Attributes
DeviceAPI *	m_deviceAPI

QMutex	m_mutex

SoapySDROutputSettings	m_settings

QString	m_deviceDescription

bool	m_running

SoapySDROutputThread *	m_thread

DeviceSoapySDRShared	m_deviceShared

QNetworkAccessManager *	m_networkManager

QNetworkRequest	m_networkRequest

Additional Inherited Members
Public Types inherited from DeviceSampleSink
enum	fcPos_t { FC_POS_INFRA = 0, FC_POS_SUPRA, FC_POS_CENTER }

Static Public Member Functions inherited from DeviceSampleSink
static qint64	calculateDeviceCenterFrequency (quint64 centerFrequency, qint64 transverterDeltaFrequency, int log2Interp, fcPos_t fcPos, quint32 devSampleRate, bool transverterMode=false)

static qint64	calculateCenterFrequency (quint64 deviceCenterFrequency, qint64 transverterDeltaFrequency, int log2Interp, fcPos_t fcPos, quint32 devSampleRate, bool transverterMode=false)

static qint32	calculateFrequencyShift (int log2Interp, fcPos_t fcPos, quint32 devSampleRate)

Protected Slots inherited from DeviceSampleSink
void	handleInputMessages ()

Protected Attributes inherited from DeviceSampleSink
SampleSourceFifo	m_sampleSourceFifo

MessageQueue	m_inputMessageQueue
	Input queue to the sink. More...

MessageQueue *	m_guiMessageQueue
	Input message queue to the GUI. More...

Detailed Description

Definition at line 49 of file soapysdroutput.h.

Constructor & Destructor Documentation

◆ SoapySDROutput()

SoapySDROutput::SoapySDROutput ( DeviceAPI * deviceAPI )

Definition at line 41 of file soapysdroutput.cpp.

                                                    :
     m_deviceAPI(deviceAPI),
     m_deviceDescription("SoapySDROutput"),
     m_running(false),
     m_thread(0)
 {
     m_deviceAPI->setNbSinkStreams(1);
     openDevice();
     initGainSettings(m_settings);
     initTunableElementsSettings(m_settings);
     initStreamArgSettings(m_settings);
     initDeviceArgSettings(m_settings);
 
     m_networkManager = new QNetworkAccessManager();
     connect(m_networkManager, SIGNAL(finished(QNetworkReply*)), this, SLOT(networkManagerFinished(QNetworkReply*)));
 }

◆ ~SoapySDROutput()

SoapySDROutput::~SoapySDROutput ( )

virtual

Definition at line 58 of file soapysdroutput.cpp.

References closeDevice(), m_networkManager, m_running, networkManagerFinished(), and stop().

 {
     disconnect(m_networkManager, SIGNAL(finished(QNetworkReply*)), this, SLOT(networkManagerFinished(QNetworkReply*)));
     delete m_networkManager;
 
     if (m_running) {
         stop();
     }
 
     closeDevice();
 }

Here is the call graph for this function:

Member Function Documentation

◆ applySettings()

bool SoapySDROutput::applySettings	(	const SoapySDROutputSettings &	settings,
		bool	force = `false`
	)

private

Definition at line 854 of file soapysdroutput.cpp.

Referenced by handleMessage(), init(), and stop().

 {
     bool forwardChangeOwnDSP = false;
     bool forwardChangeToBuddies  = false;
     bool globalGainChanged = false;
     bool individualGainsChanged = false;
     bool deviceArgsChanged = false;
     QList<QString> reverseAPIKeys;
 
     SoapySDR::Device *dev = m_deviceShared.m_device;
     SoapySDROutputThread *outputThread = findThread();
     int requestedChannel = m_deviceAPI->getDeviceItemIndex();
     qint64 xlatedDeviceCenterFrequency = settings.m_centerFrequency;
     xlatedDeviceCenterFrequency -= settings.m_transverterMode ? settings.m_transverterDeltaFrequency : 0;
     xlatedDeviceCenterFrequency = xlatedDeviceCenterFrequency < 0 ? 0 : xlatedDeviceCenterFrequency;
 
     // resize FIFO
     if ((m_settings.m_devSampleRate != settings.m_devSampleRate) || (m_settings.m_log2Interp != settings.m_log2Interp) || force)
     {
         SoapySDROutputThread *soapySDROutputThread = findThread();
         SampleSourceFifo *fifo = 0;
 
         if (soapySDROutputThread)
         {
             fifo = soapySDROutputThread->getFifo(requestedChannel);
             soapySDROutputThread->setFifo(requestedChannel, 0);
         }
 
         int fifoSize;
 
         if (settings.m_log2Interp >= 5)
         {
             fifoSize = DeviceSoapySDRShared::m_sampleFifoMinSize32;
         }
         else
         {
             fifoSize = std::max(
                 (int) ((settings.m_devSampleRate/(1<<settings.m_log2Interp)) * DeviceSoapySDRShared::m_sampleFifoLengthInSeconds),
                 DeviceSoapySDRShared::m_sampleFifoMinSize);
         }
 
         m_sampleSourceFifo.resize(fifoSize);
 
         if (fifo) {
             soapySDROutputThread->setFifo(requestedChannel, &m_sampleSourceFifo);
         }
     }
 
     if ((m_settings.m_devSampleRate != settings.m_devSampleRate) || force)
     {
         reverseAPIKeys.append("devSampleRate");
         forwardChangeOwnDSP = true;
         forwardChangeToBuddies = true;
 
         if (dev != 0)
         {
             try
             {
                 dev->setSampleRate(SOAPY_SDR_TX, requestedChannel, settings.m_devSampleRate);
                 qDebug() << "SoapySDROutput::applySettings: setSampleRate OK: " << settings.m_devSampleRate;
 
                 if (outputThread)
                 {
                     bool wasRunning = outputThread->isRunning();
                     outputThread->stopWork();
                     outputThread->setSampleRate(settings.m_devSampleRate);
 
                     if (wasRunning) {
                         outputThread->startWork();
                     }
                 }
             }
             catch (const std::exception &ex)
             {
                 qCritical("SoapySDROutput::applySettings: could not set sample rate: %d: %s",
                         settings.m_devSampleRate, ex.what());
             }
         }
     }
 
     if ((m_settings.m_log2Interp != settings.m_log2Interp) || force)
     {
         reverseAPIKeys.append("log2Interp");
         forwardChangeOwnDSP = true;
 
         if (outputThread != 0)
         {
             outputThread->setLog2Interpolation(requestedChannel, settings.m_log2Interp);
             qDebug() << "SoapySDROutput::applySettings: set decimation to " << (1<<settings.m_log2Interp);
         }
     }
 
     if ((m_settings.m_centerFrequency != settings.m_centerFrequency) || force) {
         reverseAPIKeys.append("centerFrequency");
     }
     if ((m_settings.m_transverterMode != settings.m_transverterMode) || force) {
         reverseAPIKeys.append("transverterMode");
     }
     if ((m_settings.m_transverterDeltaFrequency != settings.m_transverterDeltaFrequency) || force) {
         reverseAPIKeys.append("transverterDeltaFrequency");
     }
     if ((m_settings.m_LOppmTenths != settings.m_LOppmTenths) || force) {
         reverseAPIKeys.append("LOppmTenths");
     }
 
     if ((m_settings.m_centerFrequency != settings.m_centerFrequency)
         || (m_settings.m_transverterMode != settings.m_transverterMode)
         || (m_settings.m_transverterDeltaFrequency != settings.m_transverterDeltaFrequency)
         || (m_settings.m_LOppmTenths != settings.m_LOppmTenths)
         || (m_settings.m_devSampleRate != settings.m_devSampleRate)
         || (m_settings.m_log2Interp != settings.m_log2Interp) || force)
     {
         forwardChangeOwnDSP = true;
         forwardChangeToBuddies = true;
 
         if (dev != 0) {
             setDeviceCenterFrequency(dev, requestedChannel, settings.m_centerFrequency, settings.m_LOppmTenths);
         }
     }
 
     if ((m_settings.m_antenna != settings.m_antenna) || force)
     {
         reverseAPIKeys.append("antenna");
 
         if (dev != 0)
         {
             try
             {
                 dev->setAntenna(SOAPY_SDR_TX, requestedChannel, settings.m_antenna.toStdString());
                 qDebug("SoapySDROutput::applySettings: set antenna to %s", settings.m_antenna.toStdString().c_str());
             }
             catch (const std::exception &ex)
             {
                 qCritical("SoapySDROutput::applySettings: cannot set antenna to %s: %s",
                         settings.m_antenna.toStdString().c_str(), ex.what());
             }
         }
     }
 
     if ((m_settings.m_bandwidth != settings.m_bandwidth) || force)
     {
         reverseAPIKeys.append("bandwidth");
         forwardChangeToBuddies = true;
 
         if (dev != 0)
         {
             try
             {
                 dev->setBandwidth(SOAPY_SDR_TX, requestedChannel, settings.m_bandwidth);
                 qDebug("SoapySDROutput::applySettings: bandwidth set to %u", settings.m_bandwidth);
             }
             catch (const std::exception &ex)
             {
                 qCritical("SoapySDROutput::applySettings: cannot set bandwidth to %u: %s",
                         settings.m_bandwidth, ex.what());
             }
         }
     }
 
     for (const auto &oname : m_settings.m_tunableElements.keys())
     {
         auto nvalue = settings.m_tunableElements.find(oname);
 
         if (nvalue != settings.m_tunableElements.end() && ((m_settings.m_tunableElements[oname] != *nvalue) || force))
         {
             if (dev != 0)
             {
                 try
                 {
                     dev->setFrequency(SOAPY_SDR_TX, requestedChannel, oname.toStdString(), *nvalue);
                     qDebug("SoapySDROutput::applySettings: tunable element %s frequency set to %lf",
                             oname.toStdString().c_str(), *nvalue);
                 }
                 catch (const std::exception &ex)
                 {
                     qCritical("SoapySDROutput::applySettings: cannot set tunable element %s to %lf: %s",
                             oname.toStdString().c_str(), *nvalue, ex.what());
                 }
             }
 
             m_settings.m_tunableElements[oname] = *nvalue;
         }
     }
 
     if ((m_settings.m_globalGain != settings.m_globalGain) || force)
     {
         reverseAPIKeys.append("globalGain");
 
         if (dev != 0)
         {
             try
             {
                 dev->setGain(SOAPY_SDR_TX, requestedChannel, settings.m_globalGain);
                 qDebug("SoapySDROutput::applySettings: set global gain to %d", settings.m_globalGain);
                 globalGainChanged = true;
             }
             catch (const std::exception &ex)
             {
                 qCritical("SoapySDROutput::applySettings: cannot set global gain to %d: %s",
                         settings.m_globalGain, ex.what());
             }
         }
     }
 
     for (const auto &oname : m_settings.m_individualGains.keys())
     {
         auto nvalue = settings.m_individualGains.find(oname);
 
         if (nvalue != settings.m_individualGains.end() && ((m_settings.m_individualGains[oname] != *nvalue) || force))
         {
             if (dev != 0)
             {
                 try
                 {
                     dev->setGain(SOAPY_SDR_TX, requestedChannel, oname.toStdString(), *nvalue);
                     qDebug("SoapySDROutput::applySettings: individual gain %s set to %lf",
                             oname.toStdString().c_str(), *nvalue);
                     individualGainsChanged = true;
                 }
                 catch (const std::exception &ex)
                 {
                     qCritical("SoapySDROutput::applySettings: cannot set individual gain %s to %lf: %s",
                             oname.toStdString().c_str(), *nvalue, ex.what());
                 }
             }
 
             m_settings.m_individualGains[oname] = *nvalue;
         }
     }
 
     if ((m_settings.m_autoGain != settings.m_autoGain) || force)
     {
         reverseAPIKeys.append("autoGain");
 
         if (dev != 0)
         {
             try
             {
                 dev->setGainMode(SOAPY_SDR_TX, requestedChannel, settings.m_autoGain);
                 qDebug("SoapySDROutput::applySettings: %s AGC", settings.m_autoGain ? "set" : "unset");
             }
             catch (const std::exception &ex)
             {
                 qCritical("SoapySDROutput::applySettings: cannot %s AGC", settings.m_autoGain ? "set" : "unset");
             }
         }
     }
 
     if ((m_settings.m_autoDCCorrection != settings.m_autoDCCorrection) || force)
     {
         reverseAPIKeys.append("autoDCCorrection");
 
         if ((dev != 0) && hasDCAutoCorrection())
         {
             try
             {
                 dev->setDCOffsetMode(SOAPY_SDR_TX, requestedChannel, settings.m_autoDCCorrection);
                 qDebug("SoapySDROutput::applySettings: %s DC auto correction", settings.m_autoDCCorrection ? "set" : "unset");
             }
             catch (const std::exception &ex)
             {
                 qCritical("SoapySDROutput::applySettings: cannot %s DC auto correction", settings.m_autoDCCorrection ? "set" : "unset");
             }
         }
     }
 
     if ((m_settings.m_dcCorrection != settings.m_dcCorrection) || force)
     {
         reverseAPIKeys.append("dcCorrection");
 
         if ((dev != 0) && hasDCCorrectionValue())
         {
             try
             {
                 dev->setDCOffset(SOAPY_SDR_TX, requestedChannel, settings.m_dcCorrection);
                 qDebug("SoapySDROutput::applySettings: DC offset correction set to (%lf, %lf)", settings.m_dcCorrection.real(), settings.m_dcCorrection.imag());
             }
             catch (const std::exception &ex)
             {
                 qCritical("SoapySDROutput::applySettings: cannot set DC offset correction to (%lf, %lf)", settings.m_dcCorrection.real(), settings.m_dcCorrection.imag());
             }
         }
     }
 
     if ((m_settings.m_iqCorrection != settings.m_iqCorrection) || force)
     {
         reverseAPIKeys.append("iqCorrection");
 
         if ((dev != 0) && hasIQCorrectionValue())
         {
             try
             {
                 dev->setIQBalance(SOAPY_SDR_TX, requestedChannel, settings.m_iqCorrection);
                 qDebug("SoapySDROutput::applySettings: IQ balance correction set to (%lf, %lf)", settings.m_iqCorrection.real(), settings.m_iqCorrection.imag());
             }
             catch (const std::exception &ex)
             {
                 qCritical("SoapySDROutput::applySettings: cannot set IQ balance correction to (%lf, %lf)", settings.m_iqCorrection.real(), settings.m_iqCorrection.imag());
             }
         }
     }
 
     for (const auto &oname : m_settings.m_streamArgSettings.keys())
     {
         auto nvalue = settings.m_streamArgSettings.find(oname);
 
         if (nvalue != settings.m_streamArgSettings.end() && ((m_settings.m_streamArgSettings[oname] != *nvalue) || force))
         {
             if (dev != 0)
             {
                 try
                 {
                     dev->writeSetting(SOAPY_SDR_TX, requestedChannel, oname.toStdString(), nvalue->toString().toStdString());
                     qDebug("SoapySDROutput::applySettings: stream argument %s set to %s",
                             oname.toStdString().c_str(), nvalue->toString().toStdString().c_str());
                 }
                 catch (const std::exception &ex)
                 {
                     qCritical("SoapySDROutput::applySettings: cannot set stream argument %s to %s: %s",
                             oname.toStdString().c_str(), nvalue->toString().toStdString().c_str(), ex.what());
                 }
             }
 
             m_settings.m_streamArgSettings[oname] = *nvalue;
         }
     }
 
     for (const auto &oname : m_settings.m_deviceArgSettings.keys())
     {
         auto nvalue = settings.m_deviceArgSettings.find(oname);
 
         if (nvalue != settings.m_deviceArgSettings.end() && ((m_settings.m_deviceArgSettings[oname] != *nvalue) || force))
         {
             if (dev != 0)
             {
                 try
                 {
                     dev->writeSetting(oname.toStdString(), nvalue->toString().toStdString());
                     qDebug("SoapySDROutput::applySettings: device argument %s set to %s",
                             oname.toStdString().c_str(), nvalue->toString().toStdString().c_str());
                 }
                 catch (const std::exception &ex)
                 {
                     qCritical("SoapySDRInput::applySettings: cannot set device argument %s to %s: %s",
                             oname.toStdString().c_str(), nvalue->toString().toStdString().c_str(), ex.what());
                 }
             }
 
             m_settings.m_deviceArgSettings[oname] = *nvalue;
             deviceArgsChanged = true;
         }
     }
 
     if (forwardChangeOwnDSP)
     {
         int sampleRate = settings.m_devSampleRate/(1<<settings.m_log2Interp);
         DSPSignalNotification *notif = new DSPSignalNotification(sampleRate, settings.m_centerFrequency);
         m_deviceAPI->getDeviceEngineInputMessageQueue()->push(notif);
     }
 
     if (forwardChangeToBuddies)
     {
         // send to buddies
         const std::vector<DeviceAPI*>& sourceBuddies = m_deviceAPI->getSourceBuddies();
         const std::vector<DeviceAPI*>& sinkBuddies = m_deviceAPI->getSinkBuddies();
 
         for (const auto &itSource : sourceBuddies)
         {
             DeviceSoapySDRShared::MsgReportBuddyChange *report = DeviceSoapySDRShared::MsgReportBuddyChange::create(
                     settings.m_centerFrequency,
                     settings.m_LOppmTenths,
                     2,
                     settings.m_devSampleRate,
                     false);
             itSource->getSamplingDeviceInputMessageQueue()->push(report);
         }
 
         for (const auto &itSink : sinkBuddies)
         {
             DeviceSoapySDRShared::MsgReportBuddyChange *report = DeviceSoapySDRShared::MsgReportBuddyChange::create(
                     settings.m_centerFrequency,
                     settings.m_LOppmTenths,
                     2,
                     settings.m_devSampleRate,
                     false);
             itSink->getSamplingDeviceInputMessageQueue()->push(report);
         }
     }
 
     if (deviceArgsChanged)
     {
         // send to buddies
         const std::vector<DeviceAPI*>& sourceBuddies = m_deviceAPI->getSourceBuddies();
         const std::vector<DeviceAPI*>& sinkBuddies = m_deviceAPI->getSinkBuddies();
 
         for (const auto &itSource : sourceBuddies)
         {
             DeviceSoapySDRShared::MsgReportDeviceArgsChange *report = DeviceSoapySDRShared::MsgReportDeviceArgsChange::create(
                     settings.m_deviceArgSettings);
             itSource->getSamplingDeviceInputMessageQueue()->push(report);
         }
 
         for (const auto &itSink : sinkBuddies)
         {
             DeviceSoapySDRShared::MsgReportDeviceArgsChange *report = DeviceSoapySDRShared::MsgReportDeviceArgsChange::create(
                     settings.m_deviceArgSettings);
             itSink->getSamplingDeviceInputMessageQueue()->push(report);
         }
     }
 
     if (settings.m_useReverseAPI)
     {
         bool fullUpdate = ((m_settings.m_useReverseAPI != settings.m_useReverseAPI) && settings.m_useReverseAPI) ||
                 (m_settings.m_reverseAPIAddress != settings.m_reverseAPIAddress) ||
                 (m_settings.m_reverseAPIPort != settings.m_reverseAPIPort) ||
                 (m_settings.m_reverseAPIDeviceIndex != settings.m_reverseAPIDeviceIndex);
 
         if (fullUpdate || force) {
             webapiReverseSendSettings(reverseAPIKeys, settings, true);
         } else if (reverseAPIKeys.size() != 0) {
             webapiReverseSendSettings(reverseAPIKeys, settings, false);
         }
     }
 
     m_settings = settings;
 
     if (globalGainChanged || individualGainsChanged)
     {
         if (dev) {
             updateGains(dev, requestedChannel, m_settings);
         }
 
         if (getMessageQueueToGUI())
         {
             MsgReportGainChange *report = MsgReportGainChange::create(m_settings, globalGainChanged, individualGainsChanged);
             getMessageQueueToGUI()->push(report);
         }
     }
 
     qDebug() << "SoapySDROutput::applySettings: "
             << " m_transverterMode: " << m_settings.m_transverterMode
             << " m_transverterDeltaFrequency: " << m_settings.m_transverterDeltaFrequency
             << " m_centerFrequency: " << m_settings.m_centerFrequency << " Hz"
             << " m_LOppmTenths: " << m_settings.m_LOppmTenths
             << " m_log2Interp: " << m_settings.m_log2Interp
             << " m_devSampleRate: " << m_settings.m_devSampleRate
             << " m_bandwidth: " << m_settings.m_bandwidth
             << " m_globalGain: " << m_settings.m_globalGain
             << " force: " << force;
 
     QMap<QString, double>::const_iterator doubleIt = m_settings.m_individualGains.begin();
 
     for(; doubleIt != m_settings.m_individualGains.end(); ++doubleIt) {
         qDebug("SoapySDROutput::applySettings: m_individualGains[%s]: %lf", doubleIt.key().toStdString().c_str(), doubleIt.value());
     }
 
     doubleIt = m_settings.m_tunableElements.begin();
 
     for(; doubleIt != m_settings.m_tunableElements.end(); ++doubleIt) {
         qDebug("SoapySDROutput::applySettings: m_tunableElements[%s]: %lf", doubleIt.key().toStdString().c_str(), doubleIt.value());
     }
 
     QMap<QString, QVariant>::const_iterator varIt = m_settings.m_deviceArgSettings.begin();
 
     for(; varIt != m_settings.m_deviceArgSettings.end(); ++varIt)
     {
         qDebug("SoapySDROutput::applySettings: m_deviceArgSettings[%s] (type %d): %s",
             varIt.key().toStdString().c_str(),
             (int) varIt.value().type(), // bool: 1, int: 2, double: 6, string: 10 (http://doc.qt.io/archives/qt-4.8/qvariant.html)
             varIt.value().toString().toStdString().c_str());
     }
 
     varIt = m_settings.m_streamArgSettings.begin();
 
     for(; varIt != m_settings.m_streamArgSettings.end(); ++varIt)
     {
         qDebug("SoapySDROutput::applySettings: m_streamArgSettings[%s] (type %d): %s",
             varIt.key().toStdString().c_str(),
             (int) varIt.value().type(),
             varIt.value().toString().toStdString().c_str());
     }
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ closeDevice()

void SoapySDROutput::closeDevice ( )

private

Definition at line 151 of file soapysdroutput.cpp.

References DeviceSoapySDR::closeSoapySdr(), DeviceAPI::getSinkBuddies(), DeviceAPI::getSourceBuddies(), DeviceSoapySDR::instance(), DeviceSoapySDRShared::m_channel, DeviceSoapySDRShared::m_device, m_deviceAPI, m_deviceShared, m_running, DeviceSoapySDRShared::m_sink, m_thread, moveThreadToBuddy(), and stop().

Referenced by ~SoapySDROutput().

 {
     if (m_deviceShared.m_device == 0) { // was never open
         return;
     }
 
     if (m_running) {
         stop();
     }
 
     if (m_thread) { // stills own the thread => transfer to a buddy
         moveThreadToBuddy();
     }
 
     m_deviceShared.m_channel = -1; // publicly release channel
     m_deviceShared.m_sink = 0;
 
     // No buddies so effectively close the device
 
     if ((m_deviceAPI->getSinkBuddies().size() == 0) && (m_deviceAPI->getSourceBuddies().size() == 0))
     {
         DeviceSoapySDR& deviceSoapySDR = DeviceSoapySDR::instance();
         deviceSoapySDR.closeSoapySdr(m_deviceShared.m_device);
         m_deviceShared.m_device = 0;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ deserialize()

bool SoapySDROutput::deserialize ( const QByteArray & data )

virtual

Implements DeviceSampleSink.

Definition at line 644 of file soapysdroutput.cpp.

References SoapySDROutput::MsgConfigureSoapySDROutput::create(), SoapySDROutputSettings::deserialize(), DeviceSampleSink::m_guiMessageQueue, DeviceSampleSink::m_inputMessageQueue, m_settings, MessageQueue::push(), and SoapySDROutputSettings::resetToDefaults().

 {
     bool success = true;
 
     if (!m_settings.deserialize(data))
     {
         m_settings.resetToDefaults();
         success = false;
     }
 
     MsgConfigureSoapySDROutput* message = MsgConfigureSoapySDROutput::create(m_settings, true);
     m_inputMessageQueue.push(message);
 
     if (m_guiMessageQueue)
     {
         MsgConfigureSoapySDROutput* messageToGUI = MsgConfigureSoapySDROutput::create(m_settings, true);
         m_guiMessageQueue->push(messageToGUI);
     }
 
     return success;
 }

Here is the call graph for this function:

◆ destroy()

void SoapySDROutput::destroy ( )

virtual

Implements DeviceSampleSink.

Definition at line 70 of file soapysdroutput.cpp.

 {
     delete this;
 }

◆ findThread()

SoapySDROutputThread * SoapySDROutput::findThread ( )

private

Definition at line 362 of file soapysdroutput.cpp.

References DeviceAPI::getSinkBuddies(), getThread(), m_deviceAPI, and m_thread.

Referenced by applySettings(), start(), and stop().

 {
     if (m_thread == 0) // this does not own the thread
     {
         SoapySDROutputThread *soapySDROutputThread = 0;
 
         // find a buddy that has allocated the thread
         const std::vector<DeviceAPI*>& sinkBuddies = m_deviceAPI->getSinkBuddies();
         std::vector<DeviceAPI*>::const_iterator it = sinkBuddies.begin();
 
         for (; it != sinkBuddies.end(); ++it)
         {
             SoapySDROutput *buddySink = ((DeviceSoapySDRShared*) (*it)->getBuddySharedPtr())->m_sink;
 
             if (buddySink)
             {
                 soapySDROutputThread = buddySink->getThread();
 
                 if (soapySDROutputThread) {
                     break;
                 }
             }
         }
 
         return soapySDROutputThread;
     }
     else
     {
         return m_thread; // own thread
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getAntennas()

const std::vector< std::string > & SoapySDROutput::getAntennas ( )

Definition at line 234 of file soapysdroutput.cpp.

References DeviceSoapySDRParams::getTxChannelSettings(), DeviceSoapySDRParams::ChannelSettings::m_antennas, DeviceSoapySDRShared::m_channel, DeviceSoapySDRShared::m_deviceParams, and m_deviceShared.

Referenced by SoapySDROutputGui::SoapySDROutputGui().

 {
     const DeviceSoapySDRParams::ChannelSettings* channelSettings = m_deviceShared.m_deviceParams->getTxChannelSettings(m_deviceShared.m_channel);
     return channelSettings->m_antennas;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getBandwidthRanges()

const SoapySDR::RangeList & SoapySDROutput::getBandwidthRanges ( )

Definition at line 240 of file soapysdroutput.cpp.

References DeviceSoapySDRParams::getTxChannelSettings(), DeviceSoapySDRParams::ChannelSettings::m_bandwidthsRanges, DeviceSoapySDRShared::m_channel, DeviceSoapySDRShared::m_deviceParams, and m_deviceShared.

Referenced by SoapySDROutputGui::SoapySDROutputGui().

 {
     const DeviceSoapySDRParams::ChannelSettings* channelSettings = m_deviceShared.m_deviceParams->getTxChannelSettings(m_deviceShared.m_channel);
     return channelSettings->m_bandwidthsRanges;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getCenterFrequency()

quint64 SoapySDROutput::getCenterFrequency ( ) const

virtual

Center frequency exposed by the sink.

Implements DeviceSampleSink.

Definition at line 677 of file soapysdroutput.cpp.

References SoapySDROutputSettings::m_centerFrequency, and m_settings.

 {
     return m_settings.m_centerFrequency;
 }

◆ getDeviceArgInfoList()

const SoapySDR::ArgInfoList & SoapySDROutput::getDeviceArgInfoList ( )

Definition at line 258 of file soapysdroutput.cpp.

References DeviceSoapySDRParams::getDeviceArgs(), DeviceSoapySDRShared::m_deviceParams, and m_deviceShared.

Referenced by SoapySDROutputGui::SoapySDROutputGui().

 {
     return  m_deviceShared.m_deviceParams->getDeviceArgs();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getDeviceDescription()

const QString & SoapySDROutput::getDeviceDescription ( ) const

virtual

Implements DeviceSampleSink.

Definition at line 666 of file soapysdroutput.cpp.

References m_deviceDescription.

 {
     return m_deviceDescription;
 }

◆ getFrequencyRange()

void SoapySDROutput::getFrequencyRange	(	uint64_t &	min,
		uint64_t &	max
	)

Definition at line 178 of file soapysdroutput.cpp.

References DeviceSoapySDRParams::getTxChannelSettings(), DeviceSoapySDRShared::m_channel, DeviceSoapySDRShared::m_deviceParams, m_deviceShared, DeviceSoapySDRParams::ChannelSettings::m_frequencySettings, and DeviceSoapySDRParams::FrequencySetting::m_ranges.

Referenced by SoapySDROutputGui::SoapySDROutputGui(), and SoapySDROutputGui::updateFrequencyLimits().

 {
     const DeviceSoapySDRParams::ChannelSettings* channelSettings = m_deviceShared.m_deviceParams->getTxChannelSettings(m_deviceShared.m_channel);
 
     if (channelSettings && (channelSettings->m_frequencySettings.size() > 0))
     {
         DeviceSoapySDRParams::FrequencySetting freqSettings = channelSettings->m_frequencySettings[0];
         SoapySDR::RangeList rangeList = freqSettings.m_ranges;
 
         if (rangeList.size() > 0)
         {
             SoapySDR::Range range = rangeList[0];
             min = range.minimum();
             max = range.maximum();
         }
         else
         {
             min = 0;
             max = 0;
         }
     }
     else
     {
         min = 0;
         max = 0;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getGlobalGainRange()

void SoapySDROutput::getGlobalGainRange	(	int &	min,
		int &	max
	)

Definition at line 206 of file soapysdroutput.cpp.

References DeviceSoapySDRParams::getTxChannelSettings(), DeviceSoapySDRShared::m_channel, DeviceSoapySDRShared::m_deviceParams, m_deviceShared, and DeviceSoapySDRParams::ChannelSettings::m_gainRange.

Referenced by SoapySDROutputGui::createGlobalGainControl().

 {
     const DeviceSoapySDRParams::ChannelSettings* channelSettings = m_deviceShared.m_deviceParams->getTxChannelSettings(m_deviceShared.m_channel);
 
     if (channelSettings)
     {
         min = channelSettings->m_gainRange.minimum();
         max = channelSettings->m_gainRange.maximum();
     }
     else
     {
         min = 0;
         max = 0;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getIndividualGainsRanges()

const std::vector< DeviceSoapySDRParams::GainSetting > & SoapySDROutput::getIndividualGainsRanges ( )

Definition at line 252 of file soapysdroutput.cpp.

References DeviceSoapySDRParams::getTxChannelSettings(), DeviceSoapySDRShared::m_channel, DeviceSoapySDRShared::m_deviceParams, m_deviceShared, and DeviceSoapySDRParams::ChannelSettings::m_gainSettings.

Referenced by SoapySDROutputGui::SoapySDROutputGui().

 {
     const DeviceSoapySDRParams::ChannelSettings* channelSettings = m_deviceShared.m_deviceParams->getTxChannelSettings(m_deviceShared.m_channel);
     return channelSettings->m_gainSettings;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getRateRanges()

const SoapySDR::RangeList & SoapySDROutput::getRateRanges ( )

Definition at line 228 of file soapysdroutput.cpp.

References DeviceSoapySDRParams::getTxChannelSettings(), DeviceSoapySDRShared::m_channel, DeviceSoapySDRShared::m_deviceParams, m_deviceShared, and DeviceSoapySDRParams::ChannelSettings::m_ratesRanges.

Referenced by SoapySDROutputGui::SoapySDROutputGui().

 {
     const DeviceSoapySDRParams::ChannelSettings* channelSettings = m_deviceShared.m_deviceParams->getTxChannelSettings(m_deviceShared.m_channel);
     return channelSettings->m_ratesRanges;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getSampleRate()

int SoapySDROutput::getSampleRate ( ) const

virtual

Sample rate exposed by the sink.

Implements DeviceSampleSink.

Definition at line 671 of file soapysdroutput.cpp.

References SoapySDROutputSettings::m_devSampleRate, SoapySDROutputSettings::m_log2Interp, and m_settings.

 {
     int rate = m_settings.m_devSampleRate;
     return (rate / (1<<m_settings.m_log2Interp));
 }

◆ getStreamArgInfoList()

const SoapySDR::ArgInfoList & SoapySDROutput::getStreamArgInfoList ( )

Definition at line 296 of file soapysdroutput.cpp.

References DeviceSoapySDRParams::getTxChannelSettings(), DeviceSoapySDRShared::m_channel, DeviceSoapySDRShared::m_deviceParams, m_deviceShared, and DeviceSoapySDRParams::ChannelSettings::m_streamSettingsArgs.

Referenced by SoapySDROutputGui::SoapySDROutputGui().

 {
     const DeviceSoapySDRParams::ChannelSettings* channelSettings = m_deviceShared.m_deviceParams->getTxChannelSettings(m_deviceShared.m_channel);
     return channelSettings->m_streamSettingsArgs;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getThread()

SoapySDROutputThread* SoapySDROutput::getThread ( )

inline

Definition at line 127 of file soapysdroutput.h.

Referenced by findThread().

127 { return m_thread; }

SoapySDROutput::m_thread

SoapySDROutputThread * m_thread

Definition: soapysdroutput.h:190

Here is the caller graph for this function:

◆ getTunableElements()

const std::vector< DeviceSoapySDRParams::FrequencySetting > & SoapySDROutput::getTunableElements ( )

Definition at line 246 of file soapysdroutput.cpp.

References DeviceSoapySDRParams::getTxChannelSettings(), DeviceSoapySDRShared::m_channel, DeviceSoapySDRShared::m_deviceParams, m_deviceShared, and DeviceSoapySDRParams::ChannelSettings::m_frequencySettings.

Referenced by SoapySDROutputGui::SoapySDROutputGui().

 {
     const DeviceSoapySDRParams::ChannelSettings* channelSettings = m_deviceShared.m_deviceParams->getTxChannelSettings(m_deviceShared.m_channel);
     return channelSettings->m_frequencySettings;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handleMessage()

bool SoapySDROutput::handleMessage ( const Message & message )

virtual

Implements DeviceSampleSink.

Definition at line 756 of file soapysdroutput.cpp.

References applySettings(), SoapySDROutput::MsgConfigureSoapySDROutput::create(), DeviceSoapySDRShared::MsgReportDeviceArgsChange::create(), DeviceSoapySDRShared::MsgReportDeviceArgsChange::getDeviceArgSettings(), DeviceAPI::getDeviceItemIndex(), SoapySDROutput::MsgConfigureSoapySDROutput::getForce(), DeviceSampleSink::getMessageQueueToGUI(), SoapySDROutput::MsgConfigureSoapySDROutput::getSettings(), SoapySDROutput::MsgStartStop::getStartStop(), DeviceSoapySDRParams::getTxChannelMainTunableElementName(), DeviceAPI::initDeviceEngine(), SoapySDROutputSettings::m_bandwidth, SoapySDROutputSettings::m_centerFrequency, DeviceSoapySDRShared::m_device, m_deviceAPI, SoapySDROutputSettings::m_deviceArgSettings, DeviceSoapySDRShared::m_deviceParams, m_deviceShared, SoapySDROutputSettings::m_devSampleRate, m_settings, SoapySDROutputSettings::m_useReverseAPI, Message::match(), MessageQueue::push(), DeviceAPI::startDeviceEngine(), DeviceAPI::stopDeviceEngine(), and webapiReverseSendStartStop().

 {
     if (MsgConfigureSoapySDROutput::match(message))
     {
         MsgConfigureSoapySDROutput& conf = (MsgConfigureSoapySDROutput&) message;
         qDebug() << "SoapySDROutput::handleMessage: MsgConfigureSoapySDROutput";
 
         if (!applySettings(conf.getSettings(), conf.getForce())) {
             qDebug("SoapySDROutput::handleMessage: MsgConfigureSoapySDROutput config error");
         }
 
         return true;
     }
     else if (MsgStartStop::match(message))
     {
         MsgStartStop& cmd = (MsgStartStop&) message;
         qDebug() << "SoapySDROutput::handleMessage: MsgStartStop: " << (cmd.getStartStop() ? "start" : "stop");
 
         if (cmd.getStartStop())
         {
             if (m_deviceAPI->initDeviceEngine())
             {
                 m_deviceAPI->startDeviceEngine();
             }
         }
         else
         {
             m_deviceAPI->stopDeviceEngine();
         }
 
         if (m_settings.m_useReverseAPI) {
             webapiReverseSendStartStop(cmd.getStartStop());
         }
 
         return true;
     }
     else if (DeviceSoapySDRShared::MsgReportBuddyChange::match(message))
     {
         int requestedChannel = m_deviceAPI->getDeviceItemIndex();
         //DeviceSoapySDRShared::MsgReportBuddyChange& report = (DeviceSoapySDRShared::MsgReportBuddyChange&) message;
         SoapySDROutputSettings settings = m_settings;
         //bool fromRxBuddy = report.getRxElseTx();
 
         double centerFrequency = m_deviceShared.m_device->getFrequency(
                 SOAPY_SDR_TX,
                 requestedChannel,
                 m_deviceShared.m_deviceParams->getTxChannelMainTunableElementName(requestedChannel));
 
         settings.m_centerFrequency = round(centerFrequency/1000.0) * 1000;
         settings.m_devSampleRate = round(m_deviceShared.m_device->getSampleRate(SOAPY_SDR_TX, requestedChannel));
         settings.m_bandwidth = round(m_deviceShared.m_device->getBandwidth(SOAPY_SDR_TX, requestedChannel));
 
         //SoapySDROutputThread *outputThread = findThread();
 
         m_settings = settings;
 
         // propagate settings to GUI if any
         if (getMessageQueueToGUI())
         {
             MsgConfigureSoapySDROutput *reportToGUI = MsgConfigureSoapySDROutput::create(m_settings, false);
             getMessageQueueToGUI()->push(reportToGUI);
         }
 
         return true;
     }
     else if (DeviceSoapySDRShared::MsgReportDeviceArgsChange::match(message))
     {
         DeviceSoapySDRShared::MsgReportDeviceArgsChange& report = (DeviceSoapySDRShared::MsgReportDeviceArgsChange&) message;
         QMap<QString, QVariant> deviceArgSettings = report.getDeviceArgSettings();
 
         for (const auto &oname : m_settings.m_deviceArgSettings.keys())
         {
             auto nvalue = deviceArgSettings.find(oname);
 
             if (nvalue != deviceArgSettings.end() && (m_settings.m_deviceArgSettings[oname] != *nvalue))
             {
                 m_settings.m_deviceArgSettings[oname] = *nvalue;
                 qDebug("SoapySDROutput::handleMessage: MsgReportDeviceArgsChange: device argument %s set to %s",
                         oname.toStdString().c_str(), nvalue->toString().toStdString().c_str());
             }
         }
 
         // propagate settings to GUI if any
         if (getMessageQueueToGUI())
         {
             DeviceSoapySDRShared::MsgReportDeviceArgsChange *reportToGUI = DeviceSoapySDRShared::MsgReportDeviceArgsChange::create(
                     m_settings.m_deviceArgSettings);
             getMessageQueueToGUI()->push(reportToGUI);
         }
 
         return true;
     }
     else
     {
         return false;
     }
 }

Here is the call graph for this function:

◆ hasDCAutoCorrection()

bool SoapySDROutput::hasDCAutoCorrection ( )

Definition at line 339 of file soapysdroutput.cpp.

References DeviceSoapySDRParams::getTxChannelSettings(), DeviceSoapySDRShared::m_channel, DeviceSoapySDRShared::m_deviceParams, m_deviceShared, and DeviceSoapySDRParams::ChannelSettings::m_hasDCAutoCorrection.

Referenced by applySettings(), and SoapySDROutputGui::createCorrectionsControl().

 {
     const DeviceSoapySDRParams::ChannelSettings* channelSettings = m_deviceShared.m_deviceParams->getTxChannelSettings(m_deviceShared.m_channel);
     return channelSettings->m_hasDCAutoCorrection;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ hasDCCorrectionValue()

bool SoapySDROutput::hasDCCorrectionValue ( )

Definition at line 345 of file soapysdroutput.cpp.

References DeviceSoapySDRParams::getTxChannelSettings(), DeviceSoapySDRShared::m_channel, DeviceSoapySDRShared::m_deviceParams, m_deviceShared, and DeviceSoapySDRParams::ChannelSettings::m_hasDCOffsetValue.

Referenced by applySettings(), and SoapySDROutputGui::createCorrectionsControl().

 {
     const DeviceSoapySDRParams::ChannelSettings* channelSettings = m_deviceShared.m_deviceParams->getTxChannelSettings(m_deviceShared.m_channel);
     return channelSettings->m_hasDCOffsetValue;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ hasIQAutoCorrection()

bool SoapySDROutput::hasIQAutoCorrection ( )

inline

Definition at line 158 of file soapysdroutput.h.

Referenced by SoapySDROutputGui::createCorrectionsControl().

158 { return false; } // not in SoapySDR interface

Here is the caller graph for this function:

◆ hasIQCorrectionValue()

bool SoapySDROutput::hasIQCorrectionValue ( )

Definition at line 351 of file soapysdroutput.cpp.

References DeviceSoapySDRParams::getTxChannelSettings(), DeviceSoapySDRShared::m_channel, DeviceSoapySDRShared::m_deviceParams, m_deviceShared, and DeviceSoapySDRParams::ChannelSettings::m_hasIQBalanceValue.

Referenced by applySettings(), and SoapySDROutputGui::createCorrectionsControl().

 {
     const DeviceSoapySDRParams::ChannelSettings* channelSettings = m_deviceShared.m_deviceParams->getTxChannelSettings(m_deviceShared.m_channel);
     return channelSettings->m_hasIQBalanceValue;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init()

void SoapySDROutput::init ( )

virtual

initializations to be done when all collaborating objects are created and possibly connected

Implements DeviceSampleSink.

Definition at line 357 of file soapysdroutput.cpp.

References applySettings(), and m_settings.

 {
     applySettings(m_settings, true);
 }

Here is the call graph for this function:

◆ initDeviceArgSettings()

void SoapySDROutput::initDeviceArgSettings ( SoapySDROutputSettings & settings )

Definition at line 321 of file soapysdroutput.cpp.

References DeviceSoapySDRParams::getDeviceArgs(), SoapySDROutputSettings::m_deviceArgSettings, DeviceSoapySDRShared::m_deviceParams, and m_deviceShared.

Referenced by SoapySDROutputGui::SoapySDROutputGui().

 {
     settings.m_deviceArgSettings.clear();
 
     for (const auto &it : m_deviceShared.m_deviceParams->getDeviceArgs())
     {
         if (it.type == SoapySDR::ArgInfo::BOOL) {
             settings.m_deviceArgSettings[QString(it.key.c_str())] = QVariant(it.value == "true");
         } else if (it.type == SoapySDR::ArgInfo::INT) {
             settings.m_deviceArgSettings[QString(it.key.c_str())] = QVariant(atoi(it.value.c_str()));
         } else if (it.type == SoapySDR::ArgInfo::FLOAT) {
             settings.m_deviceArgSettings[QString(it.key.c_str())] = QVariant(atof(it.value.c_str()));
         } else if (it.type == SoapySDR::ArgInfo::STRING) {
             settings.m_deviceArgSettings[QString(it.key.c_str())] = QVariant(it.value.c_str());
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ initGainSettings()

void SoapySDROutput::initGainSettings ( SoapySDROutputSettings & settings )

Definition at line 263 of file soapysdroutput.cpp.

References DeviceSoapySDRParams::getTxChannelSettings(), DeviceSoapySDRShared::m_channel, DeviceSoapySDRShared::m_device, DeviceSoapySDRShared::m_deviceParams, m_deviceShared, DeviceSoapySDRParams::ChannelSettings::m_gainSettings, SoapySDROutputSettings::m_globalGain, SoapySDROutputSettings::m_individualGains, and updateGains().

Referenced by SoapySDROutputGui::SoapySDROutputGui().

 {
     const DeviceSoapySDRParams::ChannelSettings* channelSettings = m_deviceShared.m_deviceParams->getTxChannelSettings(m_deviceShared.m_channel);
     settings.m_individualGains.clear();
     settings.m_globalGain = 0;
 
     for (const auto &it : channelSettings->m_gainSettings) {
         settings.m_individualGains[QString(it.m_name.c_str())] = 0.0;
     }
 
     updateGains(m_deviceShared.m_device, m_deviceShared.m_channel, settings);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ initStreamArgSettings()

void SoapySDROutput::initStreamArgSettings ( SoapySDROutputSettings & settings )

Definition at line 302 of file soapysdroutput.cpp.

References DeviceSoapySDRParams::getTxChannelSettings(), DeviceSoapySDRShared::m_channel, DeviceSoapySDRShared::m_deviceParams, m_deviceShared, SoapySDROutputSettings::m_streamArgSettings, and DeviceSoapySDRParams::ChannelSettings::m_streamSettingsArgs.

Referenced by SoapySDROutputGui::SoapySDROutputGui().

 {
     const DeviceSoapySDRParams::ChannelSettings* channelSettings = m_deviceShared.m_deviceParams->getTxChannelSettings(m_deviceShared.m_channel);
     settings.m_streamArgSettings.clear();
 
     for (const auto &it : channelSettings->m_streamSettingsArgs)
     {
         if (it.type == SoapySDR::ArgInfo::BOOL) {
             settings.m_streamArgSettings[QString(it.key.c_str())] = QVariant(it.value == "true");
         } else if (it.type == SoapySDR::ArgInfo::INT) {
             settings.m_streamArgSettings[QString(it.key.c_str())] = QVariant(atoi(it.value.c_str()));
         } else if (it.type == SoapySDR::ArgInfo::FLOAT) {
             settings.m_streamArgSettings[QString(it.key.c_str())] = QVariant(atof(it.value.c_str()));
         } else if (it.type == SoapySDR::ArgInfo::STRING) {
             settings.m_streamArgSettings[QString(it.key.c_str())] = QVariant(it.value.c_str());
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ initTunableElementsSettings()

void SoapySDROutput::initTunableElementsSettings ( SoapySDROutputSettings & settings )

Definition at line 276 of file soapysdroutput.cpp.

References DeviceSoapySDRParams::getTxChannelSettings(), DeviceSoapySDRShared::m_channel, DeviceSoapySDRShared::m_device, DeviceSoapySDRShared::m_deviceParams, m_deviceShared, DeviceSoapySDRParams::ChannelSettings::m_frequencySettings, SoapySDROutputSettings::m_tunableElements, and updateTunableElements().

Referenced by SoapySDROutputGui::SoapySDROutputGui().

 {
     const DeviceSoapySDRParams::ChannelSettings* channelSettings = m_deviceShared.m_deviceParams->getTxChannelSettings(m_deviceShared.m_channel);
     settings.m_tunableElements.clear();
     bool first = true;
 
     for (const auto &it : channelSettings->m_frequencySettings)
     {
         if (first)
         {
             first = false;
             continue;
         }
 
         settings.m_tunableElements[QString(it.m_name.c_str())] = 0.0;
     }
 
     updateTunableElements(m_deviceShared.m_device, m_deviceShared.m_channel, settings);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isAGCSupported()

bool SoapySDROutput::isAGCSupported ( )

Definition at line 222 of file soapysdroutput.cpp.

References DeviceSoapySDRParams::getTxChannelSettings(), DeviceSoapySDRShared::m_channel, DeviceSoapySDRShared::m_deviceParams, m_deviceShared, and DeviceSoapySDRParams::ChannelSettings::m_hasAGC.

Referenced by SoapySDROutputGui::createGlobalGainControl().

 {
     const DeviceSoapySDRParams::ChannelSettings* channelSettings = m_deviceShared.m_deviceParams->getTxChannelSettings(m_deviceShared.m_channel);
     return channelSettings->m_hasAGC;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ moveThreadToBuddy()

void SoapySDROutput::moveThreadToBuddy ( )

private

Definition at line 394 of file soapysdroutput.cpp.

References DeviceAPI::getSinkBuddies(), m_deviceAPI, m_thread, and setThread().

Referenced by closeDevice().

 {
     const std::vector<DeviceAPI*>& sinkBuddies = m_deviceAPI->getSinkBuddies();
     std::vector<DeviceAPI*>::const_iterator it = sinkBuddies.begin();
 
     for (; it != sinkBuddies.end(); ++it)
     {
         SoapySDROutput *buddySink = ((DeviceSoapySDRShared*) (*it)->getBuddySharedPtr())->m_sink;
 
         if (buddySink)
         {
             buddySink->setThread(m_thread);
             m_thread = 0;  // zero for others
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ networkManagerFinished

void SoapySDROutput::networkManagerFinished ( QNetworkReply * reply )

privateslot

Definition at line 1929 of file soapysdroutput.cpp.

Referenced by ~SoapySDROutput().

 {
     QNetworkReply::NetworkError replyError = reply->error();
 
     if (replyError)
     {
         qWarning() << "SoapySDROutput::networkManagerFinished:"
                 << " error(" << (int) replyError
                 << "): " << replyError
                 << ": " << reply->errorString();
         return;
     }
 
     QString answer = reply->readAll();
     answer.chop(1); // remove last \n
     qDebug("SoapySDROutput::networkManagerFinished: reply:\n%s", answer.toStdString().c_str());
 }

Here is the caller graph for this function:

◆ openDevice()

bool SoapySDROutput::openDevice ( )

private

Definition at line 75 of file soapysdroutput.cpp.

References DeviceAPI::getBuddySharedPtr(), DeviceAPI::getDeviceItemIndex(), DeviceAPI::getHardwareUserArguments(), DeviceAPI::getSamplingDeviceSequence(), DeviceAPI::getSinkBuddies(), DeviceAPI::getSourceBuddies(), DeviceSoapySDR::instance(), DeviceSoapySDRShared::m_channel, DeviceSoapySDRShared::m_device, m_deviceAPI, DeviceSoapySDRShared::m_deviceParams, m_deviceShared, SoapySDROutputSettings::m_devSampleRate, SoapySDROutputSettings::m_log2Interp, DeviceSampleSink::m_sampleSourceFifo, m_settings, DeviceSoapySDRShared::m_sink, DeviceSoapySDR::openSoapySDR(), SampleSourceFifo::resize(), and DeviceAPI::setBuddySharedPtr().

 {
     m_sampleSourceFifo.resize(m_settings.m_devSampleRate/(1<<(m_settings.m_log2Interp <= 4 ? m_settings.m_log2Interp : 4)));
 
     // look for Tx buddies and get reference to the device object
     if (m_deviceAPI->getSinkBuddies().size() > 0) // look sink sibling first
     {
         qDebug("SoapySDROutput::openDevice: look in Tx buddies");
 
         DeviceAPI *sinkBuddy = m_deviceAPI->getSinkBuddies()[0];
         DeviceSoapySDRShared *deviceSoapySDRShared = (DeviceSoapySDRShared*) sinkBuddy->getBuddySharedPtr();
 
         if (deviceSoapySDRShared == 0)
         {
             qCritical("SoapySDROutput::openDevice: the sink buddy shared pointer is null");
             return false;
         }
 
         SoapySDR::Device *device = deviceSoapySDRShared->m_device;
 
         if (device == 0)
         {
             qCritical("SoapySDROutput::openDevice: cannot get device pointer from Tx buddy");
             return false;
         }
 
         m_deviceShared.m_device = device;
         m_deviceShared.m_deviceParams = deviceSoapySDRShared->m_deviceParams;
     }
     // look for Rx buddies and get reference to the device object
     else if (m_deviceAPI->getSourceBuddies().size() > 0) // then source
     {
         qDebug("SoapySDROutput::openDevice: look in Rx buddies");
 
         DeviceAPI *sourceBuddy = m_deviceAPI->getSourceBuddies()[0];
         DeviceSoapySDRShared *deviceSoapySDRShared = (DeviceSoapySDRShared*) sourceBuddy->getBuddySharedPtr();
 
         if (deviceSoapySDRShared == 0)
         {
             qCritical("SoapySDROutput::openDevice: the source buddy shared pointer is null");
             return false;
         }
 
         SoapySDR::Device *device = deviceSoapySDRShared->m_device;
 
         if (device == 0)
         {
             qCritical("SoapySDROutput::openDevice: cannot get device pointer from Rx buddy");
             return false;
         }
 
         m_deviceShared.m_device = device;
         m_deviceShared.m_deviceParams = deviceSoapySDRShared->m_deviceParams;
     }
     // There are no buddies then create the first BladeRF2 device
     else
     {
         qDebug("SoapySDROutput::openDevice: open device here");
         DeviceSoapySDR& deviceSoapySDR = DeviceSoapySDR::instance();
         m_deviceShared.m_device = deviceSoapySDR.openSoapySDR(m_deviceAPI->getSamplingDeviceSequence(), m_deviceAPI->getHardwareUserArguments());
 
         if (!m_deviceShared.m_device)
         {
             qCritical("SoapySDROutput::openDevice: cannot open SoapySDR device");
             return false;
         }
 
         m_deviceShared.m_deviceParams = new DeviceSoapySDRParams(m_deviceShared.m_device);
     }
 
     m_deviceShared.m_channel = m_deviceAPI->getDeviceItemIndex(); // publicly allocate channel
     m_deviceShared.m_sink = this;
     m_deviceAPI->setBuddySharedPtr(&m_deviceShared); // propagate common parameters to API
     return true;
 }

Here is the call graph for this function:

◆ serialize()

QByteArray SoapySDROutput::serialize ( ) const

virtual

Implements DeviceSampleSink.

Definition at line 639 of file soapysdroutput.cpp.

References m_settings, and SoapySDROutputSettings::serialize().

 {
     return m_settings.serialize();
 }

Here is the call graph for this function:

◆ setCenterFrequency()

void SoapySDROutput::setCenterFrequency ( qint64 centerFrequency )

virtual

Implements DeviceSampleSink.

Definition at line 682 of file soapysdroutput.cpp.

References SoapySDROutput::MsgConfigureSoapySDROutput::create(), SoapySDROutputSettings::m_centerFrequency, DeviceSampleSink::m_guiMessageQueue, DeviceSampleSink::m_inputMessageQueue, m_settings, and MessageQueue::push().

 {
     SoapySDROutputSettings settings = m_settings;
     settings.m_centerFrequency = centerFrequency;
 
     MsgConfigureSoapySDROutput* message = MsgConfigureSoapySDROutput::create(settings, false);
     m_inputMessageQueue.push(message);
 
     if (m_guiMessageQueue)
     {
         MsgConfigureSoapySDROutput* messageToGUI = MsgConfigureSoapySDROutput::create(settings, false);
         m_guiMessageQueue->push(messageToGUI);
     }
 }

Here is the call graph for this function:

◆ setDeviceCenterFrequency()

bool SoapySDROutput::setDeviceCenterFrequency	(	SoapySDR::Device *	dev,
		int	requestedChannel,
		quint64	freq_hz,
		int	loPpmTenths
	)

private

Definition at line 697 of file soapysdroutput.cpp.

References DeviceSoapySDRParams::getTxChannelMainTunableElementName(), DeviceSoapySDRShared::m_deviceParams, and m_deviceShared.

Referenced by applySettings().

 {
     qint64 df = ((qint64)freq_hz * loPpmTenths) / 10000000LL;
     freq_hz += df;
 
     try
     {
         dev->setFrequency(SOAPY_SDR_TX,
                 requestedChannel,
                 m_deviceShared.m_deviceParams->getTxChannelMainTunableElementName(requestedChannel),
                 freq_hz);
         qDebug("SoapySDROutput::setDeviceCenterFrequency: setFrequency(%llu)", freq_hz);
         return true;
     }
     catch (const std::exception &ex)
     {
         qCritical("SoapySDROutput::applySettings: could not set frequency: %llu: %s", freq_hz, ex.what());
         return false;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setMessageQueueToGUI()

virtual void SoapySDROutput::setMessageQueueToGUI ( MessageQueue * queue )

inlinevirtual

Implements DeviceSampleSink.

Definition at line 133 of file soapysdroutput.h.

Referenced by SoapySDROutputGui::SoapySDROutputGui().

133 { m_guiMessageQueue = queue; }

DeviceSampleSink::m_guiMessageQueue

MessageQueue * m_guiMessageQueue

Input message queue to the GUI.

Definition: devicesamplesink.h:146

Here is the caller graph for this function:

◆ setSampleRate()

virtual void SoapySDROutput::setSampleRate ( int sampleRate )

inlinevirtual

For when the sink sample rate is set externally.

Implements DeviceSampleSink.

Definition at line 136 of file soapysdroutput.h.

References leansdr::max(), and leansdr::min().

136 { (void) sampleRate; }

Here is the call graph for this function:

◆ setThread()

void SoapySDROutput::setThread ( SoapySDROutputThread * thread )

inline

Definition at line 128 of file soapysdroutput.h.

Referenced by moveThreadToBuddy().

128 { m_thread = thread; }

SoapySDROutput::m_thread

SoapySDROutputThread * m_thread

Definition: soapysdroutput.h:190

Here is the caller graph for this function:

◆ start()

bool SoapySDROutput::start ( )

virtual

Implements DeviceSampleSink.

Definition at line 411 of file soapysdroutput.cpp.

References findThread(), DeviceAPI::getDeviceItemIndex(), SoapySDROutputThread::getFifo(), SoapySDROutputThread::getLog2Interpolation(), SoapySDROutputThread::getNbChannels(), DeviceAPI::getSinkBuddies(), i, DeviceSoapySDRShared::m_device, m_deviceAPI, m_deviceShared, SoapySDROutputSettings::m_devSampleRate, SoapySDROutputSettings::m_log2Interp, m_running, DeviceSampleSink::m_sampleSourceFifo, m_settings, m_thread, SoapySDROutputThread::setFifo(), SoapySDROutputThread::setLog2Interpolation(), SoapySDROutputThread::setSampleRate(), SoapySDROutputThread::startWork(), and SoapySDROutputThread::stopWork().

 {
     // There is a single thread per physical device (Tx side). This thread is unique and referenced by a unique
     // buddy in the group of sink buddies associated with this physical device.
     //
     // This start method is responsible for managing the thread and channel enabling when the streaming of a Tx channel is started
     //
     // It checks the following conditions
     //   - the thread is allocated or not (by itself or one of its buddies). If it is it grabs the thread pointer.
     //   - the requested channel is the first (0) or the following
     //
     // There are two possible working modes:
     //   - Single Output (SO) with only one channel streaming. This HAS to be channel 0.
     //   - Multiple Output (MO) with two or more channels. It MUST be in this configuration if any channel other than 0
     //     is used. For example when we will run with only channel 2 streaming from the client perspective the channels 0 and 1
     //     will actually be enabled and streaming but zero samples will be sent to it.
     //
     // It manages the transition form SO where only one channel (the first or channel 0) should be running to the
     // Multiple Output (MO) if the requested channel is 1 or more. More generally it checks if the requested channel is within the current
     // channel range allocated in the thread or past it. To perform the transition it stops the thread, deletes it and creates a new one.
     // It marks the thread as needing start.
     //
     // If the requested channel is within the thread channel range (this thread being already allocated) it simply removes its FIFO reference
     // so that the samples are not taken from the FIFO anymore and leaves the thread unchanged (no stop, no delete/new)
     //
     // If there is no thread allocated it creates a new one with a number of channels that fits the requested channel. That is
     // 1 if channel 0 is requested (SO mode) and 3 if channel 2 is requested (MO mode). It marks the thread as needing start.
     //
     // Eventually it registers the FIFO in the thread. If the thread has to be started it enables the channels up to the number of channels
     // allocated in the thread and starts the thread.
     //
     // Note: this is quite similar to the BladeRF2 start handling. The main difference is that the channel allocation (enabling) process is
     // done in the thread object.
 
 
     if (!m_deviceShared.m_device)
     {
         qDebug("SoapySDROutput::start: no device object");
         return false;
     }
 
     int requestedChannel = m_deviceAPI->getDeviceItemIndex();
     SoapySDROutputThread *soapySDROutputThread = findThread();
     bool needsStart = false;
 
     if (soapySDROutputThread) // if thread is already allocated
     {
         qDebug("SoapySDROutput::start: thread is already allocated");
 
         int nbOriginalChannels = soapySDROutputThread->getNbChannels();
 
         if (requestedChannel+1 > nbOriginalChannels) // expansion by deleting and re-creating the thread
         {
             qDebug("SoapySDROutput::start: expand channels. Re-allocate thread and take ownership");
 
             SampleSourceFifo **fifos = new SampleSourceFifo*[nbOriginalChannels];
             unsigned int *log2Interps = new unsigned int[nbOriginalChannels];
 
             for (int i = 0; i < nbOriginalChannels; i++) // save original FIFO references and data
             {
                 fifos[i] = soapySDROutputThread->getFifo(i);
                 log2Interps[i] = soapySDROutputThread->getLog2Interpolation(i);
             }
 
             soapySDROutputThread->stopWork();
             delete soapySDROutputThread;
             soapySDROutputThread = new SoapySDROutputThread(m_deviceShared.m_device, requestedChannel+1);
             m_thread = soapySDROutputThread; // take ownership
 
             for (int i = 0; i < nbOriginalChannels; i++) // restore original FIFO references
             {
                 soapySDROutputThread->setFifo(i, fifos[i]);
                 soapySDROutputThread->setLog2Interpolation(i, log2Interps[i]);
             }
 
             // remove old thread address from buddies (reset in all buddies).  The address being held only in the owning sink.
             const std::vector<DeviceAPI*>& sinkBuddies = m_deviceAPI->getSinkBuddies();
             std::vector<DeviceAPI*>::const_iterator it = sinkBuddies.begin();
 
             for (; it != sinkBuddies.end(); ++it) {
                 ((DeviceSoapySDRShared*) (*it)->getBuddySharedPtr())->m_sink->setThread(0);
             }
 
             delete[] log2Interps;
             delete[] fifos;
 
             needsStart = true;
         }
         else
         {
             qDebug("SoapySDROutput::start: keep buddy thread");
         }
     }
     else // first allocation
     {
         qDebug("SoapySDROutput::start: allocate thread and take ownership");
         soapySDROutputThread = new SoapySDROutputThread(m_deviceShared.m_device, requestedChannel+1);
         m_thread = soapySDROutputThread; // take ownership
         needsStart = true;
     }
 
     soapySDROutputThread->setFifo(requestedChannel, &m_sampleSourceFifo);
     soapySDROutputThread->setLog2Interpolation(requestedChannel, m_settings.m_log2Interp);
 
     if (needsStart)
     {
         qDebug("SoapySDROutput::start: (re)sart buddy thread");
         soapySDROutputThread->setSampleRate(m_settings.m_devSampleRate);
         soapySDROutputThread->startWork();
     }
 
     qDebug("SoapySDROutput::start: started");
     m_running = true;
 
     return true;
 }

Here is the call graph for this function:

◆ stop()

void SoapySDROutput::stop ( )

virtual

Implements DeviceSampleSink.

Definition at line 528 of file soapysdroutput.cpp.

References applySettings(), findThread(), DeviceAPI::getDeviceItemIndex(), SoapySDROutputThread::getFifo(), SoapySDROutputThread::getLog2Interpolation(), SoapySDROutputThread::getNbChannels(), DeviceAPI::getSinkBuddies(), i, DeviceSoapySDRShared::m_device, m_deviceAPI, m_deviceShared, m_running, m_settings, m_thread, SoapySDROutputThread::setFifo(), SoapySDROutputThread::setLog2Interpolation(), SoapySDROutputThread::startWork(), and SoapySDROutputThread::stopWork().

Referenced by closeDevice(), and ~SoapySDROutput().

 {
     // This stop method is responsible for managing the thread and channel disabling when the streaming of
     // a Tx channel is stopped
     //
     // If the thread is currently managing only one channel (SO mode). The thread can be just stopped and deleted.
     // Then the channel is closed (disabled).
     //
     // If the thread is currently managing many channels (MO mode) and we are removing the last channel. The transition
     // from MO to SO or reduction of MO size is handled by stopping the thread, deleting it and creating a new one
     // with the maximum number of channels needed if (and only if) there is still a channel active.
     //
     // If the thread is currently managing many channels (MO mode) but the channel being stopped is not the last
     // channel then the FIFO reference is simply removed from the thread so that this FIFO will not be used anymore.
     // In this case the channel is not closed (this is managed in the thread object) so that other channels can continue with the
     // same configuration. The device continues streaming on this channel but the samples are set to all zeros.
 
     if (!m_running) {
         return;
     }
 
     int requestedChannel = m_deviceAPI->getDeviceItemIndex();
     SoapySDROutputThread *soapySDROutputThread = findThread();
 
     if (soapySDROutputThread == 0) { // no thread allocated
         return;
     }
 
     int nbOriginalChannels = soapySDROutputThread->getNbChannels();
 
     if (nbOriginalChannels == 1) // SO mode => just stop and delete the thread
     {
         qDebug("SoapySDROutput::stop: SO mode. Just stop and delete the thread");
         soapySDROutputThread->stopWork();
         delete soapySDROutputThread;
         m_thread = 0;
 
         // remove old thread address from buddies (reset in all buddies)
         const std::vector<DeviceAPI*>& sinkBuddies = m_deviceAPI->getSinkBuddies();
         std::vector<DeviceAPI*>::const_iterator it = sinkBuddies.begin();
 
         for (; it != sinkBuddies.end(); ++it) {
             ((DeviceSoapySDRShared*) (*it)->getBuddySharedPtr())->m_sink->setThread(0);
         }
     }
     else if (requestedChannel == nbOriginalChannels - 1) // remove last MO channel => reduce by deleting and re-creating the thread
     {
         qDebug("SoapySDROutput::stop: MO mode. Reduce by deleting and re-creating the thread");
         soapySDROutputThread->stopWork();
         SampleSourceFifo **fifos = new SampleSourceFifo*[nbOriginalChannels-1];
         unsigned int *log2Interps = new unsigned int[nbOriginalChannels-1];
         int highestActiveChannelIndex = -1;
 
         for (int i = 0; i < nbOriginalChannels-1; i++) // save original FIFO references
         {
             fifos[i] = soapySDROutputThread->getFifo(i);
 
             if ((soapySDROutputThread->getFifo(i) != 0) && (i > highestActiveChannelIndex)) {
                 highestActiveChannelIndex = i;
             }
 
             log2Interps[i] = soapySDROutputThread->getLog2Interpolation(i);
         }
 
         delete soapySDROutputThread;
         m_thread = 0;
 
         if (highestActiveChannelIndex >= 0)
         {
             soapySDROutputThread = new SoapySDROutputThread(m_deviceShared.m_device, highestActiveChannelIndex+1);
             m_thread = soapySDROutputThread; // take ownership
 
             for (int i = 0; i < nbOriginalChannels-1; i++)  // restore original FIFO references
             {
                 soapySDROutputThread->setFifo(i, fifos[i]);
                 soapySDROutputThread->setLog2Interpolation(i, log2Interps[i]);
             }
         }
         else
         {
             qDebug("SoapySDROutput::stop: do not re-create thread as there are no more FIFOs active");
         }
 
         // remove old thread address from buddies (reset in all buddies). The address being held only in the owning sink.
         const std::vector<DeviceAPI*>& sinkBuddies = m_deviceAPI->getSinkBuddies();
         std::vector<DeviceAPI*>::const_iterator it = sinkBuddies.begin();
 
         for (; it != sinkBuddies.end(); ++it) {
             ((DeviceSoapySDRShared*) (*it)->getBuddySharedPtr())->m_sink->setThread(0);
         }
 
         if (highestActiveChannelIndex >= 0)
         {
             qDebug("SoapySDROutput::stop: restarting the thread");
             soapySDROutputThread->startWork();
         }
 
         delete[] log2Interps;
         delete[] fifos;
     }
     else // remove channel from existing thread
     {
         qDebug("SoapySDROutput::stop: MO mode. Not changing MO configuration. Just remove FIFO reference");
         soapySDROutputThread->setFifo(requestedChannel, 0); // remove FIFO
     }
 
     applySettings(m_settings, true); // re-apply forcibly to set sample rate with the new number of channels
 
     m_running = false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ updateGains()

void SoapySDROutput::updateGains	(	SoapySDR::Device *	dev,
		int	requestedChannel,
		SoapySDROutputSettings &	settings
	)

private

Definition at line 718 of file soapysdroutput.cpp.

References SoapySDROutputSettings::m_globalGain, and SoapySDROutputSettings::m_individualGains.

Referenced by applySettings(), and initGainSettings().

 {
     if (dev == 0) {
         return;
     }
 
     try
     {
         settings.m_globalGain = round(dev->getGain(SOAPY_SDR_TX, requestedChannel));
 
         for (const auto &name : settings.m_individualGains.keys()) {
             settings.m_individualGains[name] = dev->getGain(SOAPY_SDR_TX, requestedChannel, name.toStdString());
         }
     }
     catch (const std::exception &ex)
     {
         qCritical("SoapySDROutput::updateGains: caught exception: %s", ex.what());
     }
 }

Here is the caller graph for this function:

◆ updateTunableElements()

void SoapySDROutput::updateTunableElements	(	SoapySDR::Device *	dev,
		int	requestedChannel,
		SoapySDROutputSettings &	settings
	)

private

Definition at line 738 of file soapysdroutput.cpp.

References SoapySDROutputSettings::m_tunableElements.

Referenced by initTunableElementsSettings().

 {
     if (dev == 0) {
         return;
     }
 
     try
     {
         for (const auto &name : settings.m_tunableElements.keys()) {
             settings.m_tunableElements[name] = dev->getFrequency(SOAPY_SDR_TX, requestedChannel, name.toStdString());
         }
     }
     catch (const std::exception &ex)
     {
         qCritical("SoapySDROutput::updateTunableElements: caught exception: %s", ex.what());
     }
 }

Here is the caller graph for this function:

◆ webapiFormatArgInfo()

void SoapySDROutput::webapiFormatArgInfo	(	const SoapySDR::ArgInfo &	arg,
		SWGSDRangel::SWGArgInfo *	argInfo
	)

private

Definition at line 1783 of file soapysdroutput.cpp.

Referenced by webapiFormatDeviceReport().

 {
     argInfo->setKey(new QString(arg.key.c_str()));
 
     if (arg.type == SoapySDR::ArgInfo::BOOL) {
         argInfo->setValueType(new QString("bool"));
     } else if (arg.type == SoapySDR::ArgInfo::INT) {
         argInfo->setValueType(new QString("int"));
     } else if (arg.type == SoapySDR::ArgInfo::FLOAT) {
         argInfo->setValueType(new QString("float"));
     } else {
         argInfo->setValueType(new QString("string"));
     }
 
     argInfo->setValueString(new QString(arg.value.c_str()));
     argInfo->setName(new QString(arg.name.c_str()));
     argInfo->setDescription(new QString(arg.description.c_str()));
     argInfo->setUnits(new QString(arg.units.c_str()));
 
     if ((arg.range.minimum() != 0.0) || (arg.range.maximum() != 0.0))
     {
         argInfo->setRange(new SWGSDRangel::SWGRangeFloat());
         argInfo->getRange()->setMin(arg.range.minimum());
         argInfo->getRange()->setMax(arg.range.maximum());
     }
 
     argInfo->setValueOptions(new QList<QString*>);
 
     for (const auto itOpt : arg.options) {
         argInfo->getValueOptions()->append(new QString(itOpt.c_str()));
     }
 
     argInfo->setOptionNames(new QList<QString*>);
 
     for (const auto itOpt : arg.optionNames) {
         argInfo->getOptionNames()->append(new QString(itOpt.c_str()));
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ webapiFormatArgValue()

void SoapySDROutput::webapiFormatArgValue	(	const QVariant &	v,
		SWGSDRangel::SWGArgValue *	argValue
	)

private

Definition at line 1759 of file soapysdroutput.cpp.

References arg(), SWGSDRangel::SWGArgValue::setValueString(), and SWGSDRangel::SWGArgValue::setValueType().

Referenced by webapiFormatDeviceSettings().

 {
     if (v.type() == QVariant::Bool)
     {
         argValue->setValueType(new QString("bool"));
         argValue->setValueString(new QString(v.toBool() ? "1" : "0"));
     }
     else if (v.type() == QVariant::Int)
     {
         argValue->setValueType(new QString("int"));
         argValue->setValueString(new QString(tr("%1").arg(v.toInt())));
     }
     else if (v.type() == QVariant::Double)
     {
         argValue->setValueType(new QString("float"));
         argValue->setValueString(new QString(tr("%1").arg(v.toDouble())));
     }
     else
     {
         argValue->setValueType(new QString("string"));
         argValue->setValueString(new QString(v.toString()));
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ webapiFormatDeviceReport()

void SoapySDROutput::webapiFormatDeviceReport ( SWGSDRangel::SWGDeviceReport & response )

private

Definition at line 1637 of file soapysdroutput.cpp.

Referenced by webapiReportGet().

 {
     const DeviceSoapySDRParams::ChannelSettings* channelSettings = m_deviceShared.m_deviceParams->getTxChannelSettings(m_deviceShared.m_channel);
 
     response.getSoapySdrOutputReport()->setDeviceSettingsArgs(new QList<SWGSDRangel::SWGArgInfo*>);
 
     for (const auto itArg : m_deviceShared.m_deviceParams->getDeviceArgs())
     {
         response.getSoapySdrOutputReport()->getDeviceSettingsArgs()->append(new SWGSDRangel::SWGArgInfo);
         webapiFormatArgInfo(itArg, response.getSoapySdrOutputReport()->getDeviceSettingsArgs()->back());
     }
 
     response.getSoapySdrOutputReport()->setStreamSettingsArgs(new QList<SWGSDRangel::SWGArgInfo*>);
 
     for (const auto itArg : channelSettings->m_streamSettingsArgs)
     {
         response.getSoapySdrOutputReport()->getStreamSettingsArgs()->append(new SWGSDRangel::SWGArgInfo);
         webapiFormatArgInfo(itArg, response.getSoapySdrOutputReport()->getStreamSettingsArgs()->back());
     }
 
     response.getSoapySdrOutputReport()->setFrequencySettingsArgs(new QList<SWGSDRangel::SWGArgInfo*>);
 
     for (const auto itArg : channelSettings->m_frequencySettingsArgs)
     {
         response.getSoapySdrOutputReport()->getFrequencySettingsArgs()->append(new SWGSDRangel::SWGArgInfo);
         webapiFormatArgInfo(itArg, response.getSoapySdrOutputReport()->getFrequencySettingsArgs()->back());
     }
 
     response.getSoapySdrOutputReport()->setHasAgc(channelSettings->m_hasAGC ? 1 : 0);
     response.getSoapySdrOutputReport()->setHasDcAutoCorrection(channelSettings->m_hasDCAutoCorrection ? 1 : 0);
     response.getSoapySdrOutputReport()->setHasDcOffsetValue(channelSettings->m_hasDCOffsetValue ? 1 : 0);
     response.getSoapySdrOutputReport()->setHasFrequencyCorrectionValue(channelSettings->m_hasFrequencyCorrectionValue ? 1 : 0);
     response.getSoapySdrOutputReport()->setHasIqBalanceValue(channelSettings->m_hasIQBalanceValue ? 1 : 0);
 
     if (channelSettings->m_antennas.size() != 0)
     {
         response.getSoapySdrOutputReport()->setAntennas(new QList<QString *>);
 
         for (const auto itAntenna : channelSettings->m_antennas) {
             response.getSoapySdrOutputReport()->getAntennas()->append(new QString(itAntenna.c_str()));
         }
     }
 
     if ((channelSettings->m_gainRange.maximum() != 0.0) || (channelSettings->m_gainRange.minimum() != 0.0))
     {
         response.getSoapySdrOutputReport()->setGainRange(new SWGSDRangel::SWGRangeFloat());
         response.getSoapySdrOutputReport()->getGainRange()->setMin(channelSettings->m_gainRange.minimum());
         response.getSoapySdrOutputReport()->getGainRange()->setMax(channelSettings->m_gainRange.maximum());
     }
 
     if (channelSettings->m_gainSettings.size() != 0)
     {
         response.getSoapySdrOutputReport()->setGainSettings(new QList<SWGSDRangel::SWGSoapySDRGainSetting*>);
 
         for (const auto itGain : channelSettings->m_gainSettings)
         {
             response.getSoapySdrOutputReport()->getGainSettings()->append(new SWGSDRangel::SWGSoapySDRGainSetting());
             response.getSoapySdrOutputReport()->getGainSettings()->back()->setRange(new SWGSDRangel::SWGRangeFloat());
             response.getSoapySdrOutputReport()->getGainSettings()->back()->getRange()->setMin(itGain.m_range.minimum());
             response.getSoapySdrOutputReport()->getGainSettings()->back()->getRange()->setMax(itGain.m_range.maximum());
             response.getSoapySdrOutputReport()->getGainSettings()->back()->setName(new QString(itGain.m_name.c_str()));
         }
     }
 
     if (channelSettings->m_frequencySettings.size() != 0)
     {
         response.getSoapySdrOutputReport()->setFrequencySettings(new QList<SWGSDRangel::SWGSoapySDRFrequencySetting*>);
 
         for (const auto itFreq : channelSettings->m_frequencySettings)
         {
             response.getSoapySdrOutputReport()->getFrequencySettings()->append(new SWGSDRangel::SWGSoapySDRFrequencySetting());
             response.getSoapySdrOutputReport()->getFrequencySettings()->back()->setRanges(new QList<SWGSDRangel::SWGRangeFloat*>);
 
             for (const auto itRange : itFreq.m_ranges)
             {
                 response.getSoapySdrOutputReport()->getFrequencySettings()->back()->getRanges()->append(new SWGSDRangel::SWGRangeFloat());
                 response.getSoapySdrOutputReport()->getFrequencySettings()->back()->getRanges()->back()->setMin(itRange.minimum());
                 response.getSoapySdrOutputReport()->getFrequencySettings()->back()->getRanges()->back()->setMax(itRange.maximum());
             }
 
             response.getSoapySdrOutputReport()->getFrequencySettings()->back()->setName(new QString(itFreq.m_name.c_str()));
         }
     }
 
     if (channelSettings->m_ratesRanges.size() != 0)
     {
         response.getSoapySdrOutputReport()->setRatesRanges(new QList<SWGSDRangel::SWGRangeFloat*>);
 
         for (const auto itRange : channelSettings->m_ratesRanges)
         {
             response.getSoapySdrOutputReport()->getRatesRanges()->append(new SWGSDRangel::SWGRangeFloat());
             response.getSoapySdrOutputReport()->getRatesRanges()->back()->setMin(itRange.minimum());
             response.getSoapySdrOutputReport()->getRatesRanges()->back()->setMax(itRange.maximum());
         }
     }
 
     if (channelSettings->m_bandwidthsRanges.size() != 0)
     {
         response.getSoapySdrOutputReport()->setBandwidthsRanges(new QList<SWGSDRangel::SWGRangeFloat*>);
 
         for (const auto itBandwidth : channelSettings->m_bandwidthsRanges)
         {
             response.getSoapySdrOutputReport()->getBandwidthsRanges()->append(new SWGSDRangel::SWGRangeFloat());
             response.getSoapySdrOutputReport()->getBandwidthsRanges()->back()->setMin(itBandwidth.minimum());
             response.getSoapySdrOutputReport()->getBandwidthsRanges()->back()->setMax(itBandwidth.maximum());
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ webapiFormatDeviceSettings()

void SoapySDROutput::webapiFormatDeviceSettings	(	SWGSDRangel::SWGDeviceSettings &	response,
		const SoapySDROutputSettings &	settings
	)

private

Definition at line 1531 of file soapysdroutput.cpp.

Referenced by webapiSettingsGet(), and webapiSettingsPutPatch().

 {
     response.getSoapySdrOutputSettings()->setCenterFrequency(settings.m_centerFrequency);
     response.getSoapySdrOutputSettings()->setLOppmTenths(settings.m_LOppmTenths);
     response.getSoapySdrOutputSettings()->setDevSampleRate(settings.m_devSampleRate);
     response.getSoapySdrOutputSettings()->setLog2Interp(settings.m_log2Interp);
     response.getSoapySdrOutputSettings()->setTransverterDeltaFrequency(settings.m_transverterDeltaFrequency);
     response.getSoapySdrOutputSettings()->setTransverterMode(settings.m_transverterMode ? 1 : 0);
 
     if (response.getSoapySdrOutputSettings()->getAntenna()) {
         *response.getSoapySdrOutputSettings()->getAntenna() = settings.m_antenna;
     } else {
         response.getSoapySdrOutputSettings()->setAntenna(new QString(settings.m_antenna));
     }
 
     if (response.getSoapySdrOutputSettings()->getTunableElements()) {
         response.getSoapySdrOutputSettings()->getTunableElements()->clear();
     } else {
         response.getSoapySdrOutputSettings()->setTunableElements(new QList<SWGSDRangel::SWGArgValue*>);
     }
 
     for (const auto itName : settings.m_tunableElements.keys())
     {
         response.getSoapySdrOutputSettings()->getTunableElements()->append(new SWGSDRangel::SWGArgValue);
         response.getSoapySdrOutputSettings()->getTunableElements()->back()->setKey(new QString(  itName));
         double value = settings.m_tunableElements.value(itName);
         response.getSoapySdrOutputSettings()->getTunableElements()->back()->setValueString(new QString(tr("%1").arg(value)));
         response.getSoapySdrOutputSettings()->getTunableElements()->back()->setValueType(new QString("float"));
     }
 
     response.getSoapySdrOutputSettings()->setBandwidth(settings.m_bandwidth);
     response.getSoapySdrOutputSettings()->setGlobalGain(settings.m_globalGain);
 
     if (response.getSoapySdrOutputSettings()->getIndividualGains()) {
         response.getSoapySdrOutputSettings()->getIndividualGains()->clear();
     } else {
         response.getSoapySdrOutputSettings()->setIndividualGains(new QList<SWGSDRangel::SWGArgValue*>);
     }
 
     for (const auto itName : settings.m_individualGains.keys())
     {
         response.getSoapySdrOutputSettings()->getIndividualGains()->append(new SWGSDRangel::SWGArgValue);
         response.getSoapySdrOutputSettings()->getIndividualGains()->back()->setKey(new QString(itName));
         double value = settings.m_individualGains.value(itName);
         response.getSoapySdrOutputSettings()->getIndividualGains()->back()->setValueString(new QString(tr("%1").arg(value)));
         response.getSoapySdrOutputSettings()->getIndividualGains()->back()->setValueType(new QString("float"));
     }
 
     response.getSoapySdrOutputSettings()->setAutoGain(settings.m_autoGain ? 1 : 0);
     response.getSoapySdrOutputSettings()->setAutoDcCorrection(settings.m_autoDCCorrection ? 1 : 0);
     response.getSoapySdrOutputSettings()->setAutoIqCorrection(settings.m_autoIQCorrection ? 1 : 0);
 
     if (!response.getSoapySdrOutputSettings()->getDcCorrection()) {
         response.getSoapySdrOutputSettings()->setDcCorrection(new SWGSDRangel::SWGComplex());
     }
 
     response.getSoapySdrOutputSettings()->getDcCorrection()->setReal(settings.m_dcCorrection.real());
     response.getSoapySdrOutputSettings()->getDcCorrection()->setImag(settings.m_dcCorrection.imag());
 
     if (!response.getSoapySdrOutputSettings()->getIqCorrection()) {
         response.getSoapySdrOutputSettings()->setIqCorrection(new SWGSDRangel::SWGComplex());
     }
 
     response.getSoapySdrOutputSettings()->getIqCorrection()->setReal(settings.m_iqCorrection.real());
     response.getSoapySdrOutputSettings()->getIqCorrection()->setImag(settings.m_iqCorrection.imag());
 
     if (response.getSoapySdrOutputSettings()->getStreamArgSettings()) {
         response.getSoapySdrOutputSettings()->getStreamArgSettings()->clear();
     } else {
         response.getSoapySdrOutputSettings()->setStreamArgSettings(new QList<SWGSDRangel::SWGArgValue*>);
     }
 
     for (const auto itName : settings.m_streamArgSettings.keys())
     {
         response.getSoapySdrOutputSettings()->getStreamArgSettings()->append(new SWGSDRangel::SWGArgValue);
         response.getSoapySdrOutputSettings()->getStreamArgSettings()->back()->setKey(new QString(itName));
         const QVariant& v = settings.m_streamArgSettings.value(itName);
         webapiFormatArgValue(v, response.getSoapySdrOutputSettings()->getStreamArgSettings()->back());
     }
 
     if (response.getSoapySdrOutputSettings()->getDeviceArgSettings()) {
         response.getSoapySdrOutputSettings()->getDeviceArgSettings()->clear();
     } else {
         response.getSoapySdrOutputSettings()->setDeviceArgSettings(new QList<SWGSDRangel::SWGArgValue*>);
     }
 
     for (const auto itName : settings.m_deviceArgSettings.keys())
     {
         response.getSoapySdrOutputSettings()->getDeviceArgSettings()->append(new SWGSDRangel::SWGArgValue);
         response.getSoapySdrOutputSettings()->getDeviceArgSettings()->back()->setKey(new QString(itName));
         const QVariant& v = settings.m_deviceArgSettings.value(itName);
         webapiFormatArgValue(v, response.getSoapySdrOutputSettings()->getDeviceArgSettings()->back());
     }
 
     response.getSoapySdrOutputSettings()->setUseReverseApi(settings.m_useReverseAPI ? 1 : 0);
 
     if (response.getSoapySdrOutputSettings()->getReverseApiAddress()) {
         *response.getSoapySdrOutputSettings()->getReverseApiAddress() = settings.m_reverseAPIAddress;
     } else {
         response.getSoapySdrOutputSettings()->setReverseApiAddress(new QString(settings.m_reverseAPIAddress));
     }
 
     response.getSoapySdrOutputSettings()->setReverseApiPort(settings.m_reverseAPIPort);
     response.getSoapySdrOutputSettings()->setReverseApiDeviceIndex(settings.m_reverseAPIDeviceIndex);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ webapiReportGet()

int SoapySDROutput::webapiReportGet	(	SWGSDRangel::SWGDeviceReport &	response,
		QString &	errorMessage
	)

virtual

Reimplemented from DeviceSampleSink.

Definition at line 1494 of file soapysdroutput.cpp.

References SWGSDRangel::SWGDeviceReport::getSoapySdrOutputReport(), SWGSDRangel::SWGSoapySDRReport::init(), SWGSDRangel::SWGDeviceReport::setSoapySdrOutputReport(), and webapiFormatDeviceReport().

 {
     (void) errorMessage;
     response.setSoapySdrOutputReport(new SWGSDRangel::SWGSoapySDRReport());
     response.getSoapySdrOutputReport()->init();
     webapiFormatDeviceReport(response);
     return 200;
 }

Here is the call graph for this function:

◆ webapiReverseSendSettings()

void SoapySDROutput::webapiReverseSendSettings	(	QList< QString > &	deviceSettingsKeys,
		const SoapySDROutputSettings &	settings,
		bool	force
	)

private

Definition at line 1822 of file soapysdroutput.cpp.

Referenced by applySettings().

 {
     SWGSDRangel::SWGDeviceSettings *swgDeviceSettings = new SWGSDRangel::SWGDeviceSettings();
     swgDeviceSettings->setDirection(1); // Single Tx
     swgDeviceSettings->setOriginatorIndex(m_deviceAPI->getDeviceSetIndex());
     swgDeviceSettings->setDeviceHwType(new QString("SoapySDR"));
     swgDeviceSettings->setSoapySdrOutputSettings(new SWGSDRangel::SWGSoapySDROutputSettings());
     swgDeviceSettings->getSoapySdrOutputSettings()->init();
     SWGSDRangel::SWGSoapySDROutputSettings *swgSoapySDROutputSettings = swgDeviceSettings->getSoapySdrOutputSettings();
 
     // transfer data that has been modified. When force is on transfer all data except reverse API data
 
     if (deviceSettingsKeys.contains("centerFrequency") || force) {
         swgSoapySDROutputSettings->setCenterFrequency(settings.m_centerFrequency);
     }
     if (deviceSettingsKeys.contains("LOppmTenths") || force) {
         swgSoapySDROutputSettings->setLOppmTenths(settings.m_LOppmTenths);
     }
     if (deviceSettingsKeys.contains("devSampleRate") || force) {
         swgSoapySDROutputSettings->setDevSampleRate(settings.m_devSampleRate);
     }
     if (deviceSettingsKeys.contains("bandwidth") || force) {
         swgSoapySDROutputSettings->setBandwidth(settings.m_bandwidth);
     }
     if (deviceSettingsKeys.contains("log2Interp") || force) {
         swgSoapySDROutputSettings->setLog2Interp(settings.m_log2Interp);
     }
     if (deviceSettingsKeys.contains("transverterDeltaFrequency") || force) {
         swgSoapySDROutputSettings->setTransverterDeltaFrequency(settings.m_transverterDeltaFrequency);
     }
     if (deviceSettingsKeys.contains("transverterMode") || force) {
         swgSoapySDROutputSettings->setTransverterMode(settings.m_transverterMode ? 1 : 0);
     }
     if (deviceSettingsKeys.contains("antenna") || force) {
         swgSoapySDROutputSettings->setAntenna(new QString(settings.m_antenna));
     }
     if (deviceSettingsKeys.contains("globalGain") || force) {
         swgSoapySDROutputSettings->setGlobalGain(settings.m_globalGain);
     }
     if (deviceSettingsKeys.contains("autoGain") || force) {
         swgSoapySDROutputSettings->setAutoGain(settings.m_autoGain ? 1 : 0);
     }
     if (deviceSettingsKeys.contains("autoDCCorrection") || force) {
         swgSoapySDROutputSettings->setAutoDcCorrection(settings.m_autoDCCorrection ? 1 : 0);
     }
     if (deviceSettingsKeys.contains("autoIQCorrection") || force) {
         swgSoapySDROutputSettings->setAutoIqCorrection(settings.m_autoIQCorrection ? 1 : 0);
     }
     if (deviceSettingsKeys.contains("dcCorrection") || force)
     {
         swgSoapySDROutputSettings->setDcCorrection(new SWGSDRangel::SWGComplex());
         swgSoapySDROutputSettings->getDcCorrection()->setReal(settings.m_dcCorrection.real());
         swgSoapySDROutputSettings->getDcCorrection()->setImag(settings.m_dcCorrection.imag());
     }
     if (deviceSettingsKeys.contains("iqCorrection") || force)
     {
         swgSoapySDROutputSettings->setIqCorrection(new SWGSDRangel::SWGComplex());
         swgSoapySDROutputSettings->getIqCorrection()->setReal(settings.m_iqCorrection.real());
         swgSoapySDROutputSettings->getIqCorrection()->setImag(settings.m_iqCorrection.imag());
     }
 
     QString deviceSettingsURL = QString("http://%1:%2/sdrangel/deviceset/%3/device/settings")
             .arg(settings.m_reverseAPIAddress)
             .arg(settings.m_reverseAPIPort)
             .arg(settings.m_reverseAPIDeviceIndex);
     m_networkRequest.setUrl(QUrl(deviceSettingsURL));
     m_networkRequest.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
 
     QBuffer *buffer=new QBuffer();
     buffer->open((QBuffer::ReadWrite));
     buffer->write(swgDeviceSettings->asJson().toUtf8());
     buffer->seek(0);
 
     // Always use PATCH to avoid passing reverse API settings
     m_networkManager->sendCustomRequest(m_networkRequest, "PATCH", buffer);
 
     delete swgDeviceSettings;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ webapiReverseSendStartStop()

void SoapySDROutput::webapiReverseSendStartStop ( bool start )

private

Definition at line 1901 of file soapysdroutput.cpp.

References SWGSDRangel::SWGDeviceSettings::asJson(), DeviceAPI::getDeviceSetIndex(), m_deviceAPI, m_networkManager, m_networkRequest, SoapySDROutputSettings::m_reverseAPIAddress, SoapySDROutputSettings::m_reverseAPIDeviceIndex, SoapySDROutputSettings::m_reverseAPIPort, m_settings, SWGSDRangel::SWGDeviceSettings::setDeviceHwType(), SWGSDRangel::SWGDeviceSettings::setDirection(), and SWGSDRangel::SWGDeviceSettings::setOriginatorIndex().

Referenced by handleMessage().

 {
     SWGSDRangel::SWGDeviceSettings *swgDeviceSettings = new SWGSDRangel::SWGDeviceSettings();
     swgDeviceSettings->setDirection(1); // Single Tx
     swgDeviceSettings->setOriginatorIndex(m_deviceAPI->getDeviceSetIndex());
     swgDeviceSettings->setDeviceHwType(new QString("SoapySDR"));
 
     QString deviceSettingsURL = QString("http://%1:%2/sdrangel/deviceset/%3/device/run")
             .arg(m_settings.m_reverseAPIAddress)
             .arg(m_settings.m_reverseAPIPort)
             .arg(m_settings.m_reverseAPIDeviceIndex);
     m_networkRequest.setUrl(QUrl(deviceSettingsURL));
     m_networkRequest.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
 
     QBuffer *buffer=new QBuffer();
     buffer->open((QBuffer::ReadWrite));
     buffer->write(swgDeviceSettings->asJson().toUtf8());
     buffer->seek(0);
 
     if (start) {
         m_networkManager->sendCustomRequest(m_networkRequest, "POST", buffer);
     } else {
         m_networkManager->sendCustomRequest(m_networkRequest, "DELETE", buffer);
     }
 
     delete swgDeviceSettings;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ webapiRun()

int SoapySDROutput::webapiRun	(	bool	run,
		SWGSDRangel::SWGDeviceState &	response,
		QString &	errorMessage
	)

virtual

Reimplemented from DeviceSampleSink.

Definition at line 1512 of file soapysdroutput.cpp.

References SoapySDROutput::MsgStartStop::create(), DeviceAPI::getDeviceEngineStateStr(), SWGSDRangel::SWGDeviceState::getState(), m_deviceAPI, DeviceSampleSink::m_guiMessageQueue, DeviceSampleSink::m_inputMessageQueue, and MessageQueue::push().

 {
     (void) errorMessage;
     m_deviceAPI->getDeviceEngineStateStr(*response.getState());
     MsgStartStop *message = MsgStartStop::create(run);
     m_inputMessageQueue.push(message);
 
     if (m_guiMessageQueue) // forward to GUI if any
     {
         MsgStartStop *msgToGUI = MsgStartStop::create(run);
         m_guiMessageQueue->push(msgToGUI);
     }
 
     return 200;
 }

Here is the call graph for this function:

◆ webapiRunGet()

int SoapySDROutput::webapiRunGet	(	SWGSDRangel::SWGDeviceState &	response,
		QString &	errorMessage
	)

virtual

Reimplemented from DeviceSampleSink.

Definition at line 1503 of file soapysdroutput.cpp.

References DeviceAPI::getDeviceEngineStateStr(), SWGSDRangel::SWGDeviceState::getState(), and m_deviceAPI.

 {
     (void) errorMessage;
     m_deviceAPI->getDeviceEngineStateStr(*response.getState());
     return 200;
 }

Here is the call graph for this function:

◆ webapiSettingsGet()

int SoapySDROutput::webapiSettingsGet	(	SWGSDRangel::SWGDeviceSettings &	response,
		QString &	errorMessage
	)

virtual

Reimplemented from DeviceSampleSink.

Definition at line 1339 of file soapysdroutput.cpp.

References SWGSDRangel::SWGDeviceSettings::getSoapySdrOutputSettings(), SWGSDRangel::SWGSoapySDROutputSettings::init(), m_settings, SWGSDRangel::SWGDeviceSettings::setSoapySdrOutputSettings(), and webapiFormatDeviceSettings().

 {
     (void) errorMessage;
     response.setSoapySdrOutputSettings(new SWGSDRangel::SWGSoapySDROutputSettings());
     response.getSoapySdrOutputSettings()->init();
     webapiFormatDeviceSettings(response, m_settings);
     return 200;
 }

Here is the call graph for this function:

◆ webapiSettingsPutPatch()

int SoapySDROutput::webapiSettingsPutPatch	(	bool	force,
		const QStringList &	deviceSettingsKeys,
		SWGSDRangel::SWGDeviceSettings &	response,
		QString &	errorMessage
	)

virtual

Reimplemented from DeviceSampleSink.

Definition at line 1350 of file soapysdroutput.cpp.

 {
     (void) errorMessage;
     SoapySDROutputSettings settings = m_settings;
 
     if (deviceSettingsKeys.contains("centerFrequency")) {
         settings.m_centerFrequency = response.getSoapySdrOutputSettings()->getCenterFrequency();
     }
     if (deviceSettingsKeys.contains("LOppmTenths")) {
         settings.m_LOppmTenths = response.getSoapySdrOutputSettings()->getLOppmTenths();
     }
     if (deviceSettingsKeys.contains("devSampleRate")) {
         settings.m_devSampleRate = response.getSoapySdrOutputSettings()->getDevSampleRate();
     }
     if (deviceSettingsKeys.contains("bandwidth")) {
         settings.m_bandwidth = response.getSoapySdrOutputSettings()->getBandwidth();
     }
     if (deviceSettingsKeys.contains("log2Interp")) {
         settings.m_log2Interp = response.getSoapySdrOutputSettings()->getLog2Interp();
     }
     if (deviceSettingsKeys.contains("transverterDeltaFrequency")) {
         settings.m_transverterDeltaFrequency = response.getSoapySdrOutputSettings()->getTransverterDeltaFrequency();
     }
     if (deviceSettingsKeys.contains("transverterMode")) {
         settings.m_transverterMode = response.getSoapySdrOutputSettings()->getTransverterMode() != 0;
     }
     if (deviceSettingsKeys.contains("antenna")) {
         settings.m_antenna = *response.getSoapySdrOutputSettings()->getAntenna();
     }
 
     if (deviceSettingsKeys.contains("tunableElements"))
     {
         QList<SWGSDRangel::SWGArgValue*> *tunableElements = response.getSoapySdrOutputSettings()->getTunableElements();
 
         for (const auto &itArg : *tunableElements)
         {
             QMap<QString, double>::iterator itSettings = settings.m_tunableElements.find(*(itArg->getKey()));
 
             if (itSettings != settings.m_tunableElements.end())
             {
                 QVariant v = webapiVariantFromArgValue(itArg);
                 itSettings.value() = v.toDouble();
             }
         }
     }
 
     if (deviceSettingsKeys.contains("globalGain")) {
         settings.m_globalGain = response.getSoapySdrOutputSettings()->getGlobalGain();
     }
 
     if (deviceSettingsKeys.contains("individualGains"))
     {
         QList<SWGSDRangel::SWGArgValue*> *individualGains = response.getSoapySdrOutputSettings()->getIndividualGains();
 
         for (const auto &itArg : *individualGains)
         {
             QMap<QString, double>::iterator itSettings = settings.m_individualGains.find(*(itArg->getKey()));
 
             if (itSettings != settings.m_individualGains.end())
             {
                 QVariant v = webapiVariantFromArgValue(itArg);
                 itSettings.value() = v.toDouble();
             }
         }
     }
 
     if (deviceSettingsKeys.contains("autoGain")) {
         settings.m_autoGain = response.getSoapySdrOutputSettings()->getAutoGain() != 0;
     }
     if (deviceSettingsKeys.contains("autoDCCorrection")) {
         settings.m_autoDCCorrection = response.getSoapySdrOutputSettings()->getAutoDcCorrection() != 0;
     }
     if (deviceSettingsKeys.contains("autoIQCorrection")) {
         settings.m_autoIQCorrection = response.getSoapySdrOutputSettings()->getAutoIqCorrection() != 0;
     }
     if (deviceSettingsKeys.contains("dcCorrection"))
     {
         settings.m_dcCorrection.real(response.getSoapySdrOutputSettings()->getDcCorrection()->getReal());
         settings.m_dcCorrection.imag(response.getSoapySdrOutputSettings()->getDcCorrection()->getImag());
     }
     if (deviceSettingsKeys.contains("iqCorrection"))
     {
         settings.m_iqCorrection.real(response.getSoapySdrOutputSettings()->getIqCorrection()->getReal());
         settings.m_iqCorrection.imag(response.getSoapySdrOutputSettings()->getIqCorrection()->getImag());
     }
 
     if (deviceSettingsKeys.contains("streamArgSettings"))
     {
         QList<SWGSDRangel::SWGArgValue*> *streamArgSettings = response.getSoapySdrOutputSettings()->getStreamArgSettings();
 
         for (const auto itArg : *streamArgSettings)
         {
             QMap<QString, QVariant>::iterator itSettings = settings.m_streamArgSettings.find(*itArg->getKey());
 
             if (itSettings != settings.m_streamArgSettings.end()) {
                 itSettings.value() = webapiVariantFromArgValue(itArg);
             }
         }
     }
 
     if (deviceSettingsKeys.contains("deviceArgSettings"))
     {
         QList<SWGSDRangel::SWGArgValue*> *deviceArgSettings = response.getSoapySdrOutputSettings()->getDeviceArgSettings();
 
         for (const auto itArg : *deviceArgSettings)
         {
             QMap<QString, QVariant>::iterator itSettings = settings.m_deviceArgSettings.find(*itArg->getKey());
 
             if (itSettings != settings.m_deviceArgSettings.end()) {
                 itSettings.value() = webapiVariantFromArgValue(itArg);
             }
         }
     }
 
     if (deviceSettingsKeys.contains("useReverseAPI")) {
         settings.m_useReverseAPI = response.getSoapySdrOutputSettings()->getUseReverseApi() != 0;
     }
     if (deviceSettingsKeys.contains("reverseAPIAddress")) {
         settings.m_reverseAPIAddress = *response.getSoapySdrOutputSettings()->getReverseApiAddress();
     }
     if (deviceSettingsKeys.contains("reverseAPIPort")) {
         settings.m_reverseAPIPort = response.getSoapySdrOutputSettings()->getReverseApiPort();
     }
     if (deviceSettingsKeys.contains("reverseAPIDeviceIndex")) {
         settings.m_reverseAPIDeviceIndex = response.getSoapySdrOutputSettings()->getReverseApiDeviceIndex();
     }
 
     MsgConfigureSoapySDROutput *msg = MsgConfigureSoapySDROutput::create(settings, force);
     m_inputMessageQueue.push(msg);
 
     if (m_guiMessageQueue) // forward to GUI if any
     {
         MsgConfigureSoapySDROutput *msgToGUI = MsgConfigureSoapySDROutput::create(settings, force);
         m_guiMessageQueue->push(msgToGUI);
     }
 
     webapiFormatDeviceSettings(response, settings);
     return 200;
 }

Here is the call graph for this function:

◆ webapiVariantFromArgValue()

QVariant SoapySDROutput::webapiVariantFromArgValue ( SWGSDRangel::SWGArgValue * argValue )

private

Definition at line 1746 of file soapysdroutput.cpp.

References SWGSDRangel::SWGArgValue::getValueString(), and SWGSDRangel::SWGArgValue::getValueType().

Referenced by webapiSettingsPutPatch().

 {
     if (*argValue->getValueType() == "bool") {
         return QVariant((bool) (*argValue->getValueString() == "1"));
     } else if (*argValue->getValueType() == "int") {
         return QVariant((int) (atoi(argValue->getValueString()->toStdString().c_str())));
     } else if (*argValue->getValueType() == "float") {
         return QVariant((double) (atof(argValue->getValueString()->toStdString().c_str())));
     } else {
         return QVariant(QString(*argValue->getValueString()));
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ m_deviceAPI

DeviceAPI* SoapySDROutput::m_deviceAPI

private

Definition at line 185 of file soapysdroutput.h.

Referenced by applySettings(), closeDevice(), findThread(), handleMessage(), moveThreadToBuddy(), openDevice(), start(), stop(), webapiReverseSendSettings(), webapiReverseSendStartStop(), webapiRun(), and webapiRunGet().

◆ m_deviceDescription

QString SoapySDROutput::m_deviceDescription

private

Definition at line 188 of file soapysdroutput.h.

Referenced by getDeviceDescription().

◆ m_deviceShared

DeviceSoapySDRShared SoapySDROutput::m_deviceShared

private

◆ m_mutex

QMutex SoapySDROutput::m_mutex

private

Definition at line 186 of file soapysdroutput.h.

◆ m_networkManager

QNetworkAccessManager* SoapySDROutput::m_networkManager

private

Definition at line 192 of file soapysdroutput.h.

Referenced by webapiReverseSendSettings(), webapiReverseSendStartStop(), and ~SoapySDROutput().

◆ m_networkRequest

QNetworkRequest SoapySDROutput::m_networkRequest

private

Definition at line 193 of file soapysdroutput.h.

Referenced by webapiReverseSendSettings(), and webapiReverseSendStartStop().

◆ m_running

bool SoapySDROutput::m_running

private

Definition at line 189 of file soapysdroutput.h.

Referenced by closeDevice(), start(), stop(), and ~SoapySDROutput().

◆ m_settings

SoapySDROutputSettings SoapySDROutput::m_settings

private

Definition at line 187 of file soapysdroutput.h.

Referenced by applySettings(), deserialize(), getCenterFrequency(), getSampleRate(), handleMessage(), init(), openDevice(), serialize(), setCenterFrequency(), start(), stop(), webapiReverseSendStartStop(), webapiSettingsGet(), and webapiSettingsPutPatch().

◆ m_thread

SoapySDROutputThread* SoapySDROutput::m_thread

private

Definition at line 190 of file soapysdroutput.h.

Referenced by closeDevice(), findThread(), moveThreadToBuddy(), start(), and stop().

The documentation for this class was generated from the following files:

plugins/samplesink/soapysdroutput/soapysdroutput.h
plugins/samplesink/soapysdroutput/soapysdroutput.cpp

Classes

Public Member Functions

Private Slots

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ SoapySDROutput()

◆ ~SoapySDROutput()

Member Function Documentation

◆ applySettings()

◆ closeDevice()

◆ deserialize()

◆ destroy()

◆ findThread()

◆ getAntennas()

◆ getBandwidthRanges()

◆ getCenterFrequency()

◆ getDeviceArgInfoList()

◆ getDeviceDescription()

◆ getFrequencyRange()

◆ getGlobalGainRange()

◆ getIndividualGainsRanges()

◆ getRateRanges()

◆ getSampleRate()

◆ getStreamArgInfoList()

◆ getThread()

◆ getTunableElements()

◆ handleMessage()

◆ hasDCAutoCorrection()

◆ hasDCCorrectionValue()

◆ hasIQAutoCorrection()

◆ hasIQCorrectionValue()

◆ init()

◆ initDeviceArgSettings()

◆ initGainSettings()

◆ initStreamArgSettings()

◆ initTunableElementsSettings()

◆ isAGCSupported()

◆ moveThreadToBuddy()

◆ networkManagerFinished

◆ openDevice()

◆ serialize()

◆ setCenterFrequency()

◆ setDeviceCenterFrequency()

◆ setMessageQueueToGUI()

◆ setSampleRate()

◆ setThread()

◆ start()

◆ stop()

◆ updateGains()

◆ updateTunableElements()

◆ webapiFormatArgInfo()

◆ webapiFormatArgValue()

◆ webapiFormatDeviceReport()

◆ webapiFormatDeviceSettings()

◆ webapiReportGet()

◆ webapiReverseSendSettings()

◆ webapiReverseSendStartStop()

◆ webapiRun()

◆ webapiRunGet()

◆ webapiSettingsGet()

◆ webapiSettingsPutPatch()

◆ webapiVariantFromArgValue()

Member Data Documentation

◆ m_deviceAPI

◆ m_deviceDescription

◆ m_deviceShared

◆ m_mutex

◆ m_networkManager

◆ m_networkRequest

◆ m_running

◆ m_settings

◆ m_thread