#include <xtrxinput.h>

Inheritance diagram for XTRXInput:

Collaboration diagram for XTRXInput:

Classes
class	MsgConfigureXTRX

class	MsgFileRecord

class	MsgGetDeviceInfo

class	MsgGetStreamInfo

class	MsgReportClockGenChange

class	MsgReportStreamInfo

class	MsgStartStop

Public Member Functions
	XTRXInput (DeviceAPI *deviceAPI)

virtual	~XTRXInput ()

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

XTRXInputThread *	getThread ()

void	setThread (XTRXInputThread *thread)

virtual QByteArray	serialize () const

virtual bool	deserialize (const QByteArray &data)

virtual void	setMessageQueueToGUI (MessageQueue *queue)

virtual const QString &	getDeviceDescription () const

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

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

uint32_t	getDevSampleRate () const

uint32_t	getLog2HardDecim () const

double	getClockGen () const

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, float &stepF) const

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

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

void	apply_gain_auto (uint32_t gain)

void	apply_gain_lna (double gain)

void	apply_gain_tia (double gain)

void	apply_gain_pga (double gain)

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

XTRXInputThread *	findThread ()

void	moveThreadToBuddy ()

void	suspendTxThread ()

void	resumeTxThread ()

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

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

void	webapiFormatDeviceReport (SWGSDRangel::SWGDeviceReport &response)

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

void	webapiReverseSendStartStop (bool start)

Private Attributes
DeviceAPI *	m_deviceAPI

QMutex	m_mutex

XTRXInputSettings	m_settings

XTRXInputThread *	m_XTRXInputThread

QString	m_deviceDescription

bool	m_running

DeviceXTRXShared	m_deviceShared

QNetworkAccessManager *	m_networkManager

QNetworkRequest	m_networkRequest

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

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 38 of file xtrxinput.h.

Constructor & Destructor Documentation

◆ XTRXInput()

XTRXInput::XTRXInput ( DeviceAPI * deviceAPI )

Definition at line 50 of file xtrxinput.cpp.

References arg().

Referenced by XTRXInput::MsgFileRecord::MsgFileRecord().

                                          :
     m_deviceAPI(deviceAPI),
     m_settings(),
     m_XTRXInputThread(0),
     m_deviceDescription("XTRXInput"),
     m_running(false)
 {
     openDevice();
 
     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:

◆ ~XTRXInput()

XTRXInput::~XTRXInput ( )

virtual

Definition at line 67 of file xtrxinput.cpp.

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

Referenced by XTRXInput::MsgFileRecord::MsgFileRecord().

 {
     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;
     closeDevice();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Function Documentation

◆ apply_gain_auto()

void XTRXInput::apply_gain_auto ( uint32_t gain )

Definition at line 795 of file xtrxinput.cpp.

References apply_gain_lna(), apply_gain_tia(), and DeviceXTRX::getAutoGains().

Referenced by applySettings(), and setSampleRate().

 {
     uint32_t lna, tia, pga;
 
     DeviceXTRX::getAutoGains(gain, lna, tia, pga);
 
     apply_gain_lna(lna);
     apply_gain_tia(tia_to_db(tia));
     apply_gain_pga(pga);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ apply_gain_lna()

void XTRXInput::apply_gain_lna ( double gain )

Definition at line 806 of file xtrxinput.cpp.

References DeviceXTRX::getDevice(), DeviceXTRXShared::m_channel, DeviceXTRXShared::m_dev, and m_deviceShared.

Referenced by apply_gain_auto(), applySettings(), and setSampleRate().

 {
     if (xtrx_set_gain(m_deviceShared.m_dev->getDevice(),
             m_deviceShared.m_channel == 0 ? XTRX_CH_A : XTRX_CH_B,
             XTRX_RX_LNA_GAIN,
             gain,
             0) < 0) {
         qDebug("XTRXInput::apply_gain_lna: xtrx_set_gain(LNA) failed");
     } else {
         qDebug() << "XTRXInput::apply_gain_lna: Gain (LNA) set to " << gain;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ apply_gain_pga()

void XTRXInput::apply_gain_pga ( double gain )

Definition at line 832 of file xtrxinput.cpp.

References DeviceXTRX::getDevice(), DeviceXTRXShared::m_channel, DeviceXTRXShared::m_dev, and m_deviceShared.

Referenced by setSampleRate().

 {
     if (xtrx_set_gain(m_deviceShared.m_dev->getDevice(),
             m_deviceShared.m_channel == 0 ? XTRX_CH_A : XTRX_CH_B,
             XTRX_RX_PGA_GAIN,
             gain,
             0) < 0)
     {
         qDebug("XTRXInput::apply_gain_pga: xtrx_set_gain(PGA) failed");
     }
     else
     {
         qDebug() << "XTRXInput::apply_gain_pga: Gain (PGA) set to " << gain;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ apply_gain_tia()

void XTRXInput::apply_gain_tia ( double gain )

Definition at line 819 of file xtrxinput.cpp.

References DeviceXTRX::getDevice(), DeviceXTRXShared::m_channel, DeviceXTRXShared::m_dev, and m_deviceShared.

Referenced by apply_gain_auto(), applySettings(), and setSampleRate().

 {
     if (xtrx_set_gain(m_deviceShared.m_dev->getDevice(),
             m_deviceShared.m_channel == 0 ? XTRX_CH_A : XTRX_CH_B,
             XTRX_RX_TIA_GAIN,
             gain,
             0) < 0) {
         qDebug("XTRXInput::apply_gain_tia: xtrx_set_gain(TIA) failed");
     } else {
         qDebug() << "XTRXInput::apply_gain_tia: Gain (TIA) set to " << gain;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ applySettings()

bool XTRXInput::applySettings	(	const XTRXInputSettings &	settings,
		bool	force = `false`,
		bool	forceNCOFrequency = `false`
	)

private

Definition at line 848 of file xtrxinput.cpp.

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

 {
     int requestedChannel = m_deviceAPI->getDeviceItemIndex();
     XTRXInputThread *inputThread = findThread();
     QList<QString> reverseAPIKeys;
 
     bool forwardChangeOwnDSP = false;
     bool forwardChangeRxDSP  = false;
     bool forwardChangeAllDSP = false;
     bool forwardClockSource  = false;
     bool rxThreadWasRunning = false;
     bool doLPCalibration = false;
     bool doChangeSampleRate = false;
     bool doChangeFreq = false;
 
     bool doGainAuto = false;
     bool doGainLna = false;
     bool doGainTia = false;
     bool doGainPga = false;
 
     // apply settings
 
     qDebug() << "XTRXInput::applySettings: center freq: " << m_settings.m_centerFrequency << " Hz"
              << " device stream sample rate: " << getDevSampleRate() << "S/s"
              << " sample rate with soft decimation: " << getSampleRate() << "S/s"
              << " m_devSampleRate: " << m_settings.m_devSampleRate
              << " m_dcBlock: " << m_settings.m_dcBlock
              << " m_iqCorrection: " << m_settings.m_iqCorrection
              << " m_log2SoftDecim: " << m_settings.m_log2SoftDecim
              << " m_gain: " << m_settings.m_gain
              << " m_lpfBW: " << m_settings.m_lpfBW
              << " m_pwrmode: " << m_settings.m_pwrmode
              << " m_ncoEnable: " << m_settings.m_ncoEnable
              << " m_ncoFrequency: " << m_settings.m_ncoFrequency
              << " m_antennaPath: " << m_settings.m_antennaPath
              << " m_extClock: " << m_settings.m_extClock
              << " m_extClockFreq: " << m_settings.m_extClockFreq
              << " force: " << force
              << " forceNCOFrequency: " << forceNCOFrequency
              << " doLPCalibration: " << doLPCalibration;
 
     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_pwrmode != settings.m_pwrmode))
     {
         reverseAPIKeys.append("pwrmode");
 
         if (m_deviceShared.m_dev->getDevice() != 0)
         {
             if (xtrx_val_set(m_deviceShared.m_dev->getDevice(),
                     XTRX_TRX,
                     m_deviceShared.m_channel == 0 ? XTRX_CH_A : XTRX_CH_B,
                     XTRX_LMS7_PWR_MODE,
                     settings.m_pwrmode) < 0) {
                 qCritical("XTRXInput::applySettings: could not set power mode %d", settings.m_pwrmode);
             }
         }
     }
 
     if ((m_settings.m_extClock != settings.m_extClock) || force) {
         reverseAPIKeys.append("extClock");
     }
     if ((m_settings.m_extClockFreq != settings.m_extClockFreq) || force) {
         reverseAPIKeys.append("extClockFreq");
     }
 
     if ((m_settings.m_extClock != settings.m_extClock)
        || (settings.m_extClock && (m_settings.m_extClockFreq != settings.m_extClockFreq)) || force)
     {
         if (m_deviceShared.m_dev->getDevice() != 0)
         {
             xtrx_set_ref_clk(m_deviceShared.m_dev->getDevice(),
                              (settings.m_extClock) ? settings.m_extClockFreq : 0,
                              (settings.m_extClock) ? XTRX_CLKSRC_EXT : XTRX_CLKSRC_INT);
             {
                 forwardClockSource = true;
                 doChangeSampleRate = true;
                 doChangeFreq = true;
                 qDebug("XTRXInput::applySettings: clock set to %s (Ext: %d Hz)",
                        settings.m_extClock ? "external" : "internal",
                        settings.m_extClockFreq);
             }
         }
     }
 
     if ((m_settings.m_devSampleRate != settings.m_devSampleRate) || force) {
         reverseAPIKeys.append("devSampleRate");
     }
     if ((m_settings.m_log2HardDecim != settings.m_log2HardDecim) || force) {
         reverseAPIKeys.append("log2HardDecim");
     }
 
     if ((m_settings.m_devSampleRate != settings.m_devSampleRate)
        || (m_settings.m_log2HardDecim != settings.m_log2HardDecim) || force)
     {
         forwardChangeAllDSP = true; //m_settings.m_devSampleRate != settings.m_devSampleRate;
 
         if (m_deviceShared.m_dev->getDevice() != 0) {
             doChangeSampleRate = true;
         }
     }
 
     if ((m_settings.m_gainMode != settings.m_gainMode) || force) {
         reverseAPIKeys.append("gainMode");
     }
     if ((m_settings.m_gain != settings.m_gain) || force) {
         reverseAPIKeys.append("gain");
     }
     if ((m_settings.m_lnaGain != settings.m_lnaGain) || force) {
         reverseAPIKeys.append("lnaGain");
     }
     if ((m_settings.m_tiaGain != settings.m_tiaGain) || force) {
         reverseAPIKeys.append("tiaGain");
     }
     if ((m_settings.m_pgaGain != settings.m_pgaGain) || force) {
         reverseAPIKeys.append("pgaGain");
     }
 
     if (m_deviceShared.m_dev->getDevice() != 0)
     {
         if ((m_settings.m_gainMode != settings.m_gainMode) || force)
         {
             if (settings.m_gainMode == XTRXInputSettings::GAIN_AUTO)
             {
                 doGainAuto = true;
             }
             else
             {
                 doGainLna = true;
                 doGainTia = true;
                 doGainPga = true;
             }
         }
         else if (m_settings.m_gainMode == XTRXInputSettings::GAIN_AUTO)
         {
             if (m_settings.m_gain != settings.m_gain) {
                 doGainAuto = true;
             }
         }
         else if (m_settings.m_gainMode == XTRXInputSettings::GAIN_MANUAL)
         {
             if (m_settings.m_lnaGain != settings.m_lnaGain) {
                 doGainLna = true;
             }
             if (m_settings.m_tiaGain != settings.m_tiaGain) {
                 doGainTia = true;
             }
             if (m_settings.m_pgaGain != settings.m_pgaGain) {
                 doGainPga = true;
             }
         }
     }
 
     if ((m_settings.m_lpfBW != settings.m_lpfBW) || force)
     {
         reverseAPIKeys.append("lpfBW");
 
         if (m_deviceShared.m_dev->getDevice() != 0) {
             doLPCalibration = true;
         }
     }
 
 #if 0
     if ((m_settings.m_lpfFIRBW != settings.m_lpfFIRBW) ||
             (m_settings.m_lpfFIREnable != settings.m_lpfFIREnable) || force)
     {
         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("XTRXInput::applySettings: could %s and set LPF FIR to %f Hz",
                           settings.m_lpfFIREnable ? "enable" : "disable",
                           settings.m_lpfFIRBW);
             }
             else
             {
                 //doCalibration = true;
                 qDebug("XTRXInput::applySettings: %sd and set LPF FIR to %f Hz",
                        settings.m_lpfFIREnable ? "enable" : "disable",
                        settings.m_lpfFIRBW);
             }
         }
     }
 #endif
 
     if ((m_settings.m_log2SoftDecim != settings.m_log2SoftDecim) || force)
     {
         reverseAPIKeys.append("log2SoftDecim");
         forwardChangeOwnDSP = true;
 
         if (inputThread != 0)
         {
             inputThread->setLog2Decimation(requestedChannel, settings.m_log2SoftDecim);
             qDebug() << "XTRXInput::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_dev->getDevice() != 0)
         {
             if (xtrx_set_antenna(m_deviceShared.m_dev->getDevice(), settings.m_antennaPath) < 0) {
                 qCritical("XTRXInput::applySettings: could not set antenna path to %d", (int) settings.m_antennaPath);
             } else {
                 qDebug("XTRXInput::applySettings: set antenna path to %d", (int) settings.m_antennaPath);
             }
         }
     }
 
     if ((m_settings.m_centerFrequency != settings.m_centerFrequency) || force)
     {
         reverseAPIKeys.append("centerFrequency");
         doChangeFreq = true;
     }
 
     if ((m_settings.m_ncoFrequency != settings.m_ncoFrequency) || force) {
         reverseAPIKeys.append("ncoFrequency");
     }
     if ((m_settings.m_ncoEnable != settings.m_ncoEnable) || force) {
         reverseAPIKeys.append("ncoEnable");
     }
 
     if ((m_settings.m_ncoFrequency != settings.m_ncoFrequency)
        || (m_settings.m_ncoEnable != settings.m_ncoEnable) || force)
     {
         forceNCOFrequency = true;
     }
 
     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;
 
     if (doChangeSampleRate)
     {
         XTRXInputThread *rxThread = findThread();
 
         if (rxThread && rxThread->isRunning())
         {
             rxThread->stopWork();
             rxThreadWasRunning = true;
         }
 
         suspendTxThread();
 
         double master = (settings.m_log2HardDecim == 0) ? 0 : (settings.m_devSampleRate * 4 * (1 << settings.m_log2HardDecim));
 
         if (m_deviceShared.m_dev->set_samplerate(settings.m_devSampleRate,
                 master, //(settings.m_devSampleRate<<settings.m_log2HardDecim)*4,
                 false) < 0)
         {
             qCritical("XTRXInput::applySettings: could not set sample rate to %f with oversampling of %d",
                       settings.m_devSampleRate,
                       1<<settings.m_log2HardDecim);
         }
         else
         {
             doChangeFreq = true;
             forceNCOFrequency = true;
             forwardChangeAllDSP = true;
 
             qDebug("XTRXInput::applySettings: sample rate set to %f with oversampling of %d",
                    m_deviceShared.m_dev->getActualInputRate(),
                    1 << getLog2HardDecim());
         }
 
         resumeTxThread();
 
         if (rxThreadWasRunning) {
             rxThread->startWork();
         }
     }
 
     if (doLPCalibration)
     {
         if (xtrx_tune_rx_bandwidth(m_deviceShared.m_dev->getDevice(),
                 m_deviceShared.m_channel == 0 ? XTRX_CH_A : XTRX_CH_B,
                 m_settings.m_lpfBW,
                 0) < 0) {
             qCritical("XTRXInput::applySettings: could not set LPF to %f Hz", m_settings.m_lpfBW);
         } else {
             qDebug("XTRXInput::applySettings: LPF set to %f Hz", m_settings.m_lpfBW);
         }
     }
 
     if (doGainAuto)
     {
         apply_gain_auto(m_settings.m_gain);
     }
     if (doGainLna)
     {
         apply_gain_lna(m_settings.m_lnaGain);
     }
     if (doGainTia)
     {
         apply_gain_tia(tia_to_db(m_settings.m_tiaGain));
     }
     if (doGainPga)
     {
         apply_gain_pga(m_settings.m_pgaGain);
     }
 
     if (doChangeFreq)
     {
         forwardChangeRxDSP = true;
 
         if (m_deviceShared.m_dev->getDevice() != 0)
         {
             if (xtrx_tune(m_deviceShared.m_dev->getDevice(),
                     XTRX_TUNE_RX_FDD,
                     settings.m_centerFrequency,
                     0) < 0) {
                 qCritical("XTRXInput::applySettings: could not set frequency to %lu", settings.m_centerFrequency);
             } else {
                 //doCalibration = true;
                 qDebug("XTRXInput::applySettings: frequency set to %lu", settings.m_centerFrequency);
             }
         }
     }
 
     if (forceNCOFrequency)
     {
         if (m_deviceShared.m_dev->getDevice() != 0)
         {
             if (xtrx_tune_ex(m_deviceShared.m_dev->getDevice(),
                     XTRX_TUNE_BB_RX,
                     m_deviceShared.m_channel == 0 ? XTRX_CH_A : XTRX_CH_B,
                     (settings.m_ncoEnable) ? settings.m_ncoFrequency : 0,
                     NULL) < 0)
             {
                 qCritical("XTRXInput::applySettings: could not %s and set NCO to %d Hz",
                           settings.m_ncoEnable ? "enable" : "disable",
                           settings.m_ncoFrequency);
             }
             else
             {
                 forwardChangeOwnDSP = true;
                 qDebug("XTRXInput::applySettings: %sd and set NCO to %d Hz",
                        settings.m_ncoEnable ? "enable" : "disable",
                        settings.m_ncoFrequency);
             }
         }
     }
 
     // forward changes to buddies or oneself
 
     if (forwardChangeAllDSP)
     {
         qDebug("XTRXInput::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(getSampleRate(), m_settings.m_centerFrequency + ncoShift);
         m_deviceAPI->getDeviceEngineInputMessageQueue()->push(notif);
 
         if (getMessageQueueToGUI())
         {
             MsgReportClockGenChange *report = MsgReportClockGenChange::create();
             getMessageQueueToGUI()->push(report);
         }
 
         // send to source buddies
         const std::vector<DeviceAPI*>& sourceBuddies = m_deviceAPI->getSourceBuddies();
         std::vector<DeviceAPI*>::const_iterator itSource = sourceBuddies.begin();
 
         for (; itSource != sourceBuddies.end(); ++itSource)
         {
             DeviceXTRXShared::MsgReportBuddyChange *report = DeviceXTRXShared::MsgReportBuddyChange::create(
                     getDevSampleRate(), getLog2HardDecim(), 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)
         {
             DeviceXTRXShared::MsgReportBuddyChange *report = DeviceXTRXShared::MsgReportBuddyChange::create(
                     getDevSampleRate(), getLog2HardDecim(), m_settings.m_centerFrequency, true);
             (*itSink)->getSamplingDeviceInputMessageQueue()->push(report);
         }
     }
     else if (forwardChangeRxDSP)
     {
         qDebug("XTRXInput::applySettings: forward change to Rx buddies");
 
         int ncoShift = m_settings.m_ncoEnable ? m_settings.m_ncoFrequency : 0;
 
         // send to self first
         DSPSignalNotification *notif = new DSPSignalNotification(getSampleRate(), m_settings.m_centerFrequency + ncoShift);
         m_deviceAPI->getDeviceEngineInputMessageQueue()->push(notif);
 
         if (getMessageQueueToGUI())
         {
             MsgReportClockGenChange *report = MsgReportClockGenChange::create();
             getMessageQueueToGUI()->push(report);
         }
 
         // send to source buddies
         const std::vector<DeviceAPI*>& sourceBuddies = m_deviceAPI->getSourceBuddies();
         std::vector<DeviceAPI*>::const_iterator itSource = sourceBuddies.begin();
 
         for (; itSource != sourceBuddies.end(); ++itSource)
         {
             DeviceXTRXShared::MsgReportBuddyChange *report = DeviceXTRXShared::MsgReportBuddyChange::create(
                         getDevSampleRate(), getLog2HardDecim(), m_settings.m_centerFrequency, true);
             (*itSource)->getSamplingDeviceInputMessageQueue()->push(report);
         }
     }
     else if (forwardChangeOwnDSP)
     {
         qDebug("XTRXInput::applySettings: forward change to self only");
 
         int ncoShift = m_settings.m_ncoEnable ? m_settings.m_ncoFrequency : 0;
 
         DSPSignalNotification *notif = new DSPSignalNotification(getSampleRate(), m_settings.m_centerFrequency + ncoShift);
         m_fileSink->handleMessage(*notif); // forward to file sink
         m_deviceAPI->getDeviceEngineInputMessageQueue()->push(notif);
 
         if (getMessageQueueToGUI())
         {
             MsgReportClockGenChange *report = MsgReportClockGenChange::create();
             getMessageQueueToGUI()->push(report);
         }
     }
 
     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)
         {
             DeviceXTRXShared::MsgReportClockSourceChange *report = DeviceXTRXShared::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)
         {
             DeviceXTRXShared::MsgReportClockSourceChange *report = DeviceXTRXShared::MsgReportClockSourceChange::create(
                         m_settings.m_extClock, m_settings.m_extClockFreq);
             (*itSink)->getSamplingDeviceInputMessageQueue()->push(report);
         }
     }
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ closeDevice()

void XTRXInput::closeDevice ( )

private

Definition at line 168 of file xtrxinput.cpp.

References DeviceXTRX::close(), DeviceAPI::getSinkBuddies(), DeviceAPI::getSourceBuddies(), DeviceXTRXShared::m_channel, DeviceXTRXShared::m_dev, m_deviceAPI, m_deviceShared, m_running, DeviceXTRXShared::m_source, m_XTRXInputThread, moveThreadToBuddy(), and stop().

Referenced by ~XTRXInput().

 {
     if (m_deviceShared.m_dev == 0) { // was never open
         return;
     }
 
     if (m_running) {
         stop();
     }
 
     if (m_XTRXInputThread) { // stills own the thread => transfer to a buddy
         moveThreadToBuddy();
     }
 
     m_deviceShared.m_channel = -1; // publicly release channel
     m_deviceShared.m_source = 0;
 
     // No buddies so effectively close the device
 
     if ((m_deviceAPI->getSinkBuddies().size() == 0) && (m_deviceAPI->getSourceBuddies().size() == 0))
     {
         m_deviceShared.m_dev->close();
         delete m_deviceShared.m_dev;
         m_deviceShared.m_dev = 0;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ deserialize()

bool XTRXInput::deserialize ( const QByteArray & data )

virtual

Implements DeviceSampleSource.

Definition at line 482 of file xtrxinput.cpp.

References XTRXInput::MsgConfigureXTRX::create(), XTRXInputSettings::deserialize(), DeviceSampleSource::m_guiMessageQueue, DeviceSampleSource::m_inputMessageQueue, m_settings, MessageQueue::push(), and XTRXInputSettings::resetToDefaults().

Referenced by setThread().

 {
     bool success = true;
 
     if (!m_settings.deserialize(data))
     {
         m_settings.resetToDefaults();
         success = false;
     }
 
     MsgConfigureXTRX* message = MsgConfigureXTRX::create(m_settings, true);
     m_inputMessageQueue.push(message);
 
     if (m_guiMessageQueue)
     {
         MsgConfigureXTRX* messageToGUI = MsgConfigureXTRX::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 XTRXInput::destroy ( )

virtual

Implements DeviceSampleSource.

Definition at line 81 of file xtrxinput.cpp.

Referenced by XTRXInput::MsgFileRecord::MsgFileRecord().

 {
     delete this;
 }

Here is the caller graph for this function:

◆ findThread()

XTRXInputThread * XTRXInput::findThread ( )

private

Definition at line 200 of file xtrxinput.cpp.

References DeviceAPI::getSourceBuddies(), getThread(), m_deviceAPI, and m_XTRXInputThread.

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

 {
     if (m_XTRXInputThread == 0) // this does not own the thread
     {
         XTRXInputThread *xtrxInputThread = 0;
 
         // find a buddy that has allocated the thread
         const std::vector<DeviceAPI*>& sourceBuddies = m_deviceAPI->getSourceBuddies();
         std::vector<DeviceAPI*>::const_iterator it = sourceBuddies.begin();
 
         for (; it != sourceBuddies.end(); ++it)
         {
             XTRXInput *buddySource = ((DeviceXTRXShared*) (*it)->getBuddySharedPtr())->m_source;
 
             if (buddySource)
             {
                 xtrxInputThread = buddySource->getThread();
 
                 if (xtrxInputThread) {
                     break;
                 }
             }
         }
 
         return xtrxInputThread;
     }
     else
     {
         return m_XTRXInputThread; // own thread
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getCenterFrequency()

quint64 XTRXInput::getCenterFrequency ( ) const

virtual

Center frequency exposed by the source.

Implements DeviceSampleSource.

Definition at line 551 of file xtrxinput.cpp.

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

Definition at line 571 of file xtrxinput.cpp.

References DeviceXTRXShared::m_channel, and m_deviceShared.

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

 {
     return m_deviceShared.m_channel;
 }

Here is the caller graph for this function:

◆ getClockGen()

double XTRXInput::getClockGen ( ) const

Definition at line 542 of file xtrxinput.cpp.

References DeviceXTRX::getClockGen(), DeviceXTRXShared::m_dev, and m_deviceShared.

Referenced by setSampleRate(), and XTRXInputGUI::updateADCRate().

 {
     if (m_deviceShared.m_dev) {
         return m_deviceShared.m_dev->getClockGen();
     } else {
         return 0.0;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getDeviceDescription()

const QString & XTRXInput::getDeviceDescription ( ) const

virtual

Implements DeviceSampleSource.

Definition at line 504 of file xtrxinput.cpp.

References m_deviceDescription.

Referenced by setMessageQueueToGUI().

 {
     return m_deviceDescription;
 }

Here is the caller graph for this function:

◆ getDevSampleRate()

uint32_t XTRXInput::getDevSampleRate ( ) const

Definition at line 520 of file xtrxinput.cpp.

References DeviceXTRX::getActualInputRate(), DeviceXTRXShared::m_dev, m_deviceShared, XTRXInputSettings::m_devSampleRate, and m_settings.

Referenced by applySettings(), XTRXInputGUI::handleMessage(), and setSampleRate().

 {
     uint32_t devSampleRate = m_settings.m_devSampleRate;
 
     if (m_deviceShared.m_dev) {
         devSampleRate = m_deviceShared.m_dev->getActualInputRate();
     }
 
     return devSampleRate;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getLog2HardDecim()

uint32_t XTRXInput::getLog2HardDecim ( ) const

Definition at line 531 of file xtrxinput.cpp.

References DeviceXTRX::getActualInputRate(), DeviceXTRX::getClockGen(), DeviceXTRXShared::m_dev, m_deviceShared, XTRXInputSettings::m_log2HardDecim, and m_settings.

Referenced by applySettings(), handleMessage(), and setSampleRate().

 {
     uint32_t log2HardDecim = m_settings.m_log2HardDecim;
 
     if (m_deviceShared.m_dev && (m_deviceShared.m_dev->getActualInputRate() != 0.0)) {
         log2HardDecim = log2(m_deviceShared.m_dev->getClockGen() / m_deviceShared.m_dev->getActualInputRate() / 4);
     }
 
     return log2HardDecim;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getLORange()

void XTRXInput::getLORange	(	float &	minF,
		float &	maxF,
		float &	stepF
	)		const

Definition at line 576 of file xtrxinput.cpp.

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

 {
     minF = 29e6;
     maxF = 3840e6;
     stepF = 10;
     qDebug("XTRXInput::getLORange: min: %f max: %f step: %f",
            minF, maxF, stepF);
 }

Here is the caller graph for this function:

◆ getLPRange()

void XTRXInput::getLPRange	(	float &	minF,
		float &	maxF,
		float &	stepF
	)		const

Definition at line 594 of file xtrxinput.cpp.

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

 {
     minF = 500e3;
     maxF = 130e6;
     stepF = 10;
     qDebug("XTRXInput::getLPRange: min: %f max: %f step: %f",
            minF, maxF, stepF);
 }

Here is the caller graph for this function:

◆ getSampleRate()

int XTRXInput::getSampleRate ( ) const

virtual

Sample rate exposed by the source.

Implements DeviceSampleSource.

Definition at line 509 of file xtrxinput.cpp.

References DeviceXTRX::getActualInputRate(), DeviceXTRXShared::m_dev, m_deviceShared, XTRXInputSettings::m_devSampleRate, XTRXInputSettings::m_log2SoftDecim, and m_settings.

Referenced by applySettings(), and setMessageQueueToGUI().

 {
     double rate = m_settings.m_devSampleRate;
 
     if (m_deviceShared.m_dev) {
         rate = m_deviceShared.m_dev->getActualInputRate();
     }
 
     return (int)((rate / (1<<m_settings.m_log2SoftDecim)));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getSRRange()

void XTRXInput::getSRRange	(	float &	minF,
		float &	maxF,
		float &	stepF
	)		const

Definition at line 585 of file xtrxinput.cpp.

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

 {
     minF = 100e3;
     maxF = 120e6;
     stepF = 10;
     qDebug("XTRXInput::getSRRange: min: %f max: %f step: %f",
            minF, maxF, stepF);
 }

Here is the caller graph for this function:

◆ getThread()

XTRXInputThread* XTRXInput::getThread ( )

inline

Definition at line 200 of file xtrxinput.h.

References m_XTRXInputThread.

Referenced by findThread().

200 { return m_XTRXInputThread; }

XTRXInput::m_XTRXInputThread

XTRXInputThread * m_XTRXInputThread

Definition: xtrxinput.h:255

Here is the caller graph for this function:

◆ handleMessage()

bool XTRXInput::handleMessage ( const Message & message )

virtual

Implements DeviceSampleSource.

Definition at line 603 of file xtrxinput.cpp.

Referenced by setSampleRate().

 {
     if (MsgConfigureXTRX::match(message))
     {
         MsgConfigureXTRX& conf = (MsgConfigureXTRX&) message;
         qDebug() << "XTRXInput::handleMessage: MsgConfigureXTRX";
 
         if (!applySettings(conf.getSettings(), conf.getForce()))
         {
             qDebug("XTRXInput::handleMessage config error");
         }
 
         return true;
     }
     else if (DeviceXTRXShared::MsgReportBuddyChange::match(message))
     {
         DeviceXTRXShared::MsgReportBuddyChange& report = (DeviceXTRXShared::MsgReportBuddyChange&) message;
 
         if (report.getRxElseTx())
         {
             m_settings.m_devSampleRate   = report.getDevSampleRate();
             m_settings.m_log2HardDecim   = report.getLog2HardDecimInterp();
             m_settings.m_centerFrequency = report.getCenterFrequency();
         }
         else
         {
             m_settings.m_devSampleRate = m_deviceShared.m_dev->getActualInputRate();
             m_settings.m_log2HardDecim = getLog2HardDecim();
 
             qDebug() << "XTRXInput::handleMessage: MsgReportBuddyChange:"
                      << " host_Hz: " << m_deviceShared.m_dev->getActualInputRate()
                      << " adc_Hz: " << m_deviceShared.m_dev->getClockGen() / 4
                      << " m_log2HardDecim: " << m_settings.m_log2HardDecim;
         }
 
         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())
         {
             DeviceXTRXShared::MsgReportBuddyChange *reportToGUI = DeviceXTRXShared::MsgReportBuddyChange::create(
                         m_settings.m_devSampleRate, m_settings.m_log2HardDecim, m_settings.m_centerFrequency, true);
             getMessageQueueToGUI()->push(reportToGUI);
         }
 
         return true;
     }
     else if (DeviceXTRXShared::MsgReportClockSourceChange::match(message))
     {
         DeviceXTRXShared::MsgReportClockSourceChange& report = (DeviceXTRXShared::MsgReportClockSourceChange&) message;
 
         m_settings.m_extClock     = report.getExtClock();
         m_settings.m_extClockFreq = report.getExtClockFeq();
 
         if (getMessageQueueToGUI())
         {
             DeviceXTRXShared::MsgReportClockSourceChange *reportToGUI = DeviceXTRXShared::MsgReportClockSourceChange::create(
                         m_settings.m_extClock, m_settings.m_extClockFreq);
             getMessageQueueToGUI()->push(reportToGUI);
         }
 
         return true;
     }
     else if (MsgGetStreamInfo::match(message))
     {
         if (m_deviceAPI->getSamplingDeviceGUIMessageQueue())
         {
             uint64_t fifolevel = 0;
 
             if (m_deviceShared.m_dev && m_deviceShared.m_dev->getDevice()) {
                 xtrx_val_get(m_deviceShared.m_dev->getDevice(), XTRX_RX, XTRX_CH_AB, XTRX_PERF_LLFIFO, &fifolevel);
             }
 
             MsgReportStreamInfo *report = MsgReportStreamInfo::create(
                         true,
                         true,
                         fifolevel,
                         65536);
 
             if (m_deviceAPI->getSamplingDeviceGUIMessageQueue()) {
                 m_deviceAPI->getSamplingDeviceGUIMessageQueue()->push(report);
             }
         }
 
         return true;
     }
     else if (MsgGetDeviceInfo::match(message))
     {
         double board_temp = 0.0;
         bool gps_locked = false;
 
         if (!m_deviceShared.m_dev->getDevice() || ((board_temp = m_deviceShared.get_board_temperature() / 256.0) == 0.0)) {
             qDebug("XTRXInput::handleMessage: MsgGetDeviceInfo: cannot get board temperature");
         }
 
         if (!m_deviceShared.m_dev->getDevice()) {
             qDebug("XTRXInput::handleMessage: MsgGetDeviceInfo: cannot get GPS lock status");
         } else {
             gps_locked = m_deviceShared.get_gps_status();
         }
 
         // send to oneself
         if (m_deviceAPI->getSamplingDeviceGUIMessageQueue())
         {
             DeviceXTRXShared::MsgReportDeviceInfo *report = DeviceXTRXShared::MsgReportDeviceInfo::create(board_temp, gps_locked);
             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())
             {
                 DeviceXTRXShared::MsgReportDeviceInfo *report = DeviceXTRXShared::MsgReportDeviceInfo::create(board_temp, gps_locked);
                 (*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())
             {
                 DeviceXTRXShared::MsgReportDeviceInfo *report = DeviceXTRXShared::MsgReportDeviceInfo::create(board_temp, gps_locked);
                 (*itSink)->getSamplingDeviceGUIMessageQueue()->push(report);
             }
         }
 
         return true;
     }
     else if (MsgFileRecord::match(message))
     {
         MsgFileRecord& conf = (MsgFileRecord&) message;
         qDebug() << "XTRXInput::handleMessage: MsgFileRecord: " << conf.getStartStop();
 
         if (conf.getStartStop()) {
             m_fileSink->startRecording();
         } else {
             m_fileSink->stopRecording();
         }
 
         return true;
     }
     else if (MsgStartStop::match(message))
     {
         MsgStartStop& cmd = (MsgStartStop&) message;
         qDebug() << "XTRXInput::handleMessage: MsgStartStop: " << (cmd.getStartStop() ? "start" : "stop");
 
         if (cmd.getStartStop())
         {
             if (m_deviceAPI->initDeviceEngine())
             {
                 m_deviceAPI->startDeviceEngine();
             }
         }
         else
         {
             m_deviceAPI->stopDeviceEngine();
         }
 
         return true;
     }
     else
     {
         return false;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init()

void XTRXInput::init ( )

virtual

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

Implements DeviceSampleSource.

Definition at line 195 of file xtrxinput.cpp.

References applySettings(), and m_settings.

Referenced by XTRXInput::MsgFileRecord::MsgFileRecord().

 {
     applySettings(m_settings, true, false);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ moveThreadToBuddy()

void XTRXInput::moveThreadToBuddy ( )

private

Definition at line 232 of file xtrxinput.cpp.

References DeviceAPI::getSourceBuddies(), m_deviceAPI, m_XTRXInputThread, and setThread().

Referenced by closeDevice().

 {
     const std::vector<DeviceAPI*>& sourceBuddies = m_deviceAPI->getSourceBuddies();
     std::vector<DeviceAPI*>::const_iterator it = sourceBuddies.begin();
 
     for (; it != sourceBuddies.end(); ++it)
     {
         XTRXInput *buddySource = ((DeviceXTRXShared*) (*it)->getBuddySharedPtr())->m_source;
 
         if (buddySource)
         {
             buddySource->setThread(m_XTRXInputThread);
             m_XTRXInputThread = 0;  // zero for others
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ networkManagerFinished

void XTRXInput::networkManagerFinished ( QNetworkReply * reply )

privateslot

Definition at line 1647 of file xtrxinput.cpp.

Referenced by ~XTRXInput().

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

Here is the caller graph for this function:

◆ openDevice()

bool XTRXInput::openDevice ( )

private

Definition at line 86 of file xtrxinput.cpp.

References DeviceAPI::getBuddySharedPtr(), DeviceAPI::getDeviceItemIndex(), DeviceAPI::getSamplingDeviceSerial(), DeviceAPI::getSinkBuddies(), DeviceAPI::getSourceBuddies(), DeviceXTRXShared::m_channel, DeviceXTRXShared::m_dev, m_deviceAPI, m_deviceShared, DeviceSampleSource::m_sampleFifo, DeviceXTRXShared::m_source, DeviceXTRX::open(), DeviceAPI::setBuddySharedPtr(), and SampleSinkFifo::setSize().

 {
     if (!m_sampleFifo.setSize(96000 * 4))
     {
         qCritical("XTRXInput::openDevice: could not allocate SampleFifo");
         return false;
     }
     else
     {
         qDebug("XTRXInput::openDevice: allocated SampleFifo");
     }
 
     // look for Rx buddies and get reference to the device object
     if (m_deviceAPI->getSourceBuddies().size() > 0) // look source sibling first
     {
         qDebug("XTRXInput::openDevice: look in Rx buddies");
 
         DeviceAPI *sourceBuddy = m_deviceAPI->getSourceBuddies()[0];
         DeviceXTRXShared *deviceXTRXShared = (DeviceXTRXShared*) sourceBuddy->getBuddySharedPtr();
 
         if (deviceXTRXShared == 0)
         {
             qCritical("XTRXInput::openDevice: the source buddy shared pointer is null");
             return false;
         }
 
         DeviceXTRX *device = deviceXTRXShared->m_dev;
 
         if (device == 0)
         {
             qCritical("XTRXInput::openDevice: cannot get device pointer from Rx buddy");
             return false;
         }
 
         m_deviceShared.m_dev = device;
     }
     // look for Tx buddies and get reference to the device object
     else if (m_deviceAPI->getSinkBuddies().size() > 0) // then sink
     {
         qDebug("XTRXInput::openDevice: look in Tx buddies");
 
         DeviceAPI *sinkBuddy = m_deviceAPI->getSinkBuddies()[0];
         DeviceXTRXShared *deviceXTRXShared = (DeviceXTRXShared*) sinkBuddy->getBuddySharedPtr();
 
         if (deviceXTRXShared == 0)
         {
             qCritical("XTRXInput::openDevice: the sink buddy shared pointer is null");
             return false;
         }
 
         DeviceXTRX *device = deviceXTRXShared->m_dev;
 
         if (device == 0)
         {
             qCritical("XTRXInput::openDevice: cannot get device pointer from Tx buddy");
             return false;
         }
 
         m_deviceShared.m_dev = device;
     }
     // There are no buddies then create the first BladeRF2 device
     else
     {
         qDebug("XTRXInput::openDevice: open device here");
 
         m_deviceShared.m_dev = new DeviceXTRX();
         char serial[256];
         strcpy(serial, qPrintable(m_deviceAPI->getSamplingDeviceSerial()));
 
         if (!m_deviceShared.m_dev->open(serial))
         {
             qCritical("XTRXInput::openDevice: cannot open BladeRF2 device");
             return false;
         }
     }
 
     m_deviceShared.m_channel = m_deviceAPI->getDeviceItemIndex(); // publicly allocate channel
     m_deviceShared.m_source = this;
     m_deviceAPI->setBuddySharedPtr(&m_deviceShared); // propagate common parameters to API
     return true;
 }

Here is the call graph for this function:

◆ resumeTxThread()

void XTRXInput::resumeTxThread ( )

private

Definition at line 460 of file xtrxinput.cpp.

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

Referenced by applySettings().

 {
     const std::vector<DeviceAPI*>& sinkBuddies = m_deviceAPI->getSinkBuddies();
     std::vector<DeviceAPI*>::const_iterator itSink = sinkBuddies.begin();
 
     qDebug("XTRXInput::resumeTxThread (%lu)", sinkBuddies.size());
 
     for (; itSink != sinkBuddies.end(); ++itSink)
     {
         DeviceXTRXShared *buddySharedPtr = (DeviceXTRXShared *) (*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 XTRXInput::serialize ( ) const

virtual

Implements DeviceSampleSource.

Definition at line 477 of file xtrxinput.cpp.

References m_settings, and XTRXInputSettings::serialize().

Referenced by setThread().

 {
     return m_settings.serialize();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setCenterFrequency()

void XTRXInput::setCenterFrequency ( qint64 centerFrequency )

virtual

Implements DeviceSampleSource.

Definition at line 556 of file xtrxinput.cpp.

References XTRXInput::MsgConfigureXTRX::create(), XTRXInputSettings::m_centerFrequency, DeviceSampleSource::m_guiMessageQueue, DeviceSampleSource::m_inputMessageQueue, XTRXInputSettings::m_ncoEnable, XTRXInputSettings::m_ncoFrequency, m_settings, and MessageQueue::push().

Referenced by setSampleRate().

 {
     XTRXInputSettings settings = m_settings;
     settings.m_centerFrequency = centerFrequency - (m_settings.m_ncoEnable ? m_settings.m_ncoFrequency : 0);
 
     MsgConfigureXTRX* message = MsgConfigureXTRX::create(settings, false);
     m_inputMessageQueue.push(message);
 
     if (m_guiMessageQueue)
     {
         MsgConfigureXTRX* messageToGUI = MsgConfigureXTRX::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 XTRXInput::setMessageQueueToGUI ( MessageQueue * queue )

inlinevirtual

Implements DeviceSampleSource.

Definition at line 206 of file xtrxinput.h.

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

206 { 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:

◆ setSampleRate()

virtual void XTRXInput::setSampleRate ( int sampleRate )

inlinevirtual

For when the source sample rate is set externally.

Implements DeviceSampleSource.

Definition at line 209 of file xtrxinput.h.

References apply_gain_auto(), apply_gain_lna(), apply_gain_pga(), apply_gain_tia(), getCenterFrequency(), getChannelIndex(), getClockGen(), getDevSampleRate(), getLog2HardDecim(), getLORange(), getLPRange(), getSRRange(), handleMessage(), setCenterFrequency(), webapiReportGet(), webapiRun(), webapiRunGet(), webapiSettingsGet(), and webapiSettingsPutPatch().

209 { (void) sampleRate; }

Here is the call graph for this function:

◆ setThread()

void XTRXInput::setThread ( XTRXInputThread * thread )

inline

Definition at line 201 of file xtrxinput.h.

References deserialize(), m_XTRXInputThread, and serialize().

Referenced by moveThreadToBuddy().

201 { m_XTRXInputThread = thread; }

XTRXInput::m_XTRXInputThread

XTRXInputThread * m_XTRXInputThread

Definition: xtrxinput.h:255

Here is the call graph for this function:

Here is the caller graph for this function:

◆ start()

bool XTRXInput::start ( )

virtual

Implements DeviceSampleSource.

Definition at line 249 of file xtrxinput.cpp.

References applySettings(), findThread(), DeviceXTRX::getDevice(), DeviceAPI::getDeviceItemIndex(), XTRXInputThread::getFifo(), XTRXInputThread::getLog2Decimation(), XTRXInputThread::getNbChannels(), DeviceAPI::getSourceBuddies(), i, DeviceXTRXShared::m_dev, m_deviceAPI, m_deviceShared, XTRXInputSettings::m_log2SoftDecim, m_running, DeviceSampleSource::m_sampleFifo, m_settings, DeviceXTRXShared::m_thread, m_XTRXInputThread, XTRXInputThread::setFifo(), XTRXInputThread::setLog2Decimation(), XTRXInputThread::startWork(), and XTRXInputThread::stopWork().

Referenced by XTRXInput::MsgFileRecord::MsgFileRecord().

 {
     // There is a single thread per physical device (Rx side). This thread is unique and referenced by a unique
     // buddy in the group of source buddies associated with this physical device.
     //
     // This start method is responsible for managing the thread when the streaming of a Rx channel is started
     //
     // It checks the following conditions
     //   - the thread is allocated or not (by itself or one of its buddies). If it is it grabs the thread pointer.
     //   - the requested channel is another channel (one is already streaming).
     //
     // The XTRX support library lets you work in two possible modes:
     //   - Single Input (SI) with only one channel streaming. This can be channel 0 or 1 (channels can be swapped - unlike with BladeRF2).
     //   - Multiple Input (MI) with two channels streaming using interleaved samples. It MUST be in this configuration if both channels are
     //     streaming.
     //
     // It manages the transition form SI where only one channel is running to the  Multiple Input (MI) if the both channels are requested.
     // To perform the transition it stops the thread, deletes it and creates a new one.
     // It marks the thread as needing start.
     //
     // If there is no thread allocated it means we are in SI mode and it creates a new one with the requested channel.
     // It marks the thread as needing start.
     //
     // Eventually it registers the FIFO in the thread. If the thread has to be started it enables the channels up to the number of channels
     // allocated in the thread and starts the thread.
 
     if (!m_deviceShared.m_dev || !m_deviceShared.m_dev->getDevice())
     {
         qDebug("XTRXInput::start: no device object");
         return false;
     }
 
     int requestedChannel = m_deviceAPI->getDeviceItemIndex();
     XTRXInputThread *xtrxInputThread = findThread();
     bool needsStart = false;
 
     if (xtrxInputThread) // if thread is already allocated
     {
         qDebug("XTRXInput::start: thread is already allocated");
 
         unsigned int nbOriginalChannels = xtrxInputThread->getNbChannels();
 
         // if one channel is already allocated it must be the other one so we'll end up with both channels
         // thus we expand by deleting and re-creating the thread
         if (nbOriginalChannels != 0)
         {
             qDebug("XTRXInput::start: expand channels. Re-allocate thread and take ownership");
 
             SampleSinkFifo **fifos = new SampleSinkFifo*[2];
             unsigned int *log2Decims = new unsigned int[2];
 
             for (int i = 0; i < 2; i++) // save original FIFO references and data
             {
                 fifos[i] = xtrxInputThread->getFifo(i);
                 log2Decims[i] = xtrxInputThread->getLog2Decimation(i);
             }
 
             xtrxInputThread->stopWork();
             delete xtrxInputThread;
             xtrxInputThread = new XTRXInputThread(m_deviceShared.m_dev->getDevice(), 2); // MI mode (2 channels)
             m_XTRXInputThread = xtrxInputThread; // take ownership
             m_deviceShared.m_thread = xtrxInputThread;
 
             for (int i = 0; i < 2; i++) // restore original FIFO references
             {
                 xtrxInputThread->setFifo(i, fifos[i]);
                 xtrxInputThread->setLog2Decimation(i, log2Decims[i]);
             }
 
             // remove old thread address from buddies (reset in all buddies). The address being held only in the owning source.
             const std::vector<DeviceAPI*>& sourceBuddies = m_deviceAPI->getSourceBuddies();
             std::vector<DeviceAPI*>::const_iterator it = sourceBuddies.begin();
 
             for (; it != sourceBuddies.end(); ++it)
             {
                 ((DeviceXTRXShared*) (*it)->getBuddySharedPtr())->m_source->setThread(0);
                 ((DeviceXTRXShared*) (*it)->getBuddySharedPtr())->m_thread = 0;
             }
 
             // was used as temporary storage:
             delete[] fifos;
             delete[] log2Decims;
 
             needsStart = true;
         }
         else
         {
             qDebug("XTRXInput::start: keep buddy thread");
         }
     }
     else // first allocation
     {
         qDebug("XTRXInput::start: allocate thread and take ownership");
         xtrxInputThread = new XTRXInputThread(m_deviceShared.m_dev->getDevice(), 1, requestedChannel);
         m_XTRXInputThread = xtrxInputThread; // take ownership
         m_deviceShared.m_thread = xtrxInputThread;
         needsStart = true;
     }
 
     xtrxInputThread->setFifo(requestedChannel, &m_sampleFifo);
     xtrxInputThread->setLog2Decimation(requestedChannel, m_settings.m_log2SoftDecim);
 
     applySettings(m_settings, true);
 
     if (needsStart)
     {
         qDebug("XTRXInput::start: (re)start thread");
         xtrxInputThread->startWork();
     }
 
     qDebug("XTRXInput::start: started");
     m_running = true;
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ stop()

void XTRXInput::stop ( )

virtual

Implements DeviceSampleSource.

Definition at line 365 of file xtrxinput.cpp.

References applySettings(), findThread(), DeviceXTRX::getDevice(), DeviceAPI::getDeviceItemIndex(), XTRXInputThread::getNbChannels(), DeviceAPI::getSourceBuddies(), DeviceXTRXShared::m_dev, m_deviceAPI, m_deviceShared, XTRXInputSettings::m_log2SoftDecim, m_running, DeviceSampleSource::m_sampleFifo, m_settings, DeviceXTRXShared::m_thread, m_XTRXInputThread, XTRXInputThread::setFifo(), XTRXInputThread::setLog2Decimation(), XTRXInputThread::startWork(), and XTRXInputThread::stopWork().

Referenced by closeDevice(), XTRXInput::MsgFileRecord::MsgFileRecord(), and ~XTRXInput().

 {
     // This stop method is responsible for managing the thread when the streaming of a Rx channel is stopped
     //
     // If the thread is currently managing only one channel (SI mode). The thread can be just stopped and deleted.
     // Then the channel is closed.
     //
     // If the thread is currently managing both channels (MI mode) then we are removing one channel. Thus we must
     // transition from MI to SI. This transition is handled by stopping the thread, deleting it and creating a new one
     // managing a single channel.
 
     if (!m_running) {
         return;
     }
 
     int removedChannel = m_deviceAPI->getDeviceItemIndex(); // channel to remove
     int requestedChannel = removedChannel ^ 1; // channel to keep (opposite channel)
     XTRXInputThread *xtrxInputThread = findThread();
 
     if (xtrxInputThread == 0) { // no thread allocated
         return;
     }
 
     int nbOriginalChannels = xtrxInputThread->getNbChannels();
 
     if (nbOriginalChannels == 1) // SI mode => just stop and delete the thread
     {
         qDebug("XTRXInput::stop: SI mode. Just stop and delete the thread");
         xtrxInputThread->stopWork();
         delete xtrxInputThread;
         m_XTRXInputThread = 0;
         m_deviceShared.m_thread = 0;
 
         // remove old thread address from buddies (reset in all buddies)
         const std::vector<DeviceAPI*>& sourceBuddies = m_deviceAPI->getSourceBuddies();
         std::vector<DeviceAPI*>::const_iterator it = sourceBuddies.begin();
 
         for (; it != sourceBuddies.end(); ++it)
         {
             ((DeviceXTRXShared*) (*it)->getBuddySharedPtr())->m_source->setThread(0);
             ((DeviceXTRXShared*) (*it)->getBuddySharedPtr())->m_thread = 0;
         }
     }
     else if (nbOriginalChannels == 2) // Reduce from MI to SI by deleting and re-creating the thread
     {
         qDebug("XTRXInput::stop: MI mode. Reduce by deleting and re-creating the thread");
         xtrxInputThread->stopWork();
         delete xtrxInputThread;
         xtrxInputThread = new XTRXInputThread(m_deviceShared.m_dev->getDevice(), 1, requestedChannel);
         m_XTRXInputThread = xtrxInputThread; // take ownership
         m_deviceShared.m_thread = xtrxInputThread;
 
         xtrxInputThread->setFifo(requestedChannel, &m_sampleFifo);
         xtrxInputThread->setLog2Decimation(requestedChannel, m_settings.m_log2SoftDecim);
 
         // remove old thread address from buddies (reset in all buddies). The address being held only in the owning source.
         const std::vector<DeviceAPI*>& sourceBuddies = m_deviceAPI->getSourceBuddies();
         std::vector<DeviceAPI*>::const_iterator it = sourceBuddies.begin();
 
         for (; it != sourceBuddies.end(); ++it)
         {
             ((DeviceXTRXShared*) (*it)->getBuddySharedPtr())->m_source->setThread(0);
             ((DeviceXTRXShared*) (*it)->getBuddySharedPtr())->m_thread = 0;
         }
 
         applySettings(m_settings, true);
         xtrxInputThread->startWork();
     }
 
     m_running = false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ suspendTxThread()

void XTRXInput::suspendTxThread ( )

private

Definition at line 437 of file xtrxinput.cpp.

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

Referenced by applySettings().

 {
     const std::vector<DeviceAPI*>& sinkBuddies = m_deviceAPI->getSinkBuddies();
     std::vector<DeviceAPI*>::const_iterator itSink = sinkBuddies.begin();
 
     qDebug("XTRXInput::suspendTxThread (%lu)", sinkBuddies.size());
 
     for (; itSink != sinkBuddies.end(); ++itSink)
     {
         DeviceXTRXShared *buddySharedPtr = (DeviceXTRXShared *) (*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 XTRXInput::webapiFormatDeviceReport ( SWGSDRangel::SWGDeviceReport & response )

private

Definition at line 1507 of file xtrxinput.cpp.

References DeviceXTRXShared::get_board_temperature(), DeviceXTRXShared::get_gps_status(), DeviceXTRX::getDevice(), SWGSDRangel::SWGDeviceReport::getXtrxInputReport(), DeviceXTRXShared::m_dev, m_deviceShared, SWGSDRangel::SWGXtrxInputReport::setFifoFill(), SWGSDRangel::SWGXtrxInputReport::setFifoSize(), SWGSDRangel::SWGXtrxInputReport::setGpsLock(), SWGSDRangel::SWGXtrxInputReport::setSuccess(), and SWGSDRangel::SWGXtrxInputReport::setTemperature().

Referenced by webapiReportGet().

 {
     int ret;
     bool success = false;
     double temp = 0.0;
     bool gpsStatus = false;
     uint64_t fifolevel = 0;
     uint32_t fifosize = 1<<16;
 
     if (m_deviceShared.m_dev && m_deviceShared.m_dev->getDevice())
     {
         ret = xtrx_val_get(m_deviceShared.m_dev->getDevice(),
                      XTRX_RX, XTRX_CH_AB, XTRX_PERF_LLFIFO, &fifolevel);
         success = (ret >= 0);
         temp = m_deviceShared.get_board_temperature() / 256.0;
         gpsStatus = m_deviceShared.get_gps_status();
     }
 
     response.getXtrxInputReport()->setSuccess(success ? 1 : 0);
     response.getXtrxInputReport()->setFifoSize(fifosize);
     response.getXtrxInputReport()->setFifoFill(fifolevel);
     response.getXtrxInputReport()->setTemperature(temp);
     response.getXtrxInputReport()->setGpsLock(gpsStatus ? 1 : 0);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ webapiFormatDeviceSettings()

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

private

Definition at line 1429 of file xtrxinput.cpp.

Referenced by webapiSettingsGet(), and webapiSettingsPutPatch().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ webapiReportGet()

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

virtual

Reimplemented from DeviceSampleSource.

Definition at line 1468 of file xtrxinput.cpp.

References SWGSDRangel::SWGDeviceReport::getXtrxInputReport(), SWGSDRangel::SWGXtrxInputReport::init(), SWGSDRangel::SWGDeviceReport::setXtrxInputReport(), and webapiFormatDeviceReport().

Referenced by setSampleRate().

 {
     (void) errorMessage;
     response.setXtrxInputReport(new SWGSDRangel::SWGXtrxInputReport());
     response.getXtrxInputReport()->init();
     webapiFormatDeviceReport(response);
     return 200;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ webapiReverseSendSettings()

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

private

Definition at line 1532 of file xtrxinput.cpp.

Referenced by applySettings().

 {
     SWGSDRangel::SWGDeviceSettings *swgDeviceSettings = new SWGSDRangel::SWGDeviceSettings();
     swgDeviceSettings->setDirection(0); // single Rx
     swgDeviceSettings->setOriginatorIndex(m_deviceAPI->getDeviceSetIndex());
     swgDeviceSettings->setDeviceHwType(new QString("XTRX"));
     swgDeviceSettings->setXtrxInputSettings(new SWGSDRangel::SWGXtrxInputSettings());
     SWGSDRangel::SWGXtrxInputSettings *swgXtrxInputSettings = swgDeviceSettings->getXtrxInputSettings();
 
     // transfer data that has been modified. When force is on transfer all data except reverse API data
 
     if (deviceSettingsKeys.contains("centerFrequency") || force) {
         swgXtrxInputSettings->setCenterFrequency(settings.m_centerFrequency);
     }
     if (deviceSettingsKeys.contains("devSampleRate") || force) {
         swgXtrxInputSettings->setDevSampleRate(settings.m_devSampleRate);
     }
     if (deviceSettingsKeys.contains("log2HardDecim") || force) {
         swgXtrxInputSettings->setLog2HardDecim(settings.m_log2HardDecim);
     }
     if (deviceSettingsKeys.contains("dcBlock") || force) {
         swgXtrxInputSettings->setDcBlock(settings.m_dcBlock ? 1 : 0);
     }
     if (deviceSettingsKeys.contains("iqCorrection") || force) {
         swgXtrxInputSettings->setIqCorrection(settings.m_iqCorrection ? 1 : 0);
     }
     if (deviceSettingsKeys.contains("log2SoftDecim") || force) {
         swgXtrxInputSettings->setLog2SoftDecim(settings.m_log2SoftDecim);
     }
     if (deviceSettingsKeys.contains("ncoEnable") || force) {
         swgXtrxInputSettings->setNcoEnable(settings.m_ncoEnable ? 1 : 0);
     }
     if (deviceSettingsKeys.contains("ncoFrequency") || force) {
         swgXtrxInputSettings->setNcoFrequency(settings.m_ncoFrequency);
     }
     if (deviceSettingsKeys.contains("lpfBW") || force) {
         swgXtrxInputSettings->setLpfBw(settings.m_lpfBW);
     }
     if (deviceSettingsKeys.contains("antennaPath") || force) {
         swgXtrxInputSettings->setAntennaPath((int) settings.m_antennaPath);
     }
     if (deviceSettingsKeys.contains("gainMode") || force) {
         swgXtrxInputSettings->setGainMode((int) settings.m_gainMode);
     }
     if (deviceSettingsKeys.contains("gain") || force) {
         swgXtrxInputSettings->setGain(settings.m_gain);
     }
     if (deviceSettingsKeys.contains("lnaGain") || force) {
         swgXtrxInputSettings->setLnaGain(settings.m_lnaGain);
     }
     if (deviceSettingsKeys.contains("tiaGain") || force) {
         swgXtrxInputSettings->setTiaGain(settings.m_tiaGain);
     }
     if (deviceSettingsKeys.contains("pgaGain") || force) {
         swgXtrxInputSettings->setPgaGain(settings.m_pgaGain);
     }
     if (deviceSettingsKeys.contains("extClock") || force) {
         swgXtrxInputSettings->setExtClock(settings.m_extClock ? 1 : 0);
     }
     if (deviceSettingsKeys.contains("extClockFreq") || force) {
         swgXtrxInputSettings->setExtClockFreq(settings.m_extClockFreq);
     }
     if (deviceSettingsKeys.contains("pwrmode") || force) {
         swgXtrxInputSettings->setPwrmode(settings.m_pwrmode);
     }
     if (deviceSettingsKeys.contains("fileRecordName") || force) {
         swgXtrxInputSettings->setFileRecordName(new QString(settings.m_fileRecordName));
     }
 
     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 XTRXInput::webapiReverseSendStartStop ( bool start )

private

Definition at line 1619 of file xtrxinput.cpp.

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

 {
     SWGSDRangel::SWGDeviceSettings *swgDeviceSettings = new SWGSDRangel::SWGDeviceSettings();
     swgDeviceSettings->setDirection(0); // single Rx
     swgDeviceSettings->setOriginatorIndex(m_deviceAPI->getDeviceSetIndex());
     swgDeviceSettings->setDeviceHwType(new QString("XTRX"));
 
     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:

◆ webapiRun()

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

virtual

Reimplemented from DeviceSampleSource.

Definition at line 1488 of file xtrxinput.cpp.

References XTRXInput::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 XTRXInput::webapiRunGet	(	SWGSDRangel::SWGDeviceState &	response,
		QString &	errorMessage
	)

virtual

Reimplemented from DeviceSampleSource.

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

virtual

Reimplemented from DeviceSampleSource.

Definition at line 1326 of file xtrxinput.cpp.

References SWGSDRangel::SWGDeviceSettings::getXtrxInputSettings(), SWGSDRangel::SWGXtrxInputSettings::init(), m_settings, SWGSDRangel::SWGDeviceSettings::setXtrxInputSettings(), and webapiFormatDeviceSettings().

Referenced by setSampleRate().

 {
     (void) errorMessage;
     response.setXtrxInputSettings(new SWGSDRangel::SWGXtrxInputSettings());
     response.getXtrxInputSettings()->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 XTRXInput::webapiSettingsPutPatch	(	bool	force,
		const QStringList &	deviceSettingsKeys,
		SWGSDRangel::SWGDeviceSettings &	response,
		QString &	errorMessage
	)

virtual

Reimplemented from DeviceSampleSource.

Definition at line 1337 of file xtrxinput.cpp.

Referenced by setSampleRate().

 {
     (void) errorMessage;
     XTRXInputSettings settings = m_settings;
 
     if (deviceSettingsKeys.contains("centerFrequency")) {
         settings.m_centerFrequency = response.getXtrxInputSettings()->getCenterFrequency();
     }
     if (deviceSettingsKeys.contains("devSampleRate")) {
         settings.m_devSampleRate = response.getXtrxInputSettings()->getDevSampleRate();
     }
     if (deviceSettingsKeys.contains("log2HardDecim")) {
         settings.m_log2HardDecim = response.getXtrxInputSettings()->getLog2HardDecim();
     }
     if (deviceSettingsKeys.contains("dcBlock")) {
         settings.m_dcBlock = response.getXtrxInputSettings()->getDcBlock() != 0;
     }
     if (deviceSettingsKeys.contains("iqCorrection")) {
         settings.m_iqCorrection = response.getXtrxInputSettings()->getIqCorrection() != 0;
     }
     if (deviceSettingsKeys.contains("log2SoftDecim")) {
         settings.m_log2SoftDecim = response.getXtrxInputSettings()->getLog2SoftDecim();
     }
     if (deviceSettingsKeys.contains("lpfBW")) {
         settings.m_lpfBW = response.getXtrxInputSettings()->getLpfBw();
     }
     if (deviceSettingsKeys.contains("gain")) {
         settings.m_gain = response.getXtrxInputSettings()->getGain();
     }
     if (deviceSettingsKeys.contains("ncoEnable")) {
         settings.m_ncoEnable = response.getXtrxInputSettings()->getNcoEnable() != 0;
     }
     if (deviceSettingsKeys.contains("ncoFrequency")) {
         settings.m_ncoFrequency = response.getXtrxInputSettings()->getNcoFrequency();
     }
     if (deviceSettingsKeys.contains("antennaPath")) {
         settings.m_antennaPath = (xtrx_antenna_t) response.getXtrxInputSettings()->getAntennaPath();
     }
     if (deviceSettingsKeys.contains("gainMode")) {
         settings.m_gainMode = (XTRXInputSettings::GainMode) response.getXtrxInputSettings()->getGainMode();
     }
     if (deviceSettingsKeys.contains("lnaGain")) {
         settings.m_lnaGain = response.getXtrxInputSettings()->getLnaGain();
     }
     if (deviceSettingsKeys.contains("tiaGain")) {
         settings.m_tiaGain = response.getXtrxInputSettings()->getTiaGain();
     }
     if (deviceSettingsKeys.contains("pgaGain")) {
         settings.m_pgaGain = response.getXtrxInputSettings()->getPgaGain();
     }
     if (deviceSettingsKeys.contains("extClock")) {
         settings.m_extClock = response.getXtrxInputSettings()->getExtClock() != 0;
     }
     if (deviceSettingsKeys.contains("extClockFreq")) {
         settings.m_extClockFreq = response.getXtrxInputSettings()->getExtClockFreq();
     }
     if (deviceSettingsKeys.contains("pwrmode")) {
         settings.m_pwrmode = response.getXtrxInputSettings()->getPwrmode();
     }
     if (deviceSettingsKeys.contains("fileRecordName")) {
         settings.m_fileRecordName = *response.getXtrxInputSettings()->getFileRecordName();
     }
     if (deviceSettingsKeys.contains("useReverseAPI")) {
         settings.m_useReverseAPI = response.getXtrxInputSettings()->getUseReverseApi() != 0;
     }
     if (deviceSettingsKeys.contains("reverseAPIAddress")) {
         settings.m_reverseAPIAddress = *response.getXtrxInputSettings()->getReverseApiAddress();
     }
     if (deviceSettingsKeys.contains("reverseAPIPort")) {
         settings.m_reverseAPIPort = response.getXtrxInputSettings()->getReverseApiPort();
     }
     if (deviceSettingsKeys.contains("reverseAPIDeviceIndex")) {
         settings.m_reverseAPIDeviceIndex = response.getXtrxInputSettings()->getReverseApiDeviceIndex();
     }
 
     MsgConfigureXTRX *msg = MsgConfigureXTRX::create(settings, force);
     m_inputMessageQueue.push(msg);
 
     if (m_guiMessageQueue) // forward to GUI if any
     {
         MsgConfigureXTRX *msgToGUI = MsgConfigureXTRX::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_deviceAPI

DeviceAPI* XTRXInput::m_deviceAPI

private

Definition at line 252 of file xtrxinput.h.

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

◆ m_deviceDescription

QString XTRXInput::m_deviceDescription

private

Definition at line 256 of file xtrxinput.h.

Referenced by getDeviceDescription().

◆ m_deviceShared

DeviceXTRXShared XTRXInput::m_deviceShared

private

Definition at line 258 of file xtrxinput.h.

Referenced by apply_gain_lna(), apply_gain_pga(), apply_gain_tia(), applySettings(), closeDevice(), getChannelIndex(), getClockGen(), getDevSampleRate(), getLog2HardDecim(), getSampleRate(), handleMessage(), openDevice(), start(), stop(), and webapiFormatDeviceReport().

◆ m_fileSink

FileRecord* XTRXInput::m_fileSink

private

File sink to record device I/Q output.

Definition at line 262 of file xtrxinput.h.

Referenced by handleMessage(), and ~XTRXInput().

◆ m_mutex

QMutex XTRXInput::m_mutex

private

Definition at line 253 of file xtrxinput.h.

◆ m_networkManager

QNetworkAccessManager* XTRXInput::m_networkManager

private

Definition at line 259 of file xtrxinput.h.

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

◆ m_networkRequest

QNetworkRequest XTRXInput::m_networkRequest

private

Definition at line 260 of file xtrxinput.h.

Referenced by webapiReverseSendSettings(), and webapiReverseSendStartStop().

◆ m_running

bool XTRXInput::m_running

private

Definition at line 257 of file xtrxinput.h.

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

◆ m_settings

XTRXInputSettings XTRXInput::m_settings

private

Definition at line 254 of file xtrxinput.h.

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

◆ m_XTRXInputThread

XTRXInputThread* XTRXInput::m_XTRXInputThread

private

Definition at line 255 of file xtrxinput.h.

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

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

plugins/samplesource/xtrxinput/xtrxinput.h
plugins/samplesource/xtrxinput/xtrxinput.cpp

Classes

Public Member Functions

Private Slots

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ XTRXInput()

◆ ~XTRXInput()

Member Function Documentation

◆ apply_gain_auto()

◆ apply_gain_lna()

◆ apply_gain_pga()

◆ apply_gain_tia()

◆ applySettings()

◆ closeDevice()

◆ deserialize()

◆ destroy()

◆ findThread()

◆ getCenterFrequency()

◆ getChannelIndex()

◆ getClockGen()

◆ getDeviceDescription()

◆ getDevSampleRate()

◆ getLog2HardDecim()

◆ getLORange()

◆ getLPRange()

◆ getSampleRate()

◆ getSRRange()

◆ getThread()

◆ handleMessage()

◆ init()

◆ moveThreadToBuddy()

◆ networkManagerFinished

◆ openDevice()

◆ resumeTxThread()

◆ serialize()

◆ setCenterFrequency()

◆ setMessageQueueToGUI()

◆ setSampleRate()

◆ setThread()

◆ start()

◆ stop()

◆ suspendTxThread()

◆ webapiFormatDeviceReport()

◆ webapiFormatDeviceSettings()

◆ webapiReportGet()

◆ webapiReverseSendSettings()

◆ webapiReverseSendStartStop()

◆ webapiRun()

◆ webapiRunGet()

◆ webapiSettingsGet()

◆ webapiSettingsPutPatch()

Member Data Documentation

◆ m_deviceAPI

◆ m_deviceDescription

◆ m_deviceShared

◆ m_fileSink

◆ m_mutex

◆ m_networkManager

◆ m_networkRequest

◆ m_running

◆ m_settings

◆ m_XTRXInputThread