#include <limesdroutput.h>

Inheritance diagram for LimeSDROutput:

Collaboration diagram for LimeSDROutput:

Classes
class	MsgConfigureLimeSDR

class	MsgGetDeviceInfo

class	MsgGetStreamInfo

class	MsgReportStreamInfo

class	MsgStartStop

Public Member Functions
	LimeSDROutput (DeviceAPI *deviceAPI)

virtual	~LimeSDROutput ()

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 ()

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)

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)

std::size_t	getChannelIndex ()

void	getLORange (float &minF, float &maxF) const

void	getSRRange (float &minF, float &maxF) const

void	getLPRange (float &minF, float &maxF) const

uint32_t	getHWLog2Interp () const

DeviceLimeSDRParams::LimeType	getLimeType () const

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 ()

bool	acquireChannel ()

void	releaseChannel ()

void	suspendRxBuddies ()

void	resumeRxBuddies ()

void	suspendTxBuddies ()

void	resumeTxBuddies ()

bool	applySettings (const LimeSDROutputSettings &settings, bool force=false, bool forceNCOFrequency=false)

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

void	webapiFormatDeviceReport (SWGSDRangel::SWGDeviceReport &response)

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

void	webapiReverseSendStartStop (bool start)

Private Attributes
DeviceAPI *	m_deviceAPI

QMutex	m_mutex

LimeSDROutputSettings	m_settings

LimeSDROutputThread *	m_limeSDROutputThread

QString	m_deviceDescription

bool	m_running

DeviceLimeSDRShared	m_deviceShared

bool	m_channelAcquired

lms_stream_t	m_streamId

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 36 of file limesdroutput.h.

Constructor & Destructor Documentation

◆ LimeSDROutput()

LimeSDROutput::LimeSDROutput ( DeviceAPI * deviceAPI )

Definition at line 49 of file limesdroutput.cpp.

References LIMESDROUTPUT_BLOCKSIZE.

Referenced by LimeSDROutput::MsgReportStreamInfo::MsgReportStreamInfo().

                                                  :
     m_deviceAPI(deviceAPI),
     m_settings(),
     m_limeSDROutputThread(0),
     m_deviceDescription("LimeSDROutput"),
     m_running(false),
     m_channelAcquired(false)
 {
     m_deviceAPI->setNbSinkStreams(1);
     m_sampleSourceFifo.resize(16*LIMESDROUTPUT_BLOCKSIZE);
     m_streamId.handle = 0;
     suspendRxBuddies();
     suspendTxBuddies();
     openDevice();
     resumeTxBuddies();
     resumeRxBuddies();
     m_networkManager = new QNetworkAccessManager();
     connect(m_networkManager, SIGNAL(finished(QNetworkReply*)), this, SLOT(networkManagerFinished(QNetworkReply*)));
 }

Here is the caller graph for this function:

◆ ~LimeSDROutput()

LimeSDROutput::~LimeSDROutput ( )

virtual

Definition at line 69 of file limesdroutput.cpp.

References closeDevice(), m_networkManager, m_running, networkManagerFinished(), resumeRxBuddies(), resumeTxBuddies(), stop(), suspendRxBuddies(), and suspendTxBuddies().

Referenced by LimeSDROutput::MsgReportStreamInfo::MsgReportStreamInfo().

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

Here is the call graph for this function:

Here is the caller graph for this function:

Member Function Documentation

◆ acquireChannel()

bool LimeSDROutput::acquireChannel ( )

private

Definition at line 285 of file limesdroutput.cpp.

References DeviceLimeSDRParams::getDevice(), DeviceLimeSDRShared::m_channel, m_channelAcquired, DeviceLimeSDRShared::m_deviceParams, m_deviceShared, m_streamId, resumeRxBuddies(), resumeTxBuddies(), suspendRxBuddies(), and suspendTxBuddies().

Referenced by start().

 {
     suspendRxBuddies();
     suspendTxBuddies();
 
     // acquire the channel
 
     if (LMS_EnableChannel(m_deviceShared.m_deviceParams->getDevice(), LMS_CH_TX, m_deviceShared.m_channel, true) != 0)
     {
         qCritical("LimeSDROutput::acquireChannel: cannot enable Tx channel %d", m_deviceShared.m_channel);
         return false;
     }
     else
     {
         qDebug("LimeSDROutput::acquireChannel: Tx channel %d enabled", m_deviceShared.m_channel);
     }
 
     // set up the stream
 
     m_streamId.channel =  m_deviceShared.m_channel; // channel number
     m_streamId.fifoSize = 1024 * 1024;              // fifo size in samples (SR / 10 take ~5MS/s)
     m_streamId.throughputVsLatency = 0.5;           // optimize for min latency
     m_streamId.isTx = true;                         // TX channel
     m_streamId.dataFmt = lms_stream_t::LMS_FMT_I12; // 12-bit integers
 
     if (LMS_SetupStream(m_deviceShared.m_deviceParams->getDevice(), &m_streamId) != 0)
     {
         qCritical("LimeSDROutput::acquireChannel: cannot setup the stream on Tx channel %d", m_deviceShared.m_channel);
         resumeTxBuddies();
         resumeRxBuddies();
         return false;
     }
     else
     {
         qDebug("LimeSDROutput::acquireChannel: stream set up on Tx channel %d", m_deviceShared.m_channel);
     }
 
     resumeTxBuddies();
     resumeRxBuddies();
 
     m_channelAcquired = true;
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ applySettings()

bool LimeSDROutput::applySettings	(	const LimeSDROutputSettings &	settings,
		bool	force = `false`,
		bool	forceNCOFrequency = `false`
	)

private

Definition at line 739 of file limesdroutput.cpp.

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

 {
     bool forwardChangeOwnDSP = false;
     bool forwardChangeTxDSP  = false;
     bool forwardChangeAllDSP = false;
     bool forwardClockSource  = false;
     bool forwardGPIOChange   = false;
     bool ownThreadWasRunning = false;
     bool doCalibration       = false;
     bool doLPCalibration     = false;
     double clockGenFreq      = 0.0;
     QList<QString> reverseAPIKeys;
 //  QMutexLocker mutexLocker(&m_mutex);
 
     qint64 deviceCenterFrequency = settings.m_centerFrequency;
     deviceCenterFrequency -= settings.m_transverterMode ? settings.m_transverterDeltaFrequency : 0;
     deviceCenterFrequency = deviceCenterFrequency < 0 ? 0 : deviceCenterFrequency;
 
     if (LMS_GetClockFreq(m_deviceShared.m_deviceParams->getDevice(), LMS_CLOCK_CGEN, &clockGenFreq) != 0)
     {
         qCritical("LimeSDROutput::applySettings: could not get clock gen frequency");
     }
     else
     {
         qDebug() << "LimeSDROutput::applySettings: clock gen frequency: " << clockGenFreq;
     }
 
     // apply settings
 
     if ((m_settings.m_gain != settings.m_gain) || force)
     {
         reverseAPIKeys.append("gain");
 
         if (m_deviceShared.m_deviceParams->getDevice() != 0 && m_channelAcquired)
         {
             if (LMS_SetGaindB(m_deviceShared.m_deviceParams->getDevice(),
                     LMS_CH_TX,
                     m_deviceShared.m_channel,
                     settings.m_gain) < 0)
             {
                 qDebug("LimeSDROutput::applySettings: LMS_SetGaindB() failed");
             }
             else
             {
                 doCalibration = true;
                 qDebug() << "LimeSDROutput::applySettings: Gain set to " << settings.m_gain;
             }
         }
     }
 
     if ((m_settings.m_devSampleRate != settings.m_devSampleRate)
        || (m_settings.m_log2HardInterp != settings.m_log2HardInterp) || force)
     {
         reverseAPIKeys.append("devSampleRate");
         reverseAPIKeys.append("log2HardInterp");
         forwardChangeAllDSP = true; //m_settings.m_devSampleRate != settings.m_devSampleRate;
 
         if (m_deviceShared.m_deviceParams->getDevice() != 0)
         {
             if (LMS_SetSampleRateDir(m_deviceShared.m_deviceParams->getDevice(),
                     LMS_CH_TX,
                     settings.m_devSampleRate,
                     1<<settings.m_log2HardInterp) < 0)
             {
                 qCritical("LimeSDROutput::applySettings: could not set sample rate to %d with oversampling of %d",
                         settings.m_devSampleRate,
                         1<<settings.m_log2HardInterp);
             }
             else
             {
                 m_deviceShared.m_deviceParams->m_log2OvSRTx = settings.m_log2HardInterp;
                 m_deviceShared.m_deviceParams->m_sampleRate = settings.m_devSampleRate;
                 //doCalibration = true;
                 forceNCOFrequency = true;
                 qDebug("LimeSDROutput::applySettings: set sample rate set to %d with oversampling of %d",
                         settings.m_devSampleRate,
                         1<<settings.m_log2HardInterp);
             }
         }
     }
 
     if ((m_settings.m_devSampleRate != settings.m_devSampleRate)
        || (m_settings.m_log2SoftInterp != settings.m_log2SoftInterp) || force)
     {
         reverseAPIKeys.append("devSampleRate");
         reverseAPIKeys.append("log2SoftInterp");
 
         int fifoSize = (std::max)(
                 (int) ((settings.m_devSampleRate/(1<<settings.m_log2SoftInterp)) * DeviceLimeSDRShared::m_sampleFifoLengthInSeconds),
                 DeviceLimeSDRShared::m_sampleFifoMinSize);
         qDebug("LimeSDROutput::applySettings: resize FIFO: %d", fifoSize);
         m_sampleSourceFifo.resize(fifoSize);
     }
 
     if ((m_settings.m_lpfBW != settings.m_lpfBW) || force)
     {
         reverseAPIKeys.append("lpfBW");
 
         if (m_deviceShared.m_deviceParams->getDevice() != 0 && m_channelAcquired)
         {
             doLPCalibration = true;
         }
     }
 
     if ((m_settings.m_lpfFIRBW != settings.m_lpfFIRBW) ||
         (m_settings.m_lpfFIREnable != settings.m_lpfFIREnable) || force)
     {
         reverseAPIKeys.append("lpfFIRBW");
         reverseAPIKeys.append("lpfFIREnable");
 
         if (m_deviceShared.m_deviceParams->getDevice() != 0 && m_channelAcquired)
         {
             if (LMS_SetGFIRLPF(m_deviceShared.m_deviceParams->getDevice(),
                     LMS_CH_TX,
                     m_deviceShared.m_channel,
                     settings.m_lpfFIREnable,
                     settings.m_lpfFIRBW) < 0)
             {
                 qCritical("LimeSDROutput::applySettings: could %s and set LPF FIR to %f Hz",
                         settings.m_lpfFIREnable ? "enable" : "disable",
                         settings.m_lpfFIRBW);
             }
             else
             {
                 //doCalibration = true;
                 qDebug("LimeSDROutput::applySettings: %sd and set LPF FIR to %f Hz",
                         settings.m_lpfFIREnable ? "enable" : "disable",
                         settings.m_lpfFIRBW);
             }
         }
     }
 
     if ((m_settings.m_ncoFrequency != settings.m_ncoFrequency) ||
         (m_settings.m_ncoEnable != settings.m_ncoEnable) || force || forceNCOFrequency)
     {
         reverseAPIKeys.append("ncoFrequency");
         reverseAPIKeys.append("ncoEnable");
         forwardChangeOwnDSP = true;
 
         if (m_deviceShared.m_deviceParams->getDevice() != 0 && m_channelAcquired)
         {
             if (DeviceLimeSDR::setNCOFrequency(m_deviceShared.m_deviceParams->getDevice(),
                     LMS_CH_TX,
                     m_deviceShared.m_channel,
                     settings.m_ncoEnable,
                     settings.m_ncoFrequency))
             {
                 //doCalibration = true;
                 m_deviceShared.m_ncoFrequency = settings.m_ncoEnable ? settings.m_ncoFrequency : 0; // for buddies
                 qDebug("LimeSDROutput::applySettings: %sd and set NCO to %d Hz",
                         settings.m_ncoEnable ? "enable" : "disable",
                         settings.m_ncoFrequency);
             }
             else
             {
                 qCritical("LimeSDROutput::applySettings: could not %s and set NCO to %d Hz",
                         settings.m_ncoEnable ? "enable" : "disable",
                         settings.m_ncoFrequency);
             }
         }
     }
 
     if ((m_settings.m_log2SoftInterp != settings.m_log2SoftInterp) || force)
     {
         reverseAPIKeys.append("log2SoftInterp");
         forwardChangeOwnDSP = true;
         m_deviceShared.m_log2Soft = settings.m_log2SoftInterp; // for buddies
 
         if (m_limeSDROutputThread != 0)
         {
             m_limeSDROutputThread->setLog2Interpolation(settings.m_log2SoftInterp);
             qDebug() << "LimeSDROutput::applySettings: set soft decimation to " << (1<<settings.m_log2SoftInterp);
         }
     }
 
     if ((m_settings.m_antennaPath != settings.m_antennaPath) || force)
     {
         reverseAPIKeys.append("antennaPath");
 
         if (m_deviceShared.m_deviceParams->getDevice() != 0 && m_channelAcquired)
         {
             if (DeviceLimeSDR::setTxAntennaPath(m_deviceShared.m_deviceParams->getDevice(),
                     m_deviceShared.m_channel,
                     settings.m_antennaPath))
             {
                 doCalibration = true;
                 qDebug("LimeSDROutput::applySettings: set antenna path to %d",
                         (int) settings.m_antennaPath);
             }
             else
             {
                 qCritical("LimeSDROutput::applySettings: could not set antenna path to %d",
                         (int) settings.m_antennaPath);
             }
         }
     }
 
     if ((m_settings.m_centerFrequency != settings.m_centerFrequency)
         || (m_settings.m_transverterMode != settings.m_transverterMode)
         || (m_settings.m_transverterDeltaFrequency != settings.m_transverterDeltaFrequency)
         || force)
     {
         reverseAPIKeys.append("centerFrequency");
         reverseAPIKeys.append("transverterMode");
         reverseAPIKeys.append("transverterDeltaFrequency");
         forwardChangeTxDSP = true;
 
         if (m_deviceShared.m_deviceParams->getDevice() != 0 && m_channelAcquired)
         {
             if (LMS_SetClockFreq(m_deviceShared.m_deviceParams->getDevice(), LMS_CLOCK_SXT, deviceCenterFrequency) < 0)
             {
                 qCritical("LimeSDROutput::applySettings: could not set frequency to %lld", deviceCenterFrequency);
             }
             else
             {
                 doCalibration = true;
                 m_deviceShared.m_centerFrequency = deviceCenterFrequency; // for buddies
                 qDebug("LimeSDROutput::applySettings: frequency set to %lld", deviceCenterFrequency);
             }
         }
     }
 
     if ((m_settings.m_extClock != settings.m_extClock) ||
         (settings.m_extClock && (m_settings.m_extClockFreq != settings.m_extClockFreq)) || force)
     {
         reverseAPIKeys.append("extClock");
         reverseAPIKeys.append("extClockFreq");
 
         if (DeviceLimeSDR::setClockSource(m_deviceShared.m_deviceParams->getDevice(),
                 settings.m_extClock,
                 settings.m_extClockFreq))
         {
             forwardClockSource = true;
             doCalibration = true;
             qDebug("LimeSDROutput::applySettings: clock set to %s (Ext: %d Hz)",
                     settings.m_extClock ? "external" : "internal",
                     settings.m_extClockFreq);
         }
         else
         {
             qCritical("LimeSDROutput::applySettings: could not set clock to %s (Ext: %d Hz)",
                     settings.m_extClock ? "external" : "internal",
                     settings.m_extClockFreq);
         }
     }
 
     if ((m_deviceShared.m_deviceParams->m_type != DeviceLimeSDRParams::LimeMini)
         && (m_deviceShared.m_deviceParams->m_type != DeviceLimeSDRParams::LimeUndefined))
     {
         if ((m_settings.m_gpioDir != settings.m_gpioDir) || force)
         {
             reverseAPIKeys.append("gpioDir");
 
             if (LMS_GPIODirWrite(m_deviceShared.m_deviceParams->getDevice(), &settings.m_gpioDir, 1) != 0)
             {
                 qCritical("LimeSDROutput::applySettings: could not set GPIO directions to %u", settings.m_gpioDir);
             }
             else
             {
                 forwardGPIOChange = true;
                 qDebug("LimeSDROutput::applySettings: GPIO directions set to %u", settings.m_gpioDir);
             }
         }
 
         if ((m_settings.m_gpioPins != settings.m_gpioPins) || force)
         {
             reverseAPIKeys.append("gpioPins");
 
             if (LMS_GPIOWrite(m_deviceShared.m_deviceParams->getDevice(), &settings.m_gpioPins, 1) != 0)
             {
                 qCritical("LimeSDROutput::applySettings: could not set GPIO pins to %u", settings.m_gpioPins);
             }
             else
             {
                 forwardGPIOChange = true;
                 qDebug("LimeSDROutput::applySettings: GPIO pins set to %u", settings.m_gpioPins);
             }
         }
     }
 
     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);
         webapiReverseSendSettings(reverseAPIKeys, settings, fullUpdate || force);
     }
 
     m_settings = settings;
     double clockGenFreqAfter;
 
     if (LMS_GetClockFreq(m_deviceShared.m_deviceParams->getDevice(), LMS_CLOCK_CGEN, &clockGenFreqAfter) != 0)
     {
         qCritical("LimeSDROutput::applySettings: could not get clock gen frequency");
     }
     else
     {
         qDebug() << "LimeSDROutput::applySettings: clock gen frequency after: " << clockGenFreqAfter;
         doCalibration = doCalibration || (clockGenFreqAfter != clockGenFreq);
     }
 
     if ((doCalibration || doLPCalibration) && m_channelAcquired)
     {
         if (m_limeSDROutputThread && m_limeSDROutputThread->isRunning())
         {
             m_limeSDROutputThread->stopWork();
             ownThreadWasRunning = true;
         }
 
         suspendRxBuddies();
         suspendTxBuddies();
 
         if (doCalibration)
         {
             if (LMS_Calibrate(m_deviceShared.m_deviceParams->getDevice(),
                     LMS_CH_TX,
                     m_deviceShared.m_channel,
                     m_settings.m_devSampleRate,
                     0) < 0)
             {
                 qCritical("LimeSDROutput::applySettings: calibration failed on Tx channel %d", m_deviceShared.m_channel);
             }
             else
             {
                 qDebug("LimeSDROutput::applySettings: calibration successful on Tx channel %d", m_deviceShared.m_channel);
             }
         }
 
         if (doLPCalibration)
         {
             if (LMS_SetLPFBW(m_deviceShared.m_deviceParams->getDevice(),
                     LMS_CH_TX,
                     m_deviceShared.m_channel,
                     m_settings.m_lpfBW) < 0)
             {
                 qCritical("LimeSDROutput::applySettings: could not set LPF to %f Hz", m_settings.m_lpfBW);
             }
             else
             {
                 qDebug("LimeSDROutput::applySettings: LPF set to %f Hz", m_settings.m_lpfBW);
             }
         }
 
         resumeTxBuddies();
         resumeRxBuddies();
 
         if (ownThreadWasRunning) {
             m_limeSDROutputThread->startWork();
         }
     }
 
     // forward changes to buddies or oneself
 
     if (forwardChangeAllDSP)
     {
         qDebug("LimeSDROutput::applySettings: forward change to all buddies");
 
         int ncoShift = m_settings.m_ncoEnable ? m_settings.m_ncoFrequency : 0;
 
         // send to self first
         DSPSignalNotification *notif = new DSPSignalNotification(
                 m_settings.m_devSampleRate/(1<<m_settings.m_log2SoftInterp),
                 m_settings.m_centerFrequency + ncoShift);
         m_deviceAPI->getDeviceEngineInputMessageQueue()->push(notif);
 
         // send to sink buddies
         const std::vector<DeviceAPI*>& sinkBuddies = m_deviceAPI->getSinkBuddies();
         std::vector<DeviceAPI*>::const_iterator itSink = sinkBuddies.begin();
 
         for (; itSink != sinkBuddies.end(); ++itSink)
         {
             DeviceLimeSDRShared::MsgReportBuddyChange *report = DeviceLimeSDRShared::MsgReportBuddyChange::create(
                     m_settings.m_devSampleRate, m_settings.m_log2HardInterp, m_settings.m_centerFrequency, false);
             (*itSink)->getSamplingDeviceInputMessageQueue()->push(report);
         }
 
         // send to source buddies
         const std::vector<DeviceAPI*>& sourceBuddies = m_deviceAPI->getSourceBuddies();
         std::vector<DeviceAPI*>::const_iterator itSource = sourceBuddies.begin();
 
         for (; itSource != sourceBuddies.end(); ++itSource)
         {
             DeviceLimeSDRShared::MsgReportBuddyChange *report = DeviceLimeSDRShared::MsgReportBuddyChange::create(
                     m_settings.m_devSampleRate, m_settings.m_log2HardInterp, m_settings.m_centerFrequency, false);
             (*itSource)->getSamplingDeviceInputMessageQueue()->push(report);
         }
     }
     else if (forwardChangeTxDSP)
     {
         qDebug("LimeSDROutput::applySettings: forward change to Tx buddies");
 
         int sampleRate = m_settings.m_devSampleRate/(1<<m_settings.m_log2SoftInterp);
         int ncoShift = m_settings.m_ncoEnable ? m_settings.m_ncoFrequency : 0;
 
         // send to self first
         DSPSignalNotification *notif = new DSPSignalNotification(sampleRate, m_settings.m_centerFrequency + ncoShift);
         m_deviceAPI->getDeviceEngineInputMessageQueue()->push(notif);
 
         // send to sink buddies
         const std::vector<DeviceAPI*>& sinkBuddies = m_deviceAPI->getSinkBuddies();
         std::vector<DeviceAPI*>::const_iterator itSink = sinkBuddies.begin();
 
         for (; itSink != sinkBuddies.end(); ++itSink)
         {
             DeviceLimeSDRShared::MsgReportBuddyChange *report = DeviceLimeSDRShared::MsgReportBuddyChange::create(
                     m_settings.m_devSampleRate, m_settings.m_log2HardInterp, m_settings.m_centerFrequency, false);
             (*itSink)->getSamplingDeviceInputMessageQueue()->push(report);
         }
     }
     else if (forwardChangeOwnDSP)
     {
         qDebug("LimeSDROutput::applySettings: forward change to self only");
 
         int sampleRate = m_settings.m_devSampleRate/(1<<m_settings.m_log2SoftInterp);
         int ncoShift = m_settings.m_ncoEnable ? m_settings.m_ncoFrequency : 0;
         DSPSignalNotification *notif = new DSPSignalNotification(sampleRate, m_settings.m_centerFrequency + ncoShift);
         m_deviceAPI->getDeviceEngineInputMessageQueue()->push(notif);
     }
 
     if (forwardClockSource)
     {
         // send to source buddies
         const std::vector<DeviceAPI*>& sourceBuddies = m_deviceAPI->getSourceBuddies();
         std::vector<DeviceAPI*>::const_iterator itSource = sourceBuddies.begin();
 
         for (; itSource != sourceBuddies.end(); ++itSource)
         {
             DeviceLimeSDRShared::MsgReportClockSourceChange *report = DeviceLimeSDRShared::MsgReportClockSourceChange::create(
                     m_settings.m_extClock, m_settings.m_extClockFreq);
             (*itSource)->getSamplingDeviceInputMessageQueue()->push(report);
         }
 
         // send to sink buddies
         const std::vector<DeviceAPI*>& sinkBuddies = m_deviceAPI->getSinkBuddies();
         std::vector<DeviceAPI*>::const_iterator itSink = sinkBuddies.begin();
 
         for (; itSink != sinkBuddies.end(); ++itSink)
         {
             DeviceLimeSDRShared::MsgReportClockSourceChange *report = DeviceLimeSDRShared::MsgReportClockSourceChange::create(
                     m_settings.m_extClock, m_settings.m_extClockFreq);
             (*itSink)->getSamplingDeviceInputMessageQueue()->push(report);
         }
     }
 
     if (forwardGPIOChange)
     {
         const std::vector<DeviceAPI*>& sourceBuddies = m_deviceAPI->getSourceBuddies();
         std::vector<DeviceAPI*>::const_iterator itSource = sourceBuddies.begin();
 
         for (; itSource != sourceBuddies.end(); ++itSource)
         {
             DeviceLimeSDRShared::MsgReportGPIOChange *report = DeviceLimeSDRShared::MsgReportGPIOChange::create(
                     m_settings.m_gpioDir, m_settings.m_gpioPins);
             (*itSource)->getSamplingDeviceInputMessageQueue()->push(report);
         }
 
         // send to sink buddies
         const std::vector<DeviceAPI*>& sinkBuddies = m_deviceAPI->getSinkBuddies();
         std::vector<DeviceAPI*>::const_iterator itSink = sinkBuddies.begin();
 
         for (; itSink != sinkBuddies.end(); ++itSink)
         {
             DeviceLimeSDRShared::MsgReportGPIOChange *report = DeviceLimeSDRShared::MsgReportGPIOChange::create(
                     m_settings.m_gpioDir, m_settings.m_gpioPins);
             (*itSink)->getSamplingDeviceInputMessageQueue()->push(report);
         }
     }
 
     QLocale loc;
 
     qDebug().noquote() << "LimeSDROutput::applySettings: center freq: " << m_settings.m_centerFrequency << " Hz"
             << " m_transverterMode: " << m_settings.m_transverterMode
             << " m_transverterDeltaFrequency: " << m_settings.m_transverterDeltaFrequency
             << " deviceCenterFrequency: " << deviceCenterFrequency
             << " device stream sample rate: " << loc.toString(m_settings.m_devSampleRate) << "S/s"
             << " sample rate with soft interpolation: " << loc.toString( m_settings.m_devSampleRate/(1<<m_settings.m_log2SoftInterp)) << "S/s"
             << " DAC sample rate with hard interpolation: " << loc.toString(m_settings.m_devSampleRate*(1<<m_settings.m_log2HardInterp)) << "S/s"
             << " m_log2HardInterp: " << m_settings.m_log2HardInterp
             << " m_log2SoftInterp: " << m_settings.m_log2SoftInterp
             << " m_gain: " << m_settings.m_gain
             << " m_lpfBW: " << loc.toString(static_cast<int>(m_settings.m_lpfBW))
             << " m_lpfFIRBW: " << loc.toString(static_cast<int>(m_settings.m_lpfFIRBW))
             << " m_lpfFIREnable: " << m_settings.m_lpfFIREnable
             << " m_ncoEnable: " << m_settings.m_ncoEnable
             << " m_ncoFrequency: " << loc.toString(m_settings.m_ncoFrequency)
             << " m_antennaPath: " << m_settings.m_antennaPath
             << " m_extClock: " << m_settings.m_extClock
             << " m_extClockFreq: " << loc.toString(m_settings.m_extClockFreq)
             << " m_gpioDir: " << m_settings.m_gpioDir
             << " m_gpioPins: " << m_settings.m_gpioPins
             << " force: " << force
             << " forceNCOFrequency: " << forceNCOFrequency
             << " doCalibration: " << doCalibration
             << " doLPCalibration: " << doLPCalibration;
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ closeDevice()

void LimeSDROutput::closeDevice ( )

private

Definition at line 265 of file limesdroutput.cpp.

References DeviceLimeSDRParams::close(), DeviceLimeSDRParams::getDevice(), DeviceAPI::getSinkBuddies(), DeviceAPI::getSourceBuddies(), DeviceLimeSDRShared::m_channel, m_deviceAPI, DeviceLimeSDRShared::m_deviceParams, m_deviceShared, m_running, and stop().

Referenced by ~LimeSDROutput().

 {
     if (m_deviceShared.m_deviceParams->getDevice() == 0) { // was never open
         return;
     }
 
     if (m_running) stop();
 
     // No buddies so effectively close the device
 
     if ((m_deviceAPI->getSourceBuddies().size() == 0) && (m_deviceAPI->getSinkBuddies().size() == 0))
     {
         m_deviceShared.m_deviceParams->close();
         delete m_deviceShared.m_deviceParams;
         m_deviceShared.m_deviceParams = 0;
     }
 
     m_deviceShared.m_channel = -1; // effectively release the channel for the possible buddies
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ deserialize()

bool LimeSDROutput::deserialize ( const QByteArray & data )

virtual

Implements DeviceSampleSink.

Definition at line 422 of file limesdroutput.cpp.

References LimeSDROutput::MsgConfigureLimeSDR::create(), LimeSDROutputSettings::deserialize(), DeviceSampleSink::m_guiMessageQueue, DeviceSampleSink::m_inputMessageQueue, m_settings, MessageQueue::push(), and LimeSDROutputSettings::resetToDefaults().

Referenced by LimeSDROutput::MsgReportStreamInfo::MsgReportStreamInfo().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ destroy()

void LimeSDROutput::destroy ( )

virtual

Implements DeviceSampleSink.

Definition at line 85 of file limesdroutput.cpp.

Referenced by LimeSDROutput::MsgReportStreamInfo::MsgReportStreamInfo().

 {
     delete this;
 }

Here is the caller graph for this function:

◆ getCenterFrequency()

quint64 LimeSDROutput::getCenterFrequency ( ) const

virtual

Center frequency exposed by the sink.

Implements DeviceSampleSink.

Definition at line 455 of file limesdroutput.cpp.

References LimeSDROutputSettings::m_centerFrequency, LimeSDROutputSettings::m_ncoEnable, LimeSDROutputSettings::m_ncoFrequency, and m_settings.

Referenced by setSampleRate().

 {
     return m_settings.m_centerFrequency + (m_settings.m_ncoEnable ? m_settings.m_ncoFrequency : 0);
 }

Here is the caller graph for this function:

◆ getChannelIndex()

std::size_t LimeSDROutput::getChannelIndex ( )

Definition at line 475 of file limesdroutput.cpp.

References DeviceLimeSDRShared::m_channel, and m_deviceShared.

Referenced by LimeSDROutputGUI::LimeSDROutputGUI(), and setSampleRate().

 {
     return m_deviceShared.m_channel;
 }

Here is the caller graph for this function:

◆ getDeviceDescription()

const QString & LimeSDROutput::getDeviceDescription ( ) const

virtual

Implements DeviceSampleSink.

Definition at line 444 of file limesdroutput.cpp.

References m_deviceDescription.

Referenced by setMessageQueueToGUI().

 {
     return m_deviceDescription;
 }

Here is the caller graph for this function:

◆ getHWLog2Interp()

uint32_t LimeSDROutput::getHWLog2Interp ( ) const

Definition at line 504 of file limesdroutput.cpp.

References DeviceLimeSDRShared::m_deviceParams, m_deviceShared, and DeviceLimeSDRParams::m_log2OvSRTx.

Referenced by setSampleRate().

 {
     return m_deviceShared.m_deviceParams->m_log2OvSRTx;
 }

Here is the caller graph for this function:

◆ getLimeType()

DeviceLimeSDRParams::LimeType LimeSDROutput::getLimeType ( ) const

Definition at line 509 of file limesdroutput.cpp.

References DeviceLimeSDRParams::LimeUndefined, DeviceLimeSDRShared::m_deviceParams, m_deviceShared, and DeviceLimeSDRParams::m_type.

Referenced by LimeSDROutputGUI::LimeSDROutputGUI(), and setSampleRate().

 {
     if (m_deviceShared.m_deviceParams) {
         return m_deviceShared.m_deviceParams->m_type;
     } else {
         return DeviceLimeSDRParams::LimeUndefined;
     }
 }

Here is the caller graph for this function:

◆ getLORange()

void LimeSDROutput::getLORange	(	float &	minF,
		float &	maxF
	)		const

Definition at line 480 of file limesdroutput.cpp.

References DeviceLimeSDRShared::m_deviceParams, m_deviceShared, and DeviceLimeSDRParams::m_loRangeTx.

Referenced by LimeSDROutputGUI::LimeSDROutputGUI(), setSampleRate(), and LimeSDROutputGUI::updateFrequencyLimits().

 {
     lms_range_t range = m_deviceShared.m_deviceParams->m_loRangeTx;
     minF = range.min;
     maxF = range.max;
     qDebug("LimeSDROutput::getLORange: min: %f max: %f", range.min, range.max);
 }

Here is the caller graph for this function:

◆ getLPRange()

void LimeSDROutput::getLPRange	(	float &	minF,
		float &	maxF
	)		const

Definition at line 496 of file limesdroutput.cpp.

References DeviceLimeSDRShared::m_deviceParams, m_deviceShared, and DeviceLimeSDRParams::m_lpfRangeTx.

Referenced by LimeSDROutputGUI::LimeSDROutputGUI(), and setSampleRate().

 {
     lms_range_t range = m_deviceShared.m_deviceParams->m_lpfRangeTx;
     minF = range.min;
     maxF = range.max;
     qDebug("LimeSDROutput::getLPRange: min: %f max: %f", range.min, range.max);
 }

Here is the caller graph for this function:

◆ getSampleRate()

int LimeSDROutput::getSampleRate ( ) const

virtual

Sample rate exposed by the sink.

Implements DeviceSampleSink.

Definition at line 449 of file limesdroutput.cpp.

References LimeSDROutputSettings::m_devSampleRate, LimeSDROutputSettings::m_log2SoftInterp, and m_settings.

Referenced by setMessageQueueToGUI().

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

Here is the caller graph for this function:

◆ getSRRange()

void LimeSDROutput::getSRRange	(	float &	minF,
		float &	maxF
	)		const

Definition at line 488 of file limesdroutput.cpp.

References DeviceLimeSDRShared::m_deviceParams, m_deviceShared, and DeviceLimeSDRParams::m_srRangeTx.

Referenced by LimeSDROutputGUI::displaySampleRate(), LimeSDROutputGUI::LimeSDROutputGUI(), and setSampleRate().

 {
     lms_range_t range = m_deviceShared.m_deviceParams->m_srRangeTx;
     minF = range.min;
     maxF = range.max;
     qDebug("LimeSDROutput::getSRRange: min: %f max: %f", range.min, range.max);
 }

Here is the caller graph for this function:

◆ handleMessage()

bool LimeSDROutput::handleMessage ( const Message & message )

virtual

Implements DeviceSampleSink.

Definition at line 518 of file limesdroutput.cpp.

Referenced by setSampleRate().

 {
     if (MsgConfigureLimeSDR::match(message))
     {
         MsgConfigureLimeSDR& conf = (MsgConfigureLimeSDR&) message;
         qDebug() << "LimeSDROutput::handleMessage: MsgConfigureLimeSDR";
 
         if (!applySettings(conf.getSettings(), conf.getForce()))
         {
             qDebug("LimeSDROutput::handleMessage config error");
         }
 
         return true;
     }
     else if (MsgStartStop::match(message))
     {
         MsgStartStop& cmd = (MsgStartStop&) message;
         qDebug() << "LimeSDROutput::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 (DeviceLimeSDRShared::MsgReportBuddyChange::match(message))
     {
         DeviceLimeSDRShared::MsgReportBuddyChange& report = (DeviceLimeSDRShared::MsgReportBuddyChange&) message;
 
         if (report.getRxElseTx() && m_running)
         {
             double host_Hz;
             double rf_Hz;
 
             if (LMS_GetSampleRate(m_deviceShared.m_deviceParams->getDevice(),
                     LMS_CH_TX,
                     m_deviceShared.m_channel,
                     &host_Hz,
                     &rf_Hz) < 0)
             {
                 qDebug("LimeSDROutput::handleMessage: MsgReportBuddyChange: LMS_GetSampleRate() failed");
             }
             else
             {
                 m_settings.m_devSampleRate = roundf(host_Hz);
                 int hard = roundf(rf_Hz) / m_settings.m_devSampleRate;
                 m_settings.m_log2HardInterp = log2(hard);
 
                 qDebug() << "LimeSDROutput::handleMessage: MsgReportBuddyChange:"
                          << " host_Hz: " << host_Hz
                          << " rf_Hz: " << rf_Hz
                          << " m_devSampleRate: " << m_settings.m_devSampleRate
                          << " log2Hard: " << hard
                          << " m_log2HardInterp: " << m_settings.m_log2HardInterp;
             }
 
         }
         else
         {
             m_settings.m_devSampleRate   = report.getDevSampleRate();
             m_settings.m_log2HardInterp  = report.getLog2HardDecimInterp();
             m_settings.m_centerFrequency = report.getCenterFrequency();
         }
 
         if (m_settings.m_ncoEnable) // need to reset NCO after sample rate change
         {
             applySettings(m_settings, false, true);
         }
 
         int ncoShift = m_settings.m_ncoEnable ? m_settings.m_ncoFrequency : 0;
 
         DSPSignalNotification *notif = new DSPSignalNotification(
                 m_settings.m_devSampleRate/(1<<m_settings.m_log2SoftInterp),
                 m_settings.m_centerFrequency + ncoShift);
         m_deviceAPI->getDeviceEngineInputMessageQueue()->push(notif);
 
         DeviceLimeSDRShared::MsgReportBuddyChange *reportToGUI = DeviceLimeSDRShared::MsgReportBuddyChange::create(
                 m_settings.m_devSampleRate, m_settings.m_log2HardInterp, m_settings.m_centerFrequency, false);
         getMessageQueueToGUI()->push(reportToGUI);
 
         return true;
     }
     else if (DeviceLimeSDRShared::MsgReportClockSourceChange::match(message))
     {
         DeviceLimeSDRShared::MsgReportClockSourceChange& report = (DeviceLimeSDRShared::MsgReportClockSourceChange&) message;
 
         m_settings.m_extClock     = report.getExtClock();
         m_settings.m_extClockFreq = report.getExtClockFeq();
 
         if (getMessageQueueToGUI())
         {
             DeviceLimeSDRShared::MsgReportClockSourceChange *reportToGUI = DeviceLimeSDRShared::MsgReportClockSourceChange::create(
                     m_settings.m_extClock, m_settings.m_extClockFreq);
             getMessageQueueToGUI()->push(reportToGUI);
         }
 
         return true;
     }
     else if (DeviceLimeSDRShared::MsgReportGPIOChange::match(message))
     {
         DeviceLimeSDRShared::MsgReportGPIOChange& report = (DeviceLimeSDRShared::MsgReportGPIOChange&) message;
 
         m_settings.m_gpioDir     = report.getGPIODir();
         m_settings.m_gpioPins = report.getGPIOPins();
 
         // no GUI for the moment only REST API
 
         return true;
     }
     else if (MsgGetStreamInfo::match(message))
     {
 //        qDebug() << "LimeSDROutput::handleMessage: MsgGetStreamInfo";
         lms_stream_status_t status;
 
         if (m_streamId.handle && (LMS_GetStreamStatus(&m_streamId, &status) == 0))
         {
             if (m_deviceAPI->getSamplingDeviceGUIMessageQueue())
             {
                 MsgReportStreamInfo *report = MsgReportStreamInfo::create(
                         true, // Success
                         status.active,
                         status.fifoFilledCount,
                         status.fifoSize,
                         status.underrun,
                         status.overrun,
                         status.droppedPackets,
                         status.linkRate,
                         status.timestamp);
                 m_deviceAPI->getSamplingDeviceGUIMessageQueue()->push(report);
             }
         }
         else
         {
             if (m_deviceAPI->getSamplingDeviceGUIMessageQueue())
             {
                 MsgReportStreamInfo *report = MsgReportStreamInfo::create(
                         false, // Success
                         false, // status.active,
                         0,     // status.fifoFilledCount,
                         16384, // status.fifoSize,
                         0,     // status.underrun,
                         0,     // status.overrun,
                         0,     // status.droppedPackets,
                         0,     // status.linkRate,
                         0);    // status.timestamp);
                 m_deviceAPI->getSamplingDeviceGUIMessageQueue()->push(report);
             }
         }
 
         return true;
     }
     else if (MsgGetDeviceInfo::match(message))
     {
         double temp = 0.0;
         uint8_t gpioPins = 0;
 
         if (m_deviceShared.m_deviceParams->getDevice() && (LMS_GetChipTemperature(m_deviceShared.m_deviceParams->getDevice(), 0, &temp) != 0)) {
             qDebug("LimeSDROutput::handleMessage: MsgGetDeviceInfo: cannot get temperature");
         }
 
         if ((m_deviceShared.m_deviceParams->m_type != DeviceLimeSDRParams::LimeMini)
             && (m_deviceShared.m_deviceParams->m_type != DeviceLimeSDRParams::LimeUndefined))
         {
             if (m_deviceShared.m_deviceParams->getDevice() && (LMS_GPIORead(m_deviceShared.m_deviceParams->getDevice(), &gpioPins, 1) != 0)) {
                 qDebug("LimeSDROutput::handleMessage: MsgGetDeviceInfo: cannot get GPIO pins values");
             }
         }
 
         // send to oneself
         if (getMessageQueueToGUI())
         {
             DeviceLimeSDRShared::MsgReportDeviceInfo *report = DeviceLimeSDRShared::MsgReportDeviceInfo::create(temp, gpioPins);
             getMessageQueueToGUI()->push(report);
         }
 
         // send to source buddies
         const std::vector<DeviceAPI*>& sourceBuddies = m_deviceAPI->getSourceBuddies();
         std::vector<DeviceAPI*>::const_iterator itSource = sourceBuddies.begin();
 
         for (; itSource != sourceBuddies.end(); ++itSource)
         {
             if ((*itSource)->getSamplingDeviceGUIMessageQueue())
             {
                 DeviceLimeSDRShared::MsgReportDeviceInfo *report = DeviceLimeSDRShared::MsgReportDeviceInfo::create(temp, gpioPins);
                 (*itSource)->getSamplingDeviceGUIMessageQueue()->push(report);
             }
         }
 
         // send to sink buddies
         const std::vector<DeviceAPI*>& sinkBuddies = m_deviceAPI->getSinkBuddies();
         std::vector<DeviceAPI*>::const_iterator itSink = sinkBuddies.begin();
 
         for (; itSink != sinkBuddies.end(); ++itSink)
         {
             if ((*itSink)->getSamplingDeviceGUIMessageQueue())
             {
                 DeviceLimeSDRShared::MsgReportDeviceInfo *report = DeviceLimeSDRShared::MsgReportDeviceInfo::create(temp, gpioPins);
                 (*itSink)->getSamplingDeviceGUIMessageQueue()->push(report);
             }
         }
 
         return true;
     }
     else
     {
         return false;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init()

void LimeSDROutput::init ( )

virtual

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

Implements DeviceSampleSink.

Definition at line 365 of file limesdroutput.cpp.

References applySettings(), and m_settings.

Referenced by LimeSDROutput::MsgReportStreamInfo::MsgReportStreamInfo().

 {
     applySettings(m_settings, true, false);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ networkManagerFinished

void LimeSDROutput::networkManagerFinished ( QNetworkReply * reply )

privateslot

Definition at line 1553 of file limesdroutput.cpp.

Referenced by ~LimeSDROutput().

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

Here is the caller graph for this function:

◆ openDevice()

bool LimeSDROutput::openDevice ( )

private

Definition at line 90 of file limesdroutput.cpp.

References DeviceAPI::getBuddySharedPtr(), DeviceAPI::getDeviceItemIndex(), DeviceAPI::getSamplingDeviceSerial(), DeviceAPI::getSinkBuddies(), DeviceAPI::getSourceBuddies(), i, DeviceLimeSDRShared::m_channel, m_deviceAPI, DeviceLimeSDRShared::m_deviceParams, m_deviceShared, DeviceLimeSDRParams::m_nbTxChannels, DeviceLimeSDRParams::open(), and DeviceAPI::setBuddySharedPtr().

 {
     int requestedChannel = m_deviceAPI->getDeviceItemIndex();
 
     // look for Tx buddies and get reference to common parameters
     // if there is a channel left take the first available
     if (m_deviceAPI->getSinkBuddies().size() > 0) // look sink sibling first
     {
         qDebug("LimeSDROutput::openDevice: look in Ix buddies");
 
         DeviceAPI *sinkBuddy = m_deviceAPI->getSinkBuddies()[0];
         //m_deviceShared = *((DeviceLimeSDRShared *) sinkBuddy->getBuddySharedPtr()); // copy shared data
         DeviceLimeSDRShared *deviceLimeSDRShared = (DeviceLimeSDRShared*) sinkBuddy->getBuddySharedPtr();
         m_deviceShared.m_deviceParams = deviceLimeSDRShared->m_deviceParams;
 
         DeviceLimeSDRParams *deviceParams = m_deviceShared.m_deviceParams; // get device parameters
 
         if (deviceParams == 0)
         {
             qCritical("LimeSDROutput::openDevice: cannot get device parameters from Tx buddy");
             return false; // the device params should have been created by the buddy
         }
         else
         {
             qDebug("LimeSDROutput::openDevice: getting device parameters from Tx buddy");
         }
 
         if (m_deviceAPI->getSinkBuddies().size() == deviceParams->m_nbTxChannels)
         {
             qCritical("LimeSDROutput::openDevice: no more Tx channels available in device");
             return false; // no more Tx channels available in device
         }
         else
         {
             qDebug("LimeSDROutput::openDevice: at least one more Tx channel is available in device");
         }
 
         // check if the requested channel is busy and abort if so (should not happen if device management is working correctly)
 
         for (unsigned int i = 0; i < m_deviceAPI->getSinkBuddies().size(); i++)
         {
             DeviceAPI *buddy = m_deviceAPI->getSinkBuddies()[i];
             DeviceLimeSDRShared *buddyShared = (DeviceLimeSDRShared *) buddy->getBuddySharedPtr();
 
             if (buddyShared->m_channel == requestedChannel)
             {
                 qCritical("LimeSDROutput::openDevice: cannot open busy channel %u", requestedChannel);
                 return false;
             }
         }
 
         m_deviceShared.m_channel = requestedChannel; // acknowledge the requested channel
     }
     // look for Rx buddies and get reference to common parameters
     // take the first Rx channel
     else if (m_deviceAPI->getSourceBuddies().size() > 0) // then source
     {
         qDebug("LimeSDROutput::openDevice: look in Rx buddies");
 
         DeviceAPI *sourceBuddy = m_deviceAPI->getSourceBuddies()[0];
         //m_deviceShared = *((DeviceLimeSDRShared *) sourceBuddy->getBuddySharedPtr()); // copy parameters
         DeviceLimeSDRShared *deviceLimeSDRShared = (DeviceLimeSDRShared*) sourceBuddy->getBuddySharedPtr();
         m_deviceShared.m_deviceParams = deviceLimeSDRShared->m_deviceParams;
 
         if (m_deviceShared.m_deviceParams == 0)
         {
             qCritical("LimeSDROutput::openDevice: cannot get device parameters from Rx buddy");
             return false; // the device params should have been created by the buddy
         }
         else
         {
             qDebug("LimeSDROutput::openDevice: getting device parameters from Rx buddy");
         }
 
         m_deviceShared.m_channel = requestedChannel; // acknowledge the requested channel
     }
     // There are no buddies then create the first LimeSDR common parameters
     // open the device this will also populate common fields
     // take the first Tx channel
     else
     {
         qDebug("LimeSDROutput::openDevice: open device here");
 
         m_deviceShared.m_deviceParams = new DeviceLimeSDRParams();
         char serial[256];
         strcpy(serial, qPrintable(m_deviceAPI->getSamplingDeviceSerial()));
         m_deviceShared.m_deviceParams->open(serial);
         m_deviceShared.m_channel = requestedChannel; // acknowledge the requested channel
     }
 
     m_deviceAPI->setBuddySharedPtr(&m_deviceShared); // propagate common parameters to API
 
     return true;
 }

Here is the call graph for this function:

◆ releaseChannel()

void LimeSDROutput::releaseChannel ( )

private

Definition at line 330 of file limesdroutput.cpp.

References DeviceLimeSDRParams::getDevice(), DeviceLimeSDRShared::m_channel, m_channelAcquired, DeviceLimeSDRShared::m_deviceParams, m_deviceShared, m_streamId, resumeRxBuddies(), resumeTxBuddies(), suspendRxBuddies(), and suspendTxBuddies().

Referenced by stop().

 {
     suspendRxBuddies();
     suspendTxBuddies();
 
     // destroy the stream
 
     if (LMS_DestroyStream(m_deviceShared.m_deviceParams->getDevice(), &m_streamId) != 0)
     {
         qWarning("LimeSDROutput::releaseChannel: cannot destroy the stream on Tx channel %d", m_deviceShared.m_channel);
     }
     else
     {
         qDebug("LimeSDROutput::releaseChannel: stream destroyed on Tx channel %d", m_deviceShared.m_channel);
     }
 
     m_streamId.handle = 0;
 
     // release the channel
 
     if (LMS_EnableChannel(m_deviceShared.m_deviceParams->getDevice(), LMS_CH_TX, m_deviceShared.m_channel, false) != 0)
     {
         qWarning("LimeSDROutput::releaseChannel: cannot disable Tx channel %d", m_deviceShared.m_channel);
     }
     else
     {
         qDebug("LimeSDROutput::releaseChannel: Tx channel %d released", m_deviceShared.m_channel);
     }
 
     resumeTxBuddies();
     resumeRxBuddies();
 
     m_channelAcquired = false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ resumeRxBuddies()

void LimeSDROutput::resumeRxBuddies ( )

private

Definition at line 231 of file limesdroutput.cpp.

References DeviceAPI::getSourceBuddies(), m_deviceAPI, DeviceLimeSDRShared::m_thread, DeviceLimeSDRShared::m_threadWasRunning, and DeviceLimeSDRShared::ThreadInterface::startWork().

Referenced by acquireChannel(), applySettings(), releaseChannel(), and ~LimeSDROutput().

 {
     const std::vector<DeviceAPI*>& sourceBuddies = m_deviceAPI->getSourceBuddies();
     std::vector<DeviceAPI*>::const_iterator itSource = sourceBuddies.begin();
 
     qDebug("LimeSDROutput::resumeRxBuddies (%lu)", sourceBuddies.size());
 
     for (; itSource != sourceBuddies.end(); ++itSource)
     {
         DeviceLimeSDRShared *buddySharedPtr = (DeviceLimeSDRShared *) (*itSource)->getBuddySharedPtr();
 
         if (buddySharedPtr->m_threadWasRunning) {
             buddySharedPtr->m_thread->startWork();
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ resumeTxBuddies()

void LimeSDROutput::resumeTxBuddies ( )

private

Definition at line 248 of file limesdroutput.cpp.

References DeviceAPI::getSinkBuddies(), m_deviceAPI, DeviceLimeSDRShared::m_thread, DeviceLimeSDRShared::m_threadWasRunning, and DeviceLimeSDRShared::ThreadInterface::startWork().

Referenced by acquireChannel(), applySettings(), releaseChannel(), and ~LimeSDROutput().

 {
     const std::vector<DeviceAPI*>& sinkBuddies = m_deviceAPI->getSinkBuddies();
     std::vector<DeviceAPI*>::const_iterator itSink = sinkBuddies.begin();
 
     qDebug("LimeSDROutput::resumeTxBuddies (%lu)", sinkBuddies.size());
 
     for (; itSink != sinkBuddies.end(); ++itSink)
     {
         DeviceLimeSDRShared *buddySharedPtr = (DeviceLimeSDRShared *) (*itSink)->getBuddySharedPtr();
 
         if (buddySharedPtr->m_threadWasRunning) {
             buddySharedPtr->m_thread->startWork();
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ serialize()

QByteArray LimeSDROutput::serialize ( ) const

virtual

Implements DeviceSampleSink.

Definition at line 417 of file limesdroutput.cpp.

References m_settings, and LimeSDROutputSettings::serialize().

Referenced by LimeSDROutput::MsgReportStreamInfo::MsgReportStreamInfo().

 {
     return m_settings.serialize();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setCenterFrequency()

void LimeSDROutput::setCenterFrequency ( qint64 centerFrequency )

virtual

Implements DeviceSampleSink.

Definition at line 460 of file limesdroutput.cpp.

References LimeSDROutput::MsgConfigureLimeSDR::create(), LimeSDROutputSettings::m_centerFrequency, DeviceSampleSink::m_guiMessageQueue, DeviceSampleSink::m_inputMessageQueue, LimeSDROutputSettings::m_ncoEnable, LimeSDROutputSettings::m_ncoFrequency, m_settings, and MessageQueue::push().

Referenced by setSampleRate().

 {
     LimeSDROutputSettings settings = m_settings;
     settings.m_centerFrequency = centerFrequency - (m_settings.m_ncoEnable ? m_settings.m_ncoFrequency : 0);
 
     MsgConfigureLimeSDR* message = MsgConfigureLimeSDR::create(settings, false);
     m_inputMessageQueue.push(message);
 
     if (m_guiMessageQueue)
     {
         MsgConfigureLimeSDR* messageToGUI = MsgConfigureLimeSDR::create(settings, false);
         m_guiMessageQueue->push(messageToGUI);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setMessageQueueToGUI()

virtual void LimeSDROutput::setMessageQueueToGUI ( MessageQueue * queue )

inlinevirtual

Implements DeviceSampleSink.

Definition at line 198 of file limesdroutput.h.

References getDeviceDescription(), getSampleRate(), and DeviceSampleSink::m_guiMessageQueue.

198 { m_guiMessageQueue = queue; }

DeviceSampleSink::m_guiMessageQueue

MessageQueue * m_guiMessageQueue

Input message queue to the GUI.

Definition: devicesamplesink.h:146

Here is the call graph for this function:

◆ setSampleRate()

virtual void LimeSDROutput::setSampleRate ( int sampleRate )

inlinevirtual

For when the sink sample rate is set externally.

Implements DeviceSampleSink.

Definition at line 201 of file limesdroutput.h.

References getCenterFrequency(), getChannelIndex(), getHWLog2Interp(), getLimeType(), getLORange(), getLPRange(), getSRRange(), handleMessage(), setCenterFrequency(), webapiReportGet(), webapiRun(), webapiRunGet(), webapiSettingsGet(), and webapiSettingsPutPatch().

201 { (void) sampleRate; }

Here is the call graph for this function:

◆ start()

bool LimeSDROutput::start ( )

virtual

Implements DeviceSampleSink.

Definition at line 370 of file limesdroutput.cpp.

References acquireChannel(), applySettings(), DeviceLimeSDRParams::getDevice(), DeviceLimeSDRShared::m_deviceParams, m_deviceShared, m_limeSDROutputThread, LimeSDROutputSettings::m_log2SoftInterp, m_running, DeviceSampleSink::m_sampleSourceFifo, m_settings, m_streamId, DeviceLimeSDRShared::m_thread, LimeSDROutputThread::setLog2Interpolation(), LimeSDROutputThread::startWork(), and stop().

Referenced by LimeSDROutput::MsgReportStreamInfo::MsgReportStreamInfo().

 {
     if (!m_deviceShared.m_deviceParams->getDevice()) {
         return false;
     }
 
     if (m_running) { stop(); }
 
     if (!acquireChannel())
     {
         return false;
     }
 
     // start / stop streaming is done in the thread.
 
     m_limeSDROutputThread = new LimeSDROutputThread(&m_streamId, &m_sampleSourceFifo);
     qDebug("LimeSDROutput::start: thread created");
 
     applySettings(m_settings, true);
 
     m_limeSDROutputThread->setLog2Interpolation(m_settings.m_log2SoftInterp);
 
     m_limeSDROutputThread->startWork();
 
     m_deviceShared.m_thread = m_limeSDROutputThread;
     m_running = true;
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ stop()

void LimeSDROutput::stop ( )

virtual

Implements DeviceSampleSink.

Definition at line 400 of file limesdroutput.cpp.

References m_deviceShared, m_limeSDROutputThread, m_running, DeviceLimeSDRShared::m_thread, releaseChannel(), and LimeSDROutputThread::stopWork().

Referenced by closeDevice(), LimeSDROutput::MsgReportStreamInfo::MsgReportStreamInfo(), start(), and ~LimeSDROutput().

 {
     qDebug("LimeSDROutput::stop");
 
     if (m_limeSDROutputThread != 0)
     {
         m_limeSDROutputThread->stopWork();
         delete m_limeSDROutputThread;
         m_limeSDROutputThread = 0;
     }
 
     m_deviceShared.m_thread = 0;
     m_running = false;
 
     releaseChannel();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ suspendRxBuddies()

void LimeSDROutput::suspendRxBuddies ( )

private

Definition at line 185 of file limesdroutput.cpp.

References DeviceAPI::getSourceBuddies(), DeviceLimeSDRShared::ThreadInterface::isRunning(), m_deviceAPI, DeviceLimeSDRShared::m_thread, DeviceLimeSDRShared::m_threadWasRunning, and DeviceLimeSDRShared::ThreadInterface::stopWork().

Referenced by acquireChannel(), applySettings(), releaseChannel(), and ~LimeSDROutput().

 {
     const std::vector<DeviceAPI*>& sourceBuddies = m_deviceAPI->getSourceBuddies();
     std::vector<DeviceAPI*>::const_iterator itSource = sourceBuddies.begin();
 
     qDebug("LimeSDROutput::suspendRxBuddies (%lu)", sourceBuddies.size());
 
     for (; itSource != sourceBuddies.end(); ++itSource)
     {
         DeviceLimeSDRShared *buddySharedPtr = (DeviceLimeSDRShared *) (*itSource)->getBuddySharedPtr();
 
         if (buddySharedPtr->m_thread && buddySharedPtr->m_thread->isRunning())
         {
             buddySharedPtr->m_thread->stopWork();
             buddySharedPtr->m_threadWasRunning = true;
         }
         else
         {
             buddySharedPtr->m_threadWasRunning = false;
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ suspendTxBuddies()

void LimeSDROutput::suspendTxBuddies ( )

private

Definition at line 208 of file limesdroutput.cpp.

References DeviceAPI::getSinkBuddies(), DeviceLimeSDRShared::ThreadInterface::isRunning(), m_deviceAPI, DeviceLimeSDRShared::m_thread, DeviceLimeSDRShared::m_threadWasRunning, and DeviceLimeSDRShared::ThreadInterface::stopWork().

Referenced by acquireChannel(), applySettings(), releaseChannel(), and ~LimeSDROutput().

 {
     const std::vector<DeviceAPI*>& sinkBuddies = m_deviceAPI->getSinkBuddies();
     std::vector<DeviceAPI*>::const_iterator itSink = sinkBuddies.begin();
 
     qDebug("LimeSDROutput::suspendTxBuddies (%lu)", sinkBuddies.size());
 
     for (; itSink != sinkBuddies.end(); ++itSink)
     {
         DeviceLimeSDRShared *buddySharedPtr = (DeviceLimeSDRShared *) (*itSink)->getBuddySharedPtr();
 
         if (buddySharedPtr->m_thread && buddySharedPtr->m_thread->isRunning())
         {
             buddySharedPtr->m_thread->stopWork();
             buddySharedPtr->m_threadWasRunning = true;
         }
         else
         {
             buddySharedPtr->m_threadWasRunning = false;
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ webapiFormatDeviceReport()

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

private

Definition at line 1404 of file limesdroutput.cpp.

Referenced by webapiReportGet().

 {
     bool success = false;
     double temp = 0.0;
     uint8_t gpioDir = 0;
     uint8_t gpioPins = 0;
     lms_stream_status_t status;
     status.active = false;
     status.fifoFilledCount = 0;
     status.fifoSize = 1;
     status.underrun = 0;
     status.overrun = 0;
     status.droppedPackets = 0;
     status.linkRate = 0.0;
     status.timestamp = 0;
 
     success = (m_streamId.handle && (LMS_GetStreamStatus(&m_streamId, &status) == 0));
 
     response.getLimeSdrOutputReport()->setSuccess(success ? 1 : 0);
     response.getLimeSdrOutputReport()->setStreamActive(status.active ? 1 : 0);
     response.getLimeSdrOutputReport()->setFifoSize(status.fifoSize);
     response.getLimeSdrOutputReport()->setFifoFill(status.fifoFilledCount);
     response.getLimeSdrOutputReport()->setUnderrunCount(status.underrun);
     response.getLimeSdrOutputReport()->setOverrunCount(status.overrun);
     response.getLimeSdrOutputReport()->setDroppedPacketsCount(status.droppedPackets);
     response.getLimeSdrOutputReport()->setLinkRate(status.linkRate);
     response.getLimeSdrOutputReport()->setHwTimestamp(status.timestamp);
 
     if (m_deviceShared.m_deviceParams->getDevice())
     {
         LMS_GetChipTemperature(m_deviceShared.m_deviceParams->getDevice(), 0, &temp);
         LMS_GPIODirRead(m_deviceShared.m_deviceParams->getDevice(), &gpioDir, 1);
         LMS_GPIORead(m_deviceShared.m_deviceParams->getDevice(), &gpioPins, 1);
     }
 
     response.getLimeSdrOutputReport()->setTemperature(temp);
     response.getLimeSdrOutputReport()->setGpioDir(gpioDir);
     response.getLimeSdrOutputReport()->setGpioPins(gpioPins);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ webapiFormatDeviceSettings()

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

private

Definition at line 1345 of file limesdroutput.cpp.

Referenced by webapiSettingsGet(), and webapiSettingsPutPatch().

 {
     response.getLimeSdrOutputSettings()->setAntennaPath((int) settings.m_antennaPath);
     response.getLimeSdrOutputSettings()->setCenterFrequency(settings.m_centerFrequency);
     response.getLimeSdrOutputSettings()->setDevSampleRate(settings.m_devSampleRate);
     response.getLimeSdrOutputSettings()->setExtClock(settings.m_extClock ? 1 : 0);
     response.getLimeSdrOutputSettings()->setExtClockFreq(settings.m_extClockFreq);
     response.getLimeSdrOutputSettings()->setGain(settings.m_gain);
     response.getLimeSdrOutputSettings()->setLog2HardInterp(settings.m_log2HardInterp);
     response.getLimeSdrOutputSettings()->setLog2SoftInterp(settings.m_log2SoftInterp);
     response.getLimeSdrOutputSettings()->setLpfBw(settings.m_lpfBW);
     response.getLimeSdrOutputSettings()->setLpfFirEnable(settings.m_lpfFIREnable ? 1 : 0);
     response.getLimeSdrOutputSettings()->setLpfFirbw(settings.m_lpfFIRBW);
     response.getLimeSdrOutputSettings()->setNcoEnable(settings.m_ncoEnable ? 1 : 0);
     response.getLimeSdrOutputSettings()->setNcoFrequency(settings.m_ncoFrequency);
     response.getLimeSdrOutputSettings()->setTransverterDeltaFrequency(settings.m_transverterDeltaFrequency);
     response.getLimeSdrOutputSettings()->setTransverterMode(settings.m_transverterMode ? 1 : 0);
     response.getLimeSdrOutputSettings()->setGpioDir(settings.m_gpioDir);
     response.getLimeSdrOutputSettings()->setGpioPins(settings.m_gpioPins);
     response.getLimeSdrOutputSettings()->setUseReverseApi(settings.m_useReverseAPI ? 1 : 0);
 
     if (response.getLimeSdrOutputSettings()->getReverseApiAddress()) {
         *response.getLimeSdrOutputSettings()->getReverseApiAddress() = settings.m_reverseAPIAddress;
     } else {
         response.getLimeSdrOutputSettings()->setReverseApiAddress(new QString(settings.m_reverseAPIAddress));
     }
 
     response.getLimeSdrOutputSettings()->setReverseApiPort(settings.m_reverseAPIPort);
     response.getLimeSdrOutputSettings()->setReverseApiDeviceIndex(settings.m_reverseAPIDeviceIndex);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ webapiReportGet()

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

virtual

Reimplemented from DeviceSampleSink.

Definition at line 1335 of file limesdroutput.cpp.

References SWGSDRangel::SWGDeviceReport::getLimeSdrOutputReport(), SWGSDRangel::SWGLimeSdrOutputReport::init(), SWGSDRangel::SWGDeviceReport::setLimeSdrOutputReport(), and webapiFormatDeviceReport().

Referenced by setSampleRate().

 {
     (void) errorMessage;
     response.setLimeSdrOutputReport(new SWGSDRangel::SWGLimeSdrOutputReport());
     response.getLimeSdrOutputReport()->init();
     webapiFormatDeviceReport(response);
     return 200;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ webapiReverseSendSettings()

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

private

Definition at line 1444 of file limesdroutput.cpp.

Referenced by applySettings().

 {
     SWGSDRangel::SWGDeviceSettings *swgDeviceSettings = new SWGSDRangel::SWGDeviceSettings();
     swgDeviceSettings->setDirection(1); // single Tx
     swgDeviceSettings->setOriginatorIndex(m_deviceAPI->getDeviceSetIndex());
     swgDeviceSettings->setDeviceHwType(new QString("LimeSDR"));
     swgDeviceSettings->setLimeSdrOutputSettings(new SWGSDRangel::SWGLimeSdrOutputSettings());
     SWGSDRangel::SWGLimeSdrOutputSettings *swgLimeSdrOutputSettings = swgDeviceSettings->getLimeSdrOutputSettings();
 
     // transfer data that has been modified. When force is on transfer all data except reverse API data
 
     if (deviceSettingsKeys.contains("antennaPath") || force) {
         swgLimeSdrOutputSettings->setAntennaPath((int) settings.m_antennaPath);
     }
     if (deviceSettingsKeys.contains("centerFrequency") || force) {
         swgLimeSdrOutputSettings->setCenterFrequency(settings.m_centerFrequency);
     }
     if (deviceSettingsKeys.contains("devSampleRate") || force) {
         swgLimeSdrOutputSettings->setDevSampleRate(settings.m_devSampleRate);
     }
     if (deviceSettingsKeys.contains("extClock") || force) {
         swgLimeSdrOutputSettings->setExtClock(settings.m_extClock ? 1 : 0);
     }
     if (deviceSettingsKeys.contains("extClockFreq") || force) {
         swgLimeSdrOutputSettings->setExtClockFreq(settings.m_extClockFreq);
     }
     if (deviceSettingsKeys.contains("gain") || force) {
         swgLimeSdrOutputSettings->setGain(settings.m_gain);
     }
     if (deviceSettingsKeys.contains("log2HardInterp") || force) {
         swgLimeSdrOutputSettings->setLog2HardInterp(settings.m_log2HardInterp);
     }
     if (deviceSettingsKeys.contains("log2SoftInterp") || force) {
         swgLimeSdrOutputSettings->setLog2SoftInterp(settings.m_log2SoftInterp);
     }
     if (deviceSettingsKeys.contains("lpfBW") || force) {
         swgLimeSdrOutputSettings->setLpfBw(settings.m_lpfBW);
     }
     if (deviceSettingsKeys.contains("lpfFIREnable") || force) {
         swgLimeSdrOutputSettings->setLpfFirEnable(settings.m_lpfFIREnable ? 1 : 0);
     }
     if (deviceSettingsKeys.contains("lpfFIRBW") || force) {
         swgLimeSdrOutputSettings->setLpfFirbw(settings.m_lpfFIRBW);
     }
     if (deviceSettingsKeys.contains("ncoEnable") || force) {
         swgLimeSdrOutputSettings->setNcoEnable(settings.m_ncoEnable ? 1 : 0);
     }
     if (deviceSettingsKeys.contains("ncoFrequency") || force) {
         swgLimeSdrOutputSettings->setNcoFrequency(settings.m_ncoFrequency);
     }
     if (deviceSettingsKeys.contains("transverterDeltaFrequency") || force) {
         swgLimeSdrOutputSettings->setTransverterDeltaFrequency(settings.m_transverterDeltaFrequency);
     }
     if (deviceSettingsKeys.contains("transverterMode") || force) {
         swgLimeSdrOutputSettings->setTransverterMode(settings.m_transverterMode ? 1 : 0);
     }
     if (deviceSettingsKeys.contains("gpioDir") || force) {
         swgLimeSdrOutputSettings->setGpioDir(settings.m_gpioDir & 0xFF);
     }
     if (deviceSettingsKeys.contains("gpioPins") || force) {
         swgLimeSdrOutputSettings->setGpioPins(settings.m_gpioPins & 0xFF);
     }
 
     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 LimeSDROutput::webapiReverseSendStartStop ( bool start )

private

Definition at line 1525 of file limesdroutput.cpp.

References SWGSDRangel::SWGDeviceSettings::asJson(), DeviceAPI::getDeviceSetIndex(), m_deviceAPI, m_networkManager, m_networkRequest, LimeSDROutputSettings::m_reverseAPIAddress, LimeSDROutputSettings::m_reverseAPIDeviceIndex, LimeSDROutputSettings::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("LimeSDR"));
 
     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 LimeSDROutput::webapiRun	(	bool	run,
		SWGSDRangel::SWGDeviceState &	response,
		QString &	errorMessage
	)

virtual

Reimplemented from DeviceSampleSink.

Definition at line 1385 of file limesdroutput.cpp.

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

Referenced by setSampleRate().

 {
     (void) errorMessage;
     m_deviceAPI->getDeviceEngineStateStr(*response.getState());
     MsgStartStop *message = MsgStartStop::create(run);
     m_inputMessageQueue.push(message);
 
     if (m_guiMessageQueue)
     {
         MsgStartStop *messagetoGui = MsgStartStop::create(run);
         m_guiMessageQueue->push(messagetoGui);
     }
 
     return 200;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ webapiRunGet()

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

virtual

Reimplemented from DeviceSampleSink.

Definition at line 1376 of file limesdroutput.cpp.

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

Referenced by setSampleRate().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ webapiSettingsGet()

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

virtual

Reimplemented from DeviceSampleSink.

Definition at line 1238 of file limesdroutput.cpp.

References SWGSDRangel::SWGDeviceSettings::getLimeSdrOutputSettings(), SWGSDRangel::SWGLimeSdrOutputSettings::init(), m_settings, SWGSDRangel::SWGDeviceSettings::setLimeSdrOutputSettings(), and webapiFormatDeviceSettings().

Referenced by setSampleRate().

 {
     (void) errorMessage;
     response.setLimeSdrOutputSettings(new SWGSDRangel::SWGLimeSdrOutputSettings());
     response.getLimeSdrOutputSettings()->init();
     webapiFormatDeviceSettings(response, m_settings);
     return 200;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ webapiSettingsPutPatch()

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

virtual

Reimplemented from DeviceSampleSink.

Definition at line 1249 of file limesdroutput.cpp.

Referenced by setSampleRate().

 {
     (void) errorMessage;
     LimeSDROutputSettings settings = m_settings;
 
     if (deviceSettingsKeys.contains("antennaPath")) {
         settings.m_antennaPath = (LimeSDROutputSettings::PathRFE) response.getLimeSdrOutputSettings()->getAntennaPath();
     }
     if (deviceSettingsKeys.contains("centerFrequency")) {
         settings.m_centerFrequency = response.getLimeSdrOutputSettings()->getCenterFrequency();
     }
     if (deviceSettingsKeys.contains("devSampleRate")) {
         settings.m_devSampleRate = response.getLimeSdrOutputSettings()->getDevSampleRate();
     }
     if (deviceSettingsKeys.contains("extClock")) {
         settings.m_extClock = response.getLimeSdrOutputSettings()->getExtClock() != 0;
     }
     if (deviceSettingsKeys.contains("extClockFreq")) {
         settings.m_extClockFreq = response.getLimeSdrOutputSettings()->getExtClockFreq();
     }
     if (deviceSettingsKeys.contains("gain")) {
         settings.m_gain = response.getLimeSdrOutputSettings()->getGain();
     }
     if (deviceSettingsKeys.contains("log2HardInterp")) {
         settings.m_log2HardInterp = response.getLimeSdrOutputSettings()->getLog2HardInterp();
     }
     if (deviceSettingsKeys.contains("log2SoftInterp")) {
         settings.m_log2SoftInterp = response.getLimeSdrOutputSettings()->getLog2SoftInterp();
     }
     if (deviceSettingsKeys.contains("lpfBW")) {
         settings.m_lpfBW = response.getLimeSdrOutputSettings()->getLpfBw();
     }
     if (deviceSettingsKeys.contains("lpfFIREnable")) {
         settings.m_lpfFIREnable = response.getLimeSdrOutputSettings()->getLpfFirEnable() != 0;
     }
     if (deviceSettingsKeys.contains("lpfFIRBW")) {
         settings.m_lpfFIRBW = response.getLimeSdrOutputSettings()->getLpfFirbw();
     }
     if (deviceSettingsKeys.contains("ncoEnable")) {
         settings.m_ncoEnable = response.getLimeSdrOutputSettings()->getNcoEnable() != 0;
     }
     if (deviceSettingsKeys.contains("ncoFrequency")) {
         settings.m_ncoFrequency = response.getLimeSdrOutputSettings()->getNcoFrequency();
     }
     if (deviceSettingsKeys.contains("transverterDeltaFrequency")) {
         settings.m_transverterDeltaFrequency = response.getLimeSdrOutputSettings()->getTransverterDeltaFrequency();
     }
     if (deviceSettingsKeys.contains("transverterMode")) {
         settings.m_transverterMode = response.getLimeSdrOutputSettings()->getTransverterMode() != 0;
     }
     if (deviceSettingsKeys.contains("gpioDir")) {
         settings.m_gpioDir = response.getLimeSdrOutputSettings()->getGpioDir() & 0xFF;
     }
     if (deviceSettingsKeys.contains("gpioPins")) {
         settings.m_gpioPins = response.getLimeSdrOutputSettings()->getGpioPins() & 0xFF;
     }
     if (deviceSettingsKeys.contains("useReverseAPI")) {
         settings.m_useReverseAPI = response.getLimeSdrOutputSettings()->getUseReverseApi() != 0;
     }
     if (deviceSettingsKeys.contains("reverseAPIAddress")) {
         settings.m_reverseAPIAddress = *response.getLimeSdrOutputSettings()->getReverseApiAddress();
     }
     if (deviceSettingsKeys.contains("reverseAPIPort")) {
         settings.m_reverseAPIPort = response.getLimeSdrOutputSettings()->getReverseApiPort();
     }
     if (deviceSettingsKeys.contains("reverseAPIDeviceIndex")) {
         settings.m_reverseAPIDeviceIndex = response.getLimeSdrOutputSettings()->getReverseApiDeviceIndex();
     }
 
     MsgConfigureLimeSDR *msg = MsgConfigureLimeSDR::create(settings, force);
     m_inputMessageQueue.push(msg);
 
     if (m_guiMessageQueue) // forward to GUI if any
     {
         MsgConfigureLimeSDR *msgToGUI = MsgConfigureLimeSDR::create(settings, force);
         m_guiMessageQueue->push(msgToGUI);
     }
 
     webapiFormatDeviceSettings(response, settings);
     return 200;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ m_channelAcquired

bool LimeSDROutput::m_channelAcquired

private

Definition at line 245 of file limesdroutput.h.

Referenced by acquireChannel(), applySettings(), and releaseChannel().

◆ m_deviceAPI

DeviceAPI* LimeSDROutput::m_deviceAPI

private

Definition at line 238 of file limesdroutput.h.

Referenced by applySettings(), closeDevice(), handleMessage(), openDevice(), resumeRxBuddies(), resumeTxBuddies(), suspendRxBuddies(), suspendTxBuddies(), webapiReverseSendSettings(), webapiReverseSendStartStop(), webapiRun(), and webapiRunGet().

◆ m_deviceDescription

QString LimeSDROutput::m_deviceDescription

private

Definition at line 242 of file limesdroutput.h.

Referenced by getDeviceDescription().

◆ m_deviceShared

DeviceLimeSDRShared LimeSDROutput::m_deviceShared

private

Definition at line 244 of file limesdroutput.h.

Referenced by acquireChannel(), applySettings(), closeDevice(), getChannelIndex(), getHWLog2Interp(), getLimeType(), getLORange(), getLPRange(), getSRRange(), handleMessage(), openDevice(), releaseChannel(), start(), stop(), and webapiFormatDeviceReport().

◆ m_limeSDROutputThread

LimeSDROutputThread* LimeSDROutput::m_limeSDROutputThread

private

Definition at line 241 of file limesdroutput.h.

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

◆ m_mutex

QMutex LimeSDROutput::m_mutex

private

Definition at line 239 of file limesdroutput.h.

◆ m_networkManager

QNetworkAccessManager* LimeSDROutput::m_networkManager

private

Definition at line 247 of file limesdroutput.h.

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

◆ m_networkRequest

QNetworkRequest LimeSDROutput::m_networkRequest

private

Definition at line 248 of file limesdroutput.h.

Referenced by webapiReverseSendSettings(), and webapiReverseSendStartStop().

◆ m_running

bool LimeSDROutput::m_running

private

Definition at line 243 of file limesdroutput.h.

Referenced by closeDevice(), handleMessage(), start(), stop(), and ~LimeSDROutput().

◆ m_settings

LimeSDROutputSettings LimeSDROutput::m_settings

private

Definition at line 240 of file limesdroutput.h.

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

◆ m_streamId

lms_stream_t LimeSDROutput::m_streamId

private

Definition at line 246 of file limesdroutput.h.

Referenced by acquireChannel(), handleMessage(), releaseChannel(), start(), and webapiFormatDeviceReport().

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

plugins/samplesink/limesdroutput/limesdroutput.h
plugins/samplesink/limesdroutput/limesdroutput.cpp

Classes

Public Member Functions

Private Slots

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ LimeSDROutput()

◆ ~LimeSDROutput()

Member Function Documentation

◆ acquireChannel()

◆ applySettings()

◆ closeDevice()

◆ deserialize()

◆ destroy()

◆ getCenterFrequency()

◆ getChannelIndex()

◆ getDeviceDescription()

◆ getHWLog2Interp()

◆ getLimeType()

◆ getLORange()

◆ getLPRange()

◆ getSampleRate()

◆ getSRRange()

◆ handleMessage()

◆ init()

◆ networkManagerFinished

◆ openDevice()

◆ releaseChannel()

◆ resumeRxBuddies()

◆ resumeTxBuddies()

◆ serialize()

◆ setCenterFrequency()

◆ setMessageQueueToGUI()

◆ setSampleRate()

◆ start()

◆ stop()

◆ suspendRxBuddies()

◆ suspendTxBuddies()

◆ webapiFormatDeviceReport()

◆ webapiFormatDeviceSettings()

◆ webapiReportGet()

◆ webapiReverseSendSettings()

◆ webapiReverseSendStartStop()

◆ webapiRun()

◆ webapiRunGet()

◆ webapiSettingsGet()

◆ webapiSettingsPutPatch()

Member Data Documentation

◆ m_channelAcquired

◆ m_deviceAPI

◆ m_deviceDescription

◆ m_deviceShared

◆ m_limeSDROutputThread

◆ m_mutex

◆ m_networkManager

◆ m_networkRequest

◆ m_running

◆ m_settings

◆ m_streamId