#include <limesdrinput.h>

Inheritance diagram for LimeSDRInput:

Collaboration diagram for LimeSDRInput:

Classes
class	MsgConfigureLimeSDR

class	MsgFileRecord

class	MsgGetDeviceInfo

class	MsgGetStreamInfo

class	MsgReportStreamInfo

class	MsgStartStop

Public Member Functions
	LimeSDRInput (DeviceAPI *deviceAPI)

virtual	~LimeSDRInput ()

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 source. More...

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

virtual quint64	getCenterFrequency () const
	Center frequency exposed by the source. 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	getHWLog2Decim () const

DeviceLimeSDRParams::LimeType	getLimeType () const

Public Member Functions inherited from DeviceSampleSource
	DeviceSampleSource ()

virtual	~DeviceSampleSource ()

MessageQueue *	getInputMessageQueue ()

MessageQueue *	getMessageQueueToGUI ()

SampleSinkFifo *	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 LimeSDRInputSettings &settings, bool force=false, bool forceNCOFrequency=false)

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

void	webapiFormatDeviceReport (SWGSDRangel::SWGDeviceReport &response)

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

void	webapiReverseSendStartStop (bool start)

Private Attributes
DeviceAPI *	m_deviceAPI

QMutex	m_mutex

LimeSDRInputSettings	m_settings

LimeSDRInputThread *	m_limeSDRInputThread

QString	m_deviceDescription

bool	m_running

DeviceLimeSDRShared	m_deviceShared

bool	m_channelAcquired

lms_stream_t	m_streamId

FileRecord *	m_fileSink
	File sink to record device I/Q output. More...

QNetworkAccessManager *	m_networkManager

QNetworkRequest	m_networkRequest

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

enum	FrequencyShiftScheme { FSHIFT_STD = 0, FSHIFT_TXSYNC }

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

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

static qint32	calculateFrequencyShift (int log2Decim, fcPos_t fcPos, quint32 devSampleRate, FrequencyShiftScheme frequencyShiftScheme)

Protected Slots inherited from DeviceSampleSource
void	handleInputMessages ()

Protected Attributes inherited from DeviceSampleSource
SampleSinkFifo	m_sampleFifo

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

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

Detailed Description

Definition at line 37 of file limesdrinput.h.

Constructor & Destructor Documentation

◆ LimeSDRInput()

LimeSDRInput::LimeSDRInput ( DeviceAPI * deviceAPI )

Definition at line 51 of file limesdrinput.cpp.

References arg().

Referenced by LimeSDRInput::MsgStartStop::MsgStartStop().

                                                :
     m_deviceAPI(deviceAPI),
     m_settings(),
     m_limeSDRInputThread(0),
     m_deviceDescription("LimeSDRInput"),
     m_running(false),
     m_channelAcquired(false)
 {
     m_streamId.handle = 0;
     suspendRxBuddies();
     suspendTxBuddies();
     openDevice();
     resumeTxBuddies();
     resumeRxBuddies();
 
     m_fileSink = new FileRecord(QString("test_%1.sdriq").arg(m_deviceAPI->getDeviceUID()));
     m_deviceAPI->setNbSourceStreams(1);
     m_deviceAPI->addAncillarySink(m_fileSink);
 
     m_networkManager = new QNetworkAccessManager();
     connect(m_networkManager, SIGNAL(finished(QNetworkReply*)), this, SLOT(networkManagerFinished(QNetworkReply*)));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ~LimeSDRInput()

LimeSDRInput::~LimeSDRInput ( )

virtual

Definition at line 74 of file limesdrinput.cpp.

References closeDevice(), m_deviceAPI, m_fileSink, m_networkManager, m_running, networkManagerFinished(), DeviceAPI::removeAncillarySink(), resumeRxBuddies(), resumeTxBuddies(), stop(), suspendRxBuddies(), and suspendTxBuddies().

Referenced by LimeSDRInput::MsgStartStop::MsgStartStop().

 {
     disconnect(m_networkManager, SIGNAL(finished(QNetworkReply*)), this, SLOT(networkManagerFinished(QNetworkReply*)));
     delete m_networkManager;
 
     if (m_running) {
         stop();
     }
 
     m_deviceAPI->removeAncillarySink(m_fileSink);
     delete m_fileSink;
     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 LimeSDRInput::acquireChannel ( )

private

Definition at line 316 of file limesdrinput.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_RX, m_deviceShared.m_channel, true) != 0)
     {
         qCritical("LimeSDRInput::acquireChannel: cannot enable Rx channel %d", m_deviceShared.m_channel);
         return false;
     }
     else
     {
         qDebug("LimeSDRInput::acquireChannel: Rx 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 = false;                        // RX 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("LimeSDRInput::acquireChannel: cannot setup the stream on Rx channel %d", m_deviceShared.m_channel);
         resumeTxBuddies();
         resumeRxBuddies();
         return false;
     }
     else
     {
         qDebug("LimeSDRInput::acquireChannel: stream set up on Rx 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 LimeSDRInput::applySettings	(	const LimeSDRInputSettings &	settings,
		bool	force = `false`,
		bool	forceNCOFrequency = `false`
	)

private

Definition at line 797 of file limesdrinput.cpp.

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

 {
     bool forwardChangeOwnDSP = false;
     bool forwardChangeRxDSP  = false;
     bool forwardChangeAllDSP = false;
     bool forwardClockSource  = false;
     bool forwardGPIOChange   = false;
     bool ownThreadWasRunning = false;
     bool doCalibration = false;
     bool doLPCalibration = false;
     bool setAntennaAuto = 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("LimeSDRInput::applySettings: could not get clock gen frequency");
     }
     else
     {
         qDebug() << "LimeSDRInput::applySettings: clock gen frequency: " << clockGenFreq;
     }
 
     // apply settings
 
     if ((m_settings.m_dcBlock != settings.m_dcBlock) || force)
     {
         reverseAPIKeys.append("dcBlock");
         m_deviceAPI->configureCorrections(settings.m_dcBlock, settings.m_iqCorrection);
     }
 
     if ((m_settings.m_iqCorrection != settings.m_iqCorrection) || force)
     {
         reverseAPIKeys.append("iqCorrection");
         m_deviceAPI->configureCorrections(settings.m_dcBlock, settings.m_iqCorrection);
     }
 
     if ((m_settings.m_gainMode != settings.m_gainMode) || force)
     {
         reverseAPIKeys.append("gainMode");
 
         if (settings.m_gainMode == LimeSDRInputSettings::GAIN_AUTO)
         {
             if (m_deviceShared.m_deviceParams->getDevice() != 0 && m_channelAcquired)
             {
                 if (LMS_SetGaindB(m_deviceShared.m_deviceParams->getDevice(),
                         LMS_CH_RX,
                         m_deviceShared.m_channel,
                         settings.m_gain) < 0)
                 {
                     qDebug("LimeSDRInput::applySettings: LMS_SetGaindB() failed");
                 }
                 else
                 {
                     doCalibration = true;
                     qDebug() << "LimeSDRInput::applySettings: Gain (auto) set to " << settings.m_gain;
                 }
             }
         }
         else
         {
             if (m_deviceShared.m_deviceParams->getDevice() != 0 && m_channelAcquired)
             {
                 if (DeviceLimeSDR::SetRFELNA_dB(m_deviceShared.m_deviceParams->getDevice(),
                         m_deviceShared.m_channel,
                         settings.m_lnaGain))
                 {
                     doCalibration = true;
                     qDebug() << "LimeSDRInput::applySettings: LNA gain (manual) set to " << settings.m_lnaGain;
                 }
                 else
                 {
                     qDebug("LimeSDRInput::applySettings: DeviceLimeSDR::SetRFELNA_dB() failed");
                 }
 
                 if (DeviceLimeSDR::SetRFETIA_dB(m_deviceShared.m_deviceParams->getDevice(),
                         m_deviceShared.m_channel,
                         settings.m_tiaGain))
                 {
                     doCalibration = true;
                     qDebug() << "LimeSDRInput::applySettings: TIA gain (manual) set to " << settings.m_tiaGain;
                 }
                 else
                 {
                     qDebug("LimeSDRInput::applySettings: DeviceLimeSDR::SetRFETIA_dB() failed");
                 }
 
                 if (DeviceLimeSDR::SetRBBPGA_dB(m_deviceShared.m_deviceParams->getDevice(),
                         m_deviceShared.m_channel,
                         settings.m_pgaGain))
                 {
                     doCalibration = true;
                     qDebug() << "LimeSDRInput::applySettings: PGA gain (manual) set to " << settings.m_pgaGain;
                 }
                 else
                 {
                     qDebug("LimeSDRInput::applySettings: DeviceLimeSDR::SetRBBPGA_dB() failed");
                 }
             }
         }
     }
 
     if ((m_settings.m_gainMode == LimeSDRInputSettings::GAIN_AUTO) && (m_settings.m_gain != settings.m_gain))
     {
         reverseAPIKeys.append("gain");
 
         if (m_deviceShared.m_deviceParams->getDevice() != 0 && m_channelAcquired)
         {
             if (LMS_SetGaindB(m_deviceShared.m_deviceParams->getDevice(),
                     LMS_CH_RX,
                     m_deviceShared.m_channel,
                     settings.m_gain) < 0)
             {
                 qDebug("LimeSDRInput::applySettings: LMS_SetGaindB() failed");
             }
             else
             {
                 doCalibration = true;
                 qDebug() << "LimeSDRInput::applySettings: Gain (auto) set to " << settings.m_gain;
             }
         }
     }
 
     if ((m_settings.m_gainMode == LimeSDRInputSettings::GAIN_MANUAL) && (m_settings.m_lnaGain != settings.m_lnaGain))
     {
         reverseAPIKeys.append("lnaGain");
 
         if (m_deviceShared.m_deviceParams->getDevice() != 0 && m_channelAcquired)
         {
             if (DeviceLimeSDR::SetRFELNA_dB(m_deviceShared.m_deviceParams->getDevice(),
                     m_deviceShared.m_channel,
                     settings.m_lnaGain))
             {
                 doCalibration = true;
                 qDebug() << "LimeSDRInput::applySettings: LNA gain (manual) set to " << settings.m_lnaGain;
             }
             else
             {
                 qDebug("LimeSDRInput::applySettings: DeviceLimeSDR::SetRFELNA_dB() failed");
             }
         }
     }
 
     if ((m_settings.m_gainMode == LimeSDRInputSettings::GAIN_MANUAL) && (m_settings.m_tiaGain != settings.m_tiaGain))
     {
         reverseAPIKeys.append("tiaGain");
 
         if (m_deviceShared.m_deviceParams->getDevice() != 0 && m_channelAcquired)
         {
             if (DeviceLimeSDR::SetRFETIA_dB(m_deviceShared.m_deviceParams->getDevice(),
                     m_deviceShared.m_channel,
                     settings.m_tiaGain))
             {
                 doCalibration = true;
                 qDebug() << "LimeSDRInput::applySettings: TIA gain (manual) set to " << settings.m_tiaGain;
             }
             else
             {
                 qDebug("LimeSDRInput::applySettings: DeviceLimeSDR::SetRFETIA_dB() failed");
             }
         }
     }
 
     if ((m_settings.m_gainMode == LimeSDRInputSettings::GAIN_MANUAL) && (m_settings.m_pgaGain != settings.m_pgaGain))
     {
         reverseAPIKeys.append("pgaGain");
 
         if (m_deviceShared.m_deviceParams->getDevice() != 0 && m_channelAcquired)
         {
             if (DeviceLimeSDR::SetRBBPGA_dB(m_deviceShared.m_deviceParams->getDevice(),
                     m_deviceShared.m_channel,
                     settings.m_pgaGain))
             {
                 doCalibration = true;
                 qDebug() << "LimeSDRInput::applySettings: PGA gain (manual) set to " << settings.m_pgaGain;
             }
             else
             {
                 qDebug("LimeSDRInput::applySettings: DeviceLimeSDR::SetRBBPGA_dB() failed");
             }
         }
     }
 
     if ((m_settings.m_devSampleRate != settings.m_devSampleRate)
        || (m_settings.m_log2HardDecim != settings.m_log2HardDecim) || force)
     {
         reverseAPIKeys.append("devSampleRate");
         reverseAPIKeys.append("log2HardDecim");
         forwardChangeAllDSP = true; //m_settings.m_devSampleRate != settings.m_devSampleRate;
 
         if (m_deviceShared.m_deviceParams->getDevice() != 0 && m_channelAcquired)
         {
             if (LMS_SetSampleRateDir(m_deviceShared.m_deviceParams->getDevice(),
                     LMS_CH_RX,
                     settings.m_devSampleRate,
                     1<<settings.m_log2HardDecim) < 0)
             {
                 qCritical("LimeSDRInput::applySettings: could not set sample rate to %d with oversampling of %d",
                         settings.m_devSampleRate,
                         1<<settings.m_log2HardDecim);
             }
             else
             {
                 m_deviceShared.m_deviceParams->m_log2OvSRRx = settings.m_log2HardDecim;
                 m_deviceShared.m_deviceParams->m_sampleRate = settings.m_devSampleRate;
                 //doCalibration = true;
                 forceNCOFrequency = true;
                 qDebug("LimeSDRInput::applySettings: set sample rate set to %d with oversampling of %d",
                         settings.m_devSampleRate,
                         1<<settings.m_log2HardDecim);
             }
         }
     }
 
     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_RX,
                     m_deviceShared.m_channel,
                     settings.m_lpfFIREnable,
                     settings.m_lpfFIRBW) < 0)
             {
                 qCritical("LimeSDRInput::applySettings: could %s and set LPF FIR to %f Hz",
                         settings.m_lpfFIREnable ? "enable" : "disable",
                         settings.m_lpfFIRBW);
             }
             else
             {
                 //doCalibration = true;
                 qDebug("LimeSDRInput::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_RX,
                     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("LimeSDRInput::applySettings: %sd and set NCO to %d Hz",
                         settings.m_ncoEnable ? "enable" : "disable",
                         settings.m_ncoFrequency);
             }
             else
             {
                 qCritical("LimeSDRInput::applySettings: could not %s and set NCO to %d Hz",
                         settings.m_ncoEnable ? "enable" : "disable",
                         settings.m_ncoFrequency);
             }
         }
     }
 
     if ((m_settings.m_log2SoftDecim != settings.m_log2SoftDecim) || force)
     {
         reverseAPIKeys.append("log2SoftDecim");
         forwardChangeOwnDSP = true;
         m_deviceShared.m_log2Soft = settings.m_log2SoftDecim; // for buddies
 
         if (m_limeSDRInputThread != 0)
         {
             m_limeSDRInputThread->setLog2Decimation(settings.m_log2SoftDecim);
             qDebug() << "LimeSDRInput::applySettings: set soft decimation to " << (1<<settings.m_log2SoftDecim);
         }
     }
 
     if ((m_settings.m_antennaPath != settings.m_antennaPath) || force)
     {
         reverseAPIKeys.append("antennaPath");
 
         if (m_deviceShared.m_deviceParams->getDevice() != 0 && m_channelAcquired)
         {
             if (DeviceLimeSDR::setRxAntennaPath(m_deviceShared.m_deviceParams->getDevice(),
                     m_deviceShared.m_channel,
                     settings.m_antennaPath))
             {
                 doCalibration = true;
                 //setAntennaAuto = (settings.m_antennaPath == 0);
                 qDebug("LimeSDRInput::applySettings: set antenna path to %d on channel %d",
                         (int) settings.m_antennaPath,
                         m_deviceShared.m_channel);
             }
             else
             {
                 qCritical("LimeSDRInput::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)
         || setAntennaAuto || force)
     {
         reverseAPIKeys.append("centerFrequency");
         reverseAPIKeys.append("transverterMode");
         reverseAPIKeys.append("transverterDeltaFrequency");
         forwardChangeRxDSP = true;
 
         if (m_deviceShared.m_deviceParams->getDevice() != 0 && m_channelAcquired)
         {
             if (LMS_SetClockFreq(m_deviceShared.m_deviceParams->getDevice(), LMS_CLOCK_SXR, deviceCenterFrequency) < 0)
             {
                 qCritical("LimeSDRInput::applySettings: could not set frequency to %lld", deviceCenterFrequency);
             }
             else
             {
                 doCalibration = true;
                 m_deviceShared.m_centerFrequency = deviceCenterFrequency; // for buddies
                 qDebug("LimeSDRInput::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("LimeSDRInput::applySettings: clock set to %s (Ext: %d Hz)",
                     settings.m_extClock ? "external" : "internal",
                     settings.m_extClockFreq);
         }
         else
         {
             qCritical("LimeSDRInput::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("LimeSDRInput::applySettings: could not get clock gen frequency");
     }
     else
     {
         qDebug() << "LimeSDRInput::applySettings: clock gen frequency after: " << clockGenFreqAfter;
         doCalibration = doCalibration || (clockGenFreqAfter != clockGenFreq);
     }
 
     if (doCalibration || doLPCalibration)
     {
         if (m_limeSDRInputThread && m_limeSDRInputThread->isRunning())
         {
             m_limeSDRInputThread->stopWork();
             ownThreadWasRunning = true;
         }
 
         suspendRxBuddies();
         suspendTxBuddies();
 
         if (doCalibration)
         {
             if (LMS_Calibrate(m_deviceShared.m_deviceParams->getDevice(),
                     LMS_CH_RX,
                     m_deviceShared.m_channel,
                     m_settings.m_devSampleRate,
                     0) < 0)
             {
                 qCritical("LimeSDRInput::applySettings: calibration failed on Rx channel %d", m_deviceShared.m_channel);
             }
             else
             {
                 qDebug("LimeSDRInput::applySettings: calibration successful on Rx channel %d", m_deviceShared.m_channel);
             }
         }
 
         if (doLPCalibration)
         {
             if (LMS_SetLPFBW(m_deviceShared.m_deviceParams->getDevice(),
                     LMS_CH_RX,
                     m_deviceShared.m_channel,
                     m_settings.m_lpfBW) < 0)
             {
                 qCritical("LimeSDRInput::applySettings: could not set LPF to %f Hz", m_settings.m_lpfBW);
             }
             else
             {
                 qDebug("LimeSDRInput::applySettings: LPF set to %f Hz", m_settings.m_lpfBW);
             }
         }
 
         resumeTxBuddies();
         resumeRxBuddies();
 
         if (ownThreadWasRunning) {
             m_limeSDRInputThread->startWork();
         }
     }
 
     // forward changes to buddies or oneself
 
     if (forwardChangeAllDSP)
     {
         qDebug("LimeSDRInput::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_log2SoftDecim),
                 m_settings.m_centerFrequency + ncoShift);
         m_deviceAPI->getDeviceEngineInputMessageQueue()->push(notif);
 
         // 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_log2HardDecim, m_settings.m_centerFrequency, true);
             (*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::MsgReportBuddyChange *report = DeviceLimeSDRShared::MsgReportBuddyChange::create(
                     m_settings.m_devSampleRate, m_settings.m_log2HardDecim, m_settings.m_centerFrequency, true);
             (*itSink)->getSamplingDeviceInputMessageQueue()->push(report);
         }
     }
     else if (forwardChangeRxDSP)
     {
         qDebug("LimeSDRInput::applySettings: forward change to Rx buddies");
 
         int sampleRate = m_settings.m_devSampleRate/(1<<m_settings.m_log2SoftDecim);
         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 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_log2HardDecim, m_settings.m_centerFrequency, true);
             (*itSource)->getSamplingDeviceInputMessageQueue()->push(report);
         }
     }
     else if (forwardChangeOwnDSP)
     {
         qDebug("LimeSDRInput::applySettings: forward change to self only");
 
         int sampleRate = m_settings.m_devSampleRate/(1<<m_settings.m_log2SoftDecim);
         int ncoShift = m_settings.m_ncoEnable ? m_settings.m_ncoFrequency : 0;
         DSPSignalNotification *notif = new DSPSignalNotification(sampleRate, m_settings.m_centerFrequency + ncoShift);
         m_fileSink->handleMessage(*notif); // forward to file sink
         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)
     {
         // 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);
         }
     }
 
     QLocale loc;
 
     qDebug().noquote() << "LimeSDRInput::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 decimation: " << loc.toString( m_settings.m_devSampleRate/(1<<m_settings.m_log2SoftDecim)) << "S/s"
             << " ADC sample rate with hard decimation: " << loc.toString(m_settings.m_devSampleRate*(1<<m_settings.m_log2HardDecim)) << "S/s"
             << " m_log2HardDecim: " << m_settings.m_log2HardDecim
             << " m_log2SoftDecim: " << m_settings.m_log2SoftDecim
             << " 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 LimeSDRInput::closeDevice ( )

private

Definition at line 296 of file limesdrinput.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 ~LimeSDRInput().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ deserialize()

bool LimeSDRInput::deserialize ( const QByteArray & data )

virtual

Implements DeviceSampleSource.

Definition at line 454 of file limesdrinput.cpp.

References LimeSDRInput::MsgConfigureLimeSDR::create(), LimeSDRInputSettings::deserialize(), DeviceSampleSource::m_guiMessageQueue, DeviceSampleSource::m_inputMessageQueue, m_settings, MessageQueue::push(), and LimeSDRInputSettings::resetToDefaults().

Referenced by LimeSDRInput::MsgStartStop::MsgStartStop().

 {
     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 LimeSDRInput::destroy ( )

virtual

Implements DeviceSampleSource.

Definition at line 92 of file limesdrinput.cpp.

Referenced by LimeSDRInput::MsgStartStop::MsgStartStop().

 {
     delete this;
 }

Here is the caller graph for this function:

◆ getCenterFrequency()

quint64 LimeSDRInput::getCenterFrequency ( ) const

virtual

Center frequency exposed by the source.

Implements DeviceSampleSource.

Definition at line 487 of file limesdrinput.cpp.

References LimeSDRInputSettings::m_centerFrequency, LimeSDRInputSettings::m_ncoEnable, LimeSDRInputSettings::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 LimeSDRInput::getChannelIndex ( )

Definition at line 507 of file limesdrinput.cpp.

References DeviceLimeSDRShared::m_channel, and m_deviceShared.

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

 {
     return m_deviceShared.m_channel;
 }

Here is the caller graph for this function:

◆ getDeviceDescription()

const QString & LimeSDRInput::getDeviceDescription ( ) const

virtual

Implements DeviceSampleSource.

Definition at line 476 of file limesdrinput.cpp.

References m_deviceDescription.

Referenced by setMessageQueueToGUI().

 {
     return m_deviceDescription;
 }

Here is the caller graph for this function:

◆ getHWLog2Decim()

uint32_t LimeSDRInput::getHWLog2Decim ( ) const

Definition at line 536 of file limesdrinput.cpp.

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

Referenced by setSampleRate().

 {
     return m_deviceShared.m_deviceParams->m_log2OvSRRx;
 }

Here is the caller graph for this function:

◆ getLimeType()

DeviceLimeSDRParams::LimeType LimeSDRInput::getLimeType ( ) const

Definition at line 541 of file limesdrinput.cpp.

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

Referenced by LimeSDRInputGUI::LimeSDRInputGUI(), 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 LimeSDRInput::getLORange	(	float &	minF,
		float &	maxF
	)		const

Definition at line 512 of file limesdrinput.cpp.

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

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

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

Here is the caller graph for this function:

◆ getLPRange()

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

Definition at line 528 of file limesdrinput.cpp.

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

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

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

Here is the caller graph for this function:

◆ getSampleRate()

int LimeSDRInput::getSampleRate ( ) const

virtual

Sample rate exposed by the source.

Implements DeviceSampleSource.

Definition at line 481 of file limesdrinput.cpp.

References LimeSDRInputSettings::m_devSampleRate, LimeSDRInputSettings::m_log2SoftDecim, and m_settings.

Referenced by setMessageQueueToGUI().

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

Here is the caller graph for this function:

◆ getSRRange()

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

Definition at line 520 of file limesdrinput.cpp.

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

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

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

Here is the caller graph for this function:

◆ handleMessage()

bool LimeSDRInput::handleMessage ( const Message & message )

virtual

Implements DeviceSampleSource.

Definition at line 550 of file limesdrinput.cpp.

Referenced by setSampleRate().

 {
     if (MsgConfigureLimeSDR::match(message))
     {
         MsgConfigureLimeSDR& conf = (MsgConfigureLimeSDR&) message;
         qDebug() << "LimeSDRInput::handleMessage: MsgConfigureLimeSDR";
 
         if (!applySettings(conf.getSettings(), conf.getForce()))
         {
             qDebug("LimeSDRInput::handleMessage config error");
         }
 
         return true;
     }
     else if (DeviceLimeSDRShared::MsgReportBuddyChange::match(message))
     {
         DeviceLimeSDRShared::MsgReportBuddyChange& report = (DeviceLimeSDRShared::MsgReportBuddyChange&) message;
 
         if (report.getRxElseTx())
         {
             m_settings.m_devSampleRate   = report.getDevSampleRate();
             m_settings.m_log2HardDecim   = report.getLog2HardDecimInterp();
             m_settings.m_centerFrequency = report.getCenterFrequency();
         }
         else if (m_running)
         {
             double host_Hz;
             double rf_Hz;
 
             if (LMS_GetSampleRate(m_deviceShared.m_deviceParams->getDevice(),
                     LMS_CH_RX,
                     m_deviceShared.m_channel,
                     &host_Hz,
                     &rf_Hz) < 0)
             {
                 qDebug("LimeSDRInput::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_log2HardDecim = log2(hard);
 
                 qDebug() << "LimeSDRInput::handleMessage: MsgReportBuddyChange:"
                          << " host_Hz: " << host_Hz
                          << " rf_Hz: " << rf_Hz
                          << " m_devSampleRate: " << m_settings.m_devSampleRate
                          << " log2Hard: " << hard
                          << " m_log2HardDecim: " << m_settings.m_log2HardDecim;
 //                int adcdac_rate = report.getDevSampleRate() * (1<<report.getLog2HardDecimInterp());
 //                m_settings.m_devSampleRate = adcdac_rate / (1<<m_settings.m_log2HardDecim); // new device to host sample rate
             }
         }
 
         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_log2SoftDecim),
                 m_settings.m_centerFrequency + ncoShift);
         m_deviceAPI->getDeviceEngineInputMessageQueue()->push(notif);
 
         if (getMessageQueueToGUI())
         {
             DeviceLimeSDRShared::MsgReportBuddyChange *reportToGUI = DeviceLimeSDRShared::MsgReportBuddyChange::create(
                     m_settings.m_devSampleRate, m_settings.m_log2HardDecim, m_settings.m_centerFrequency, true);
             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() << "LimeSDRInput::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("LimeSDRInput::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 (m_deviceAPI->getSamplingDeviceGUIMessageQueue())
         {
             DeviceLimeSDRShared::MsgReportDeviceInfo *report = DeviceLimeSDRShared::MsgReportDeviceInfo::create(temp, gpioPins);
             m_deviceAPI->getSamplingDeviceGUIMessageQueue()->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 if (MsgFileRecord::match(message))
     {
         MsgFileRecord& conf = (MsgFileRecord&) message;
         qDebug() << "LimeSDRInput::handleMessage: MsgFileRecord: " << conf.getStartStop();
 
         if (conf.getStartStop())
         {
             if (m_settings.m_fileRecordName.size() != 0) {
                 m_fileSink->setFileName(m_settings.m_fileRecordName);
             } else {
                 m_fileSink->genUniqueFileName(m_deviceAPI->getDeviceUID());
             }
 
             m_fileSink->startRecording();
         }
         else
         {
             m_fileSink->stopRecording();
         }
 
         return true;
     }
     else if (MsgStartStop::match(message))
     {
         MsgStartStop& cmd = (MsgStartStop&) message;
         qDebug() << "LimeSDRInput::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
     {
         return false;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init()

void LimeSDRInput::init ( )

virtual

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

Implements DeviceSampleSource.

Definition at line 397 of file limesdrinput.cpp.

References applySettings(), and m_settings.

Referenced by LimeSDRInput::MsgStartStop::MsgStartStop().

 {
     applySettings(m_settings, true, false);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ networkManagerFinished

void LimeSDRInput::networkManagerFinished ( QNetworkReply * reply )

privateslot

Definition at line 1797 of file limesdrinput.cpp.

Referenced by ~LimeSDRInput().

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

Here is the caller graph for this function:

◆ openDevice()

bool LimeSDRInput::openDevice ( )

private

Definition at line 97 of file limesdrinput.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_nbRxChannels, DeviceSampleSource::m_sampleFifo, DeviceLimeSDRParams::open(), DeviceAPI::setBuddySharedPtr(), and SampleSinkFifo::setSize().

 {
     if (!m_sampleFifo.setSize(96000 * 4))
     {
         qCritical("LimeSDRInput::openDevice: could not allocate SampleFifo");
         return false;
     }
     else
     {
         qDebug("LimeSDRInput::openDevice: allocated SampleFifo");
     }
 
     int requestedChannel = m_deviceAPI->getDeviceItemIndex();
 
     // look for Rx buddies and get reference to common parameters
     // if there is a channel left take the first available
     if (m_deviceAPI->getSourceBuddies().size() > 0) // look source sibling first
     {
         qDebug("LimeSDRInput::openDevice: look in Rx buddies");
 
         DeviceAPI *sourceBuddy = m_deviceAPI->getSourceBuddies()[0];
         //m_deviceShared = *((DeviceLimeSDRShared *) sourceBuddy->getBuddySharedPtr()); // copy shared data
         DeviceLimeSDRShared *deviceLimeSDRShared = (DeviceLimeSDRShared*) sourceBuddy->getBuddySharedPtr();
 
         if (deviceLimeSDRShared == 0)
         {
             qCritical("LimeSDRInput::openDevice: the source buddy shared pointer is null");
             return false;
         }
 
         m_deviceShared.m_deviceParams = deviceLimeSDRShared->m_deviceParams;
 
         DeviceLimeSDRParams *deviceParams = m_deviceShared.m_deviceParams; // get device parameters
 
         if (deviceParams == 0)
         {
             qCritical("LimeSDRInput::openDevice: cannot get device parameters from Rx buddy");
             return false; // the device params should have been created by the buddy
         }
         else
         {
             qDebug("LimeSDRInput::openDevice: getting device parameters from Rx buddy");
         }
 
         if (m_deviceAPI->getSourceBuddies().size() == deviceParams->m_nbRxChannels)
         {
             qCritical("LimeSDRInput::openDevice: no more Rx channels available in device");
             return false; // no more Rx channels available in device
         }
         else
         {
             qDebug("LimeSDRInput::openDevice: at least one more Rx 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->getSourceBuddies().size(); i++)
         {
             DeviceAPI *buddy = m_deviceAPI->getSourceBuddies()[i];
             DeviceLimeSDRShared *buddyShared = (DeviceLimeSDRShared *) buddy->getBuddySharedPtr();
 
             if (buddyShared->m_channel == requestedChannel)
             {
                 qCritical("LimeSDRInput::openDevice: cannot open busy channel %u", requestedChannel);
                 return false;
             }
         }
 
         m_deviceShared.m_channel = requestedChannel; // acknowledge the requested channel
     }
     // look for Tx buddies and get reference to common parameters
     // take the first Rx channel
     else if (m_deviceAPI->getSinkBuddies().size() > 0) // then sink
     {
         qDebug("LimeSDRInput::openDevice: look in Tx buddies");
 
         DeviceAPI *sinkBuddy = m_deviceAPI->getSinkBuddies()[0];
         //m_deviceShared = *((DeviceLimeSDRShared *) sinkBuddy->getBuddySharedPtr()); // copy parameters
         DeviceLimeSDRShared *deviceLimeSDRShared = (DeviceLimeSDRShared*) sinkBuddy->getBuddySharedPtr();
 
         if (deviceLimeSDRShared == 0)
         {
             qCritical("LimeSDRInput::openDevice: the sink buddy shared pointer is null");
             return false;
         }
 
         m_deviceShared.m_deviceParams = deviceLimeSDRShared->m_deviceParams;
 
         if (m_deviceShared.m_deviceParams == 0)
         {
             qCritical("LimeSDRInput::openDevice: cannot get device parameters from Tx buddy");
             return false; // the device params should have been created by the buddy
         }
         else
         {
             qDebug("LimeSDRInput::openDevice: getting device parameters from Tx 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 Rx channel
     else
     {
         qDebug("LimeSDRInput::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 LimeSDRInput::releaseChannel ( )

private

Definition at line 361 of file limesdrinput.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("LimeSDRInput::releaseChannel: cannot destroy the stream on Rx channel %d", m_deviceShared.m_channel);
     }
     else
     {
         qDebug("LimeSDRInput::releaseChannel: stream destroyed on Rx channel %d", m_deviceShared.m_channel);
     }
 
     m_streamId.handle = 0;
 
     // release the channel
 
     if (LMS_EnableChannel(m_deviceShared.m_deviceParams->getDevice(), LMS_CH_RX, m_deviceShared.m_channel, false) != 0)
     {
         qWarning("LimeSDRInput::releaseChannel: cannot disable Rx channel %d", m_deviceShared.m_channel);
     }
     else
     {
         qDebug("LimeSDRInput::releaseChannel: Rx channel %d disabled", m_deviceShared.m_channel);
     }
 
     resumeTxBuddies();
     resumeRxBuddies();
 
     // The channel will be effectively released to be reused in another device set only at close time
 
     m_channelAcquired = false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ resumeRxBuddies()

void LimeSDRInput::resumeRxBuddies ( )

private

Definition at line 262 of file limesdrinput.cpp.

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

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

 {
     const std::vector<DeviceAPI*>& sourceBuddies = m_deviceAPI->getSourceBuddies();
     std::vector<DeviceAPI*>::const_iterator itSource = sourceBuddies.begin();
 
     qDebug("LimeSDRInput::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 LimeSDRInput::resumeTxBuddies ( )

private

Definition at line 279 of file limesdrinput.cpp.

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

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

 {
     const std::vector<DeviceAPI*>& sinkBuddies = m_deviceAPI->getSinkBuddies();
     std::vector<DeviceAPI*>::const_iterator itSink = sinkBuddies.begin();
 
     qDebug("LimeSDRInput::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 LimeSDRInput::serialize ( ) const

virtual

Implements DeviceSampleSource.

Definition at line 449 of file limesdrinput.cpp.

References m_settings, and LimeSDRInputSettings::serialize().

Referenced by LimeSDRInput::MsgStartStop::MsgStartStop().

 {
     return m_settings.serialize();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setCenterFrequency()

void LimeSDRInput::setCenterFrequency ( qint64 centerFrequency )

virtual

Implements DeviceSampleSource.

Definition at line 492 of file limesdrinput.cpp.

References LimeSDRInput::MsgConfigureLimeSDR::create(), LimeSDRInputSettings::m_centerFrequency, DeviceSampleSource::m_guiMessageQueue, DeviceSampleSource::m_inputMessageQueue, LimeSDRInputSettings::m_ncoEnable, LimeSDRInputSettings::m_ncoFrequency, m_settings, and MessageQueue::push().

Referenced by setSampleRate().

 {
     LimeSDRInputSettings 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 LimeSDRInput::setMessageQueueToGUI ( MessageQueue * queue )

inlinevirtual

Implements DeviceSampleSource.

Definition at line 218 of file limesdrinput.h.

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

Referenced by LimeSDRInputGUI::LimeSDRInputGUI().

218 { m_guiMessageQueue = queue; }

DeviceSampleSource::m_guiMessageQueue

MessageQueue * m_guiMessageQueue

Input message queue to the GUI.

Definition: devicesamplesource.h:158

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setSampleRate()

virtual void LimeSDRInput::setSampleRate ( int sampleRate )

inlinevirtual

For when the source sample rate is set externally.

Implements DeviceSampleSource.

Definition at line 221 of file limesdrinput.h.

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

221 { (void) sampleRate; }

Here is the call graph for this function:

◆ start()

bool LimeSDRInput::start ( )

virtual

Implements DeviceSampleSource.

Definition at line 402 of file limesdrinput.cpp.

References acquireChannel(), applySettings(), DeviceLimeSDRParams::getDevice(), DeviceLimeSDRShared::m_deviceParams, m_deviceShared, m_limeSDRInputThread, LimeSDRInputSettings::m_log2SoftDecim, m_running, DeviceSampleSource::m_sampleFifo, m_settings, m_streamId, DeviceLimeSDRShared::m_thread, LimeSDRInputThread::setLog2Decimation(), LimeSDRInputThread::startWork(), and stop().

Referenced by LimeSDRInput::MsgStartStop::MsgStartStop().

 {
     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_limeSDRInputThread = new LimeSDRInputThread(&m_streamId, &m_sampleFifo);
     qDebug("LimeSDRInput::start: thread created");
 
     applySettings(m_settings, true);
 
     m_limeSDRInputThread->setLog2Decimation(m_settings.m_log2SoftDecim);
 
     m_limeSDRInputThread->startWork();
 
     m_deviceShared.m_thread = m_limeSDRInputThread;
     m_running = true;
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ stop()

void LimeSDRInput::stop ( )

virtual

Implements DeviceSampleSource.

Definition at line 432 of file limesdrinput.cpp.

References m_deviceShared, m_limeSDRInputThread, m_running, DeviceLimeSDRShared::m_thread, releaseChannel(), and LimeSDRInputThread::stopWork().

Referenced by closeDevice(), LimeSDRInput::MsgStartStop::MsgStartStop(), start(), and ~LimeSDRInput().

 {
     qDebug("LimeSDRInput::stop");
 
     if (m_limeSDRInputThread != 0)
     {
         m_limeSDRInputThread->stopWork();
         delete m_limeSDRInputThread;
         m_limeSDRInputThread = 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 LimeSDRInput::suspendRxBuddies ( )

private

Definition at line 216 of file limesdrinput.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 ~LimeSDRInput().

 {
     const std::vector<DeviceAPI*>& sourceBuddies = m_deviceAPI->getSourceBuddies();
     std::vector<DeviceAPI*>::const_iterator itSource = sourceBuddies.begin();
 
     qDebug("LimeSDRInput::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 LimeSDRInput::suspendTxBuddies ( )

private

Definition at line 239 of file limesdrinput.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 ~LimeSDRInput().

 {
     const std::vector<DeviceAPI*>& sinkBuddies = m_deviceAPI->getSinkBuddies();
     std::vector<DeviceAPI*>::const_iterator itSink = sinkBuddies.begin();
 
     qDebug("LimeSDRInput::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 LimeSDRInput::webapiFormatDeviceReport ( SWGSDRangel::SWGDeviceReport & response )

private

Definition at line 1627 of file limesdrinput.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.getLimeSdrInputReport()->setSuccess(success ? 1 : 0);
     response.getLimeSdrInputReport()->setStreamActive(status.active ? 1 : 0);
     response.getLimeSdrInputReport()->setFifoSize(status.fifoSize);
     response.getLimeSdrInputReport()->setFifoFill(status.fifoFilledCount);
     response.getLimeSdrInputReport()->setUnderrunCount(status.underrun);
     response.getLimeSdrInputReport()->setOverrunCount(status.overrun);
     response.getLimeSdrInputReport()->setDroppedPacketsCount(status.droppedPackets);
     response.getLimeSdrInputReport()->setLinkRate(status.linkRate);
     response.getLimeSdrInputReport()->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.getLimeSdrInputReport()->setTemperature(temp);
     response.getLimeSdrInputReport()->setGpioDir(gpioDir);
     response.getLimeSdrInputReport()->setGpioPins(gpioPins);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ webapiFormatDeviceSettings()

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

private

Definition at line 1544 of file limesdrinput.cpp.

Referenced by webapiSettingsGet(), and webapiSettingsPutPatch().

 {
     response.getLimeSdrInputSettings()->setAntennaPath((int) settings.m_antennaPath);
     response.getLimeSdrInputSettings()->setCenterFrequency(settings.m_centerFrequency);
     response.getLimeSdrInputSettings()->setDcBlock(settings.m_dcBlock ? 1 : 0);
     response.getLimeSdrInputSettings()->setDevSampleRate(settings.m_devSampleRate);
     response.getLimeSdrInputSettings()->setExtClock(settings.m_extClock ? 1 : 0);
     response.getLimeSdrInputSettings()->setExtClockFreq(settings.m_extClockFreq);
     response.getLimeSdrInputSettings()->setGain(settings.m_gain);
     response.getLimeSdrInputSettings()->setGainMode((int) settings.m_gainMode);
     response.getLimeSdrInputSettings()->setIqCorrection(settings.m_iqCorrection ? 1 : 0);
     response.getLimeSdrInputSettings()->setLnaGain(settings.m_lnaGain);
     response.getLimeSdrInputSettings()->setLog2HardDecim(settings.m_log2HardDecim);
     response.getLimeSdrInputSettings()->setLog2SoftDecim(settings.m_log2SoftDecim);
     response.getLimeSdrInputSettings()->setLpfBw(settings.m_lpfBW);
     response.getLimeSdrInputSettings()->setLpfFirEnable(settings.m_lpfFIREnable ? 1 : 0);
     response.getLimeSdrInputSettings()->setLpfFirbw(settings.m_lpfFIRBW);
     response.getLimeSdrInputSettings()->setNcoEnable(settings.m_ncoEnable ? 1 : 0);
     response.getLimeSdrInputSettings()->setNcoFrequency(settings.m_ncoFrequency);
     response.getLimeSdrInputSettings()->setPgaGain(settings.m_pgaGain);
     response.getLimeSdrInputSettings()->setTiaGain(settings.m_tiaGain);
     response.getLimeSdrInputSettings()->setTransverterDeltaFrequency(settings.m_transverterDeltaFrequency);
     response.getLimeSdrInputSettings()->setTransverterMode(settings.m_transverterMode ? 1 : 0);
 
     if (response.getLimeSdrInputSettings()->getFileRecordName()) {
         *response.getLimeSdrInputSettings()->getFileRecordName() = settings.m_fileRecordName;
     } else {
         response.getLimeSdrInputSettings()->setFileRecordName(new QString(settings.m_fileRecordName));
     }
 
     response.getLimeSdrInputSettings()->setGpioDir(settings.m_gpioDir);
     response.getLimeSdrInputSettings()->setGpioPins(settings.m_gpioPins);
     response.getLimeSdrInputSettings()->setUseReverseApi(settings.m_useReverseAPI ? 1 : 0);
 
     if (response.getLimeSdrInputSettings()->getReverseApiAddress()) {
         *response.getLimeSdrInputSettings()->getReverseApiAddress() = settings.m_reverseAPIAddress;
     } else {
         response.getLimeSdrInputSettings()->setReverseApiAddress(new QString(settings.m_reverseAPIAddress));
     }
 
     response.getLimeSdrInputSettings()->setReverseApiPort(settings.m_reverseAPIPort);
     response.getLimeSdrInputSettings()->setReverseApiDeviceIndex(settings.m_reverseAPIDeviceIndex);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ webapiReportGet()

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

virtual

Reimplemented from DeviceSampleSource.

Definition at line 1588 of file limesdrinput.cpp.

References SWGSDRangel::SWGDeviceReport::getLimeSdrInputReport(), SWGSDRangel::SWGLimeSdrInputReport::init(), SWGSDRangel::SWGDeviceReport::setLimeSdrInputReport(), and webapiFormatDeviceReport().

Referenced by setSampleRate().

 {
     (void) errorMessage;
     response.setLimeSdrInputReport(new SWGSDRangel::SWGLimeSdrInputReport());
     response.getLimeSdrInputReport()->init();
     webapiFormatDeviceReport(response);
     return 200;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ webapiReverseSendSettings()

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

private

Definition at line 1667 of file limesdrinput.cpp.

Referenced by applySettings().

 {
     SWGSDRangel::SWGDeviceSettings *swgDeviceSettings = new SWGSDRangel::SWGDeviceSettings();
     swgDeviceSettings->setDirection(0); // single Rx
     swgDeviceSettings->setOriginatorIndex(m_deviceAPI->getDeviceSetIndex());
     swgDeviceSettings->setDeviceHwType(new QString("LimeSDR"));
     swgDeviceSettings->setLimeSdrInputSettings(new SWGSDRangel::SWGLimeSdrInputSettings());
     SWGSDRangel::SWGLimeSdrInputSettings *swgLimeSdrInputSettings = swgDeviceSettings->getLimeSdrInputSettings();
 
     // transfer data that has been modified. When force is on transfer all data except reverse API data
 
     if (deviceSettingsKeys.contains("antennaPath") || force) {
         swgLimeSdrInputSettings->setAntennaPath((int) settings.m_antennaPath);
     }
     if (deviceSettingsKeys.contains("centerFrequency") || force) {
         swgLimeSdrInputSettings->setCenterFrequency(settings.m_centerFrequency);
     }
     if (deviceSettingsKeys.contains("dcBlock") || force) {
         swgLimeSdrInputSettings->setDcBlock(settings.m_dcBlock ? 1 : 0);
     }
     if (deviceSettingsKeys.contains("devSampleRate") || force) {
         swgLimeSdrInputSettings->setDevSampleRate(settings.m_devSampleRate);
     }
     if (deviceSettingsKeys.contains("extClock") || force) {
         swgLimeSdrInputSettings->setExtClock(settings.m_extClock ? 1 : 0);
     }
     if (deviceSettingsKeys.contains("extClockFreq") || force) {
         swgLimeSdrInputSettings->setExtClockFreq(settings.m_extClockFreq);
     }
     if (deviceSettingsKeys.contains("gain") || force) {
         swgLimeSdrInputSettings->setGain(settings.m_gain);
     }
     if (deviceSettingsKeys.contains("gainMode") || force) {
         swgLimeSdrInputSettings->setGainMode((int) settings.m_gainMode);
     }
     if (deviceSettingsKeys.contains("iqCorrection") || force) {
         swgLimeSdrInputSettings->setIqCorrection(settings.m_iqCorrection ? 1 : 0);
     }
     if (deviceSettingsKeys.contains("lnaGain") || force) {
         swgLimeSdrInputSettings->setLnaGain(settings.m_lnaGain);
     }
     if (deviceSettingsKeys.contains("log2HardDecim") || force) {
         swgLimeSdrInputSettings->setLog2HardDecim(settings.m_log2HardDecim);
     }
     if (deviceSettingsKeys.contains("log2SoftDecim") || force) {
         swgLimeSdrInputSettings->setLog2SoftDecim(settings.m_log2SoftDecim);
     }
     if (deviceSettingsKeys.contains("lpfBW") || force) {
         swgLimeSdrInputSettings->setLpfBw(settings.m_lpfBW);
     }
     if (deviceSettingsKeys.contains("lpfFIREnable") || force) {
         swgLimeSdrInputSettings->setLpfFirEnable(settings.m_lpfFIREnable ? 1 : 0);
     }
     if (deviceSettingsKeys.contains("lpfFIRBW") || force) {
         swgLimeSdrInputSettings->setLpfFirbw(settings.m_lpfFIRBW);
     }
     if (deviceSettingsKeys.contains("ncoEnable") || force) {
         swgLimeSdrInputSettings->setNcoEnable(settings.m_ncoEnable ? 1 : 0);
     }
     if (deviceSettingsKeys.contains("ncoFrequency") || force) {
         swgLimeSdrInputSettings->setNcoFrequency(settings.m_ncoFrequency);
     }
     if (deviceSettingsKeys.contains("pgaGain") || force) {
         swgLimeSdrInputSettings->setPgaGain(settings.m_pgaGain);
     }
     if (deviceSettingsKeys.contains("tiaGain") || force) {
         swgLimeSdrInputSettings->setTiaGain(settings.m_tiaGain);
     }
     if (deviceSettingsKeys.contains("transverterDeltaFrequency") || force) {
         swgLimeSdrInputSettings->setTransverterDeltaFrequency(settings.m_transverterDeltaFrequency);
     }
     if (deviceSettingsKeys.contains("transverterMode") || force) {
         swgLimeSdrInputSettings->setTransverterMode(settings.m_transverterMode ? 1 : 0);
     }
     if (deviceSettingsKeys.contains("fileRecordName") || force) {
         swgLimeSdrInputSettings->setFileRecordName(new QString(settings.m_fileRecordName));
     }
     if (deviceSettingsKeys.contains("gpioDir") || force) {
         swgLimeSdrInputSettings->setGpioDir(settings.m_gpioDir & 0xFF);
     }
     if (deviceSettingsKeys.contains("gpioPins") || force) {
         swgLimeSdrInputSettings->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 LimeSDRInput::webapiReverseSendStartStop ( bool start )

private

Definition at line 1769 of file limesdrinput.cpp.

References SWGSDRangel::SWGDeviceSettings::asJson(), DeviceAPI::getDeviceSetIndex(), m_deviceAPI, m_networkManager, m_networkRequest, LimeSDRInputSettings::m_reverseAPIAddress, LimeSDRInputSettings::m_reverseAPIDeviceIndex, LimeSDRInputSettings::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(0); // single Rx
     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 LimeSDRInput::webapiRun	(	bool	run,
		SWGSDRangel::SWGDeviceState &	response,
		QString &	errorMessage
	)

virtual

Reimplemented from DeviceSampleSource.

Definition at line 1608 of file limesdrinput.cpp.

References LimeSDRInput::MsgStartStop::create(), DeviceAPI::getDeviceEngineStateStr(), SWGSDRangel::SWGDeviceState::getState(), m_deviceAPI, DeviceSampleSource::m_guiMessageQueue, DeviceSampleSource::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) // forward to GUI if any
     {
         MsgStartStop *msgToGUI = MsgStartStop::create(run);
         m_guiMessageQueue->push(msgToGUI);
     }
 
     return 200;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ webapiRunGet()

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

virtual

Reimplemented from DeviceSampleSource.

Definition at line 1599 of file limesdrinput.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 LimeSDRInput::webapiSettingsGet	(	SWGSDRangel::SWGDeviceSettings &	response,
		QString &	errorMessage
	)

virtual

Reimplemented from DeviceSampleSource.

Definition at line 1426 of file limesdrinput.cpp.

References SWGSDRangel::SWGDeviceSettings::getLimeSdrInputSettings(), SWGSDRangel::SWGLimeSdrInputSettings::init(), m_settings, SWGSDRangel::SWGDeviceSettings::setLimeSdrInputSettings(), and webapiFormatDeviceSettings().

Referenced by setSampleRate().

 {
     (void) errorMessage;
     response.setLimeSdrInputSettings(new SWGSDRangel::SWGLimeSdrInputSettings());
     response.getLimeSdrInputSettings()->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 LimeSDRInput::webapiSettingsPutPatch	(	bool	force,
		const QStringList &	deviceSettingsKeys,
		SWGSDRangel::SWGDeviceSettings &	response,
		QString &	errorMessage
	)

virtual

Reimplemented from DeviceSampleSource.

Definition at line 1437 of file limesdrinput.cpp.

Referenced by setSampleRate().

 {
     (void) errorMessage;
     LimeSDRInputSettings settings = m_settings;
 
     if (deviceSettingsKeys.contains("antennaPath")) {
         settings.m_antennaPath = (LimeSDRInputSettings::PathRFE) response.getLimeSdrInputSettings()->getAntennaPath();
     }
     if (deviceSettingsKeys.contains("centerFrequency")) {
         settings.m_centerFrequency = response.getLimeSdrInputSettings()->getCenterFrequency();
     }
     if (deviceSettingsKeys.contains("dcBlock")) {
         settings.m_dcBlock = response.getLimeSdrInputSettings()->getDcBlock() != 0;
     }
     if (deviceSettingsKeys.contains("devSampleRate")) {
         settings.m_devSampleRate = response.getLimeSdrInputSettings()->getDevSampleRate();
     }
     if (deviceSettingsKeys.contains("extClock")) {
         settings.m_extClock = response.getLimeSdrInputSettings()->getExtClock() != 0;
     }
     if (deviceSettingsKeys.contains("extClockFreq")) {
         settings.m_extClockFreq = response.getLimeSdrInputSettings()->getExtClockFreq();
     }
     if (deviceSettingsKeys.contains("gain")) {
         settings.m_gain = response.getLimeSdrInputSettings()->getGain();
     }
     if (deviceSettingsKeys.contains("gainMode")) {
         settings.m_gainMode = (LimeSDRInputSettings::GainMode) response.getLimeSdrInputSettings()->getGainMode();
     }
     if (deviceSettingsKeys.contains("iqCorrection")) {
         settings.m_iqCorrection = response.getLimeSdrInputSettings()->getIqCorrection() != 0;
     }
     if (deviceSettingsKeys.contains("lnaGain")) {
         settings.m_lnaGain = response.getLimeSdrInputSettings()->getLnaGain();
     }
     if (deviceSettingsKeys.contains("log2HardDecim")) {
         settings.m_log2HardDecim = response.getLimeSdrInputSettings()->getLog2HardDecim();
     }
     if (deviceSettingsKeys.contains("log2SoftDecim")) {
         settings.m_log2SoftDecim = response.getLimeSdrInputSettings()->getLog2SoftDecim();
     }
     if (deviceSettingsKeys.contains("lpfBW")) {
         settings.m_lpfBW = response.getLimeSdrInputSettings()->getLpfBw();
     }
     if (deviceSettingsKeys.contains("lpfFIREnable")) {
         settings.m_lpfFIREnable = response.getLimeSdrInputSettings()->getLpfFirEnable() != 0;
     }
     if (deviceSettingsKeys.contains("lpfFIRBW")) {
         settings.m_lpfFIRBW = response.getLimeSdrInputSettings()->getLpfFirbw();
     }
     if (deviceSettingsKeys.contains("ncoEnable")) {
         settings.m_ncoEnable = response.getLimeSdrInputSettings()->getNcoEnable() != 0;
     }
     if (deviceSettingsKeys.contains("ncoFrequency")) {
         settings.m_ncoFrequency = response.getLimeSdrInputSettings()->getNcoFrequency();
     }
     if (deviceSettingsKeys.contains("pgaGain")) {
         settings.m_pgaGain = response.getLimeSdrInputSettings()->getPgaGain();
     }
     if (deviceSettingsKeys.contains("tiaGain")) {
         settings.m_tiaGain = response.getLimeSdrInputSettings()->getTiaGain();
     }
     if (deviceSettingsKeys.contains("transverterDeltaFrequency")) {
         settings.m_transverterDeltaFrequency = response.getLimeSdrInputSettings()->getTransverterDeltaFrequency();
     }
     if (deviceSettingsKeys.contains("transverterMode")) {
         settings.m_transverterMode = response.getLimeSdrInputSettings()->getTransverterMode() != 0;
     }
     if (deviceSettingsKeys.contains("fileRecordName")) {
         settings.m_fileRecordName = *response.getLimeSdrInputSettings()->getFileRecordName();
     }
     if (deviceSettingsKeys.contains("gpioDir")) {
         settings.m_gpioDir = response.getLimeSdrInputSettings()->getGpioDir() & 0xFF;
     }
     if (deviceSettingsKeys.contains("gpioPins")) {
         settings.m_gpioPins = response.getLimeSdrInputSettings()->getGpioPins() & 0xFF;
     }
     if (deviceSettingsKeys.contains("useReverseAPI")) {
         settings.m_useReverseAPI = response.getLimeSdrInputSettings()->getUseReverseApi() != 0;
     }
     if (deviceSettingsKeys.contains("reverseAPIAddress")) {
         settings.m_reverseAPIAddress = *response.getLimeSdrInputSettings()->getReverseApiAddress();
     }
     if (deviceSettingsKeys.contains("reverseAPIPort")) {
         settings.m_reverseAPIPort = response.getLimeSdrInputSettings()->getReverseApiPort();
     }
     if (deviceSettingsKeys.contains("reverseAPIDeviceIndex")) {
         settings.m_reverseAPIDeviceIndex = response.getLimeSdrInputSettings()->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 LimeSDRInput::m_channelAcquired

private

Definition at line 265 of file limesdrinput.h.

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

◆ m_deviceAPI

DeviceAPI* LimeSDRInput::m_deviceAPI

private

Definition at line 258 of file limesdrinput.h.

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

◆ m_deviceDescription

QString LimeSDRInput::m_deviceDescription

private

Definition at line 262 of file limesdrinput.h.

Referenced by getDeviceDescription().

◆ m_deviceShared

DeviceLimeSDRShared LimeSDRInput::m_deviceShared

private

Definition at line 264 of file limesdrinput.h.

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

◆ m_fileSink

FileRecord* LimeSDRInput::m_fileSink

private

File sink to record device I/Q output.

Definition at line 267 of file limesdrinput.h.

Referenced by applySettings(), handleMessage(), and ~LimeSDRInput().

◆ m_limeSDRInputThread

LimeSDRInputThread* LimeSDRInput::m_limeSDRInputThread

private

Definition at line 261 of file limesdrinput.h.

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

◆ m_mutex

QMutex LimeSDRInput::m_mutex

private

Definition at line 259 of file limesdrinput.h.

◆ m_networkManager

QNetworkAccessManager* LimeSDRInput::m_networkManager

private

Definition at line 268 of file limesdrinput.h.

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

◆ m_networkRequest

QNetworkRequest LimeSDRInput::m_networkRequest

private

Definition at line 269 of file limesdrinput.h.

Referenced by webapiReverseSendSettings(), and webapiReverseSendStartStop().

◆ m_running

bool LimeSDRInput::m_running

private

Definition at line 263 of file limesdrinput.h.

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

◆ m_settings

LimeSDRInputSettings LimeSDRInput::m_settings

private

Definition at line 260 of file limesdrinput.h.

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

◆ m_streamId

lms_stream_t LimeSDRInput::m_streamId

private

Definition at line 266 of file limesdrinput.h.

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

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

plugins/samplesource/limesdrinput/limesdrinput.h
plugins/samplesource/limesdrinput/limesdrinput.cpp

Classes

Public Member Functions

Private Slots

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ LimeSDRInput()

◆ ~LimeSDRInput()

Member Function Documentation

◆ acquireChannel()

◆ applySettings()

◆ closeDevice()

◆ deserialize()

◆ destroy()

◆ getCenterFrequency()

◆ getChannelIndex()

◆ getDeviceDescription()

◆ getHWLog2Decim()

◆ 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_fileSink

◆ m_limeSDRInputThread

◆ m_mutex

◆ m_networkManager

◆ m_networkRequest

◆ m_running

◆ m_settings

◆ m_streamId