XTRXOutput Class Reference

#include <xtrxoutput.h>

Inheritance diagram for XTRXOutput:

Collaboration diagram for XTRXOutput:

Classes
class	MsgConfigureXTRX
class	MsgGetDeviceInfo
class	MsgGetStreamInfo
class	MsgReportClockGenChange
class	MsgReportStreamInfo
class	MsgStartStop

Public Member Functions
	XTRXOutput (DeviceAPI *deviceAPI)
virtual	~XTRXOutput ()
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 ()
XTRXOutputThread *	getThread ()
void	setThread (XTRXOutputThread *thread)
virtual QByteArray	serialize () const
virtual bool	deserialize (const QByteArray &data)
virtual void	setMessageQueueToGUI (MessageQueue *queue)
virtual const QString &	getDeviceDescription () const
virtual int	getSampleRate () const
	Sample rate exposed by the sink. More...
virtual void	setSampleRate (int sampleRate)
	For when the sink sample rate is set externally. More...
uint32_t	getDevSampleRate () const
uint32_t	getLog2HardInterp () const
double	getClockGen () const
virtual quint64	getCenterFrequency () const
	Center frequency exposed by the sink. More...
virtual void	setCenterFrequency (qint64 centerFrequency)
virtual bool	handleMessage (const Message &message)
virtual int	webapiSettingsGet (SWGSDRangel::SWGDeviceSettings &response, QString &errorMessage)
virtual int	webapiSettingsPutPatch (bool force, const QStringList &deviceSettingsKeys, SWGSDRangel::SWGDeviceSettings &response, QString &errorMessage)
virtual int	webapiReportGet (SWGSDRangel::SWGDeviceReport &response, QString &errorMessage)
virtual int	webapiRunGet (SWGSDRangel::SWGDeviceState &response, QString &errorMessage)
virtual int	webapiRun (bool run, SWGSDRangel::SWGDeviceState &response, QString &errorMessage)
std::size_t	getChannelIndex ()
void	getLORange (float &minF, float &maxF, float &stepF) const
void	getSRRange (float &minF, float &maxF, float &stepF) const
void	getLPRange (float &minF, float &maxF, float &stepF) const
Public Member Functions inherited from DeviceSampleSink
	DeviceSampleSink ()
virtual	~DeviceSampleSink ()
MessageQueue *	getInputMessageQueue ()
MessageQueue *	getMessageQueueToGUI ()
SampleSourceFifo *	getSampleFifo ()

Private Slots
void	networkManagerFinished (QNetworkReply *reply)

Private Member Functions
bool	openDevice ()
void	closeDevice ()
XTRXOutputThread *	findThread ()
void	moveThreadToBuddy ()
void	suspendRxThread ()
void	resumeRxThread ()
bool	applySettings (const XTRXOutputSettings &settings, bool force=false, bool forceNCOFrequency=false)
void	webapiFormatDeviceSettings (SWGSDRangel::SWGDeviceSettings &response, const XTRXOutputSettings &settings)
void	webapiFormatDeviceReport (SWGSDRangel::SWGDeviceReport &response)
void	webapiReverseSendSettings (QList< QString > &deviceSettingsKeys, const XTRXOutputSettings &settings, bool force)
void	webapiReverseSendStartStop (bool start)

Private Attributes
DeviceAPI *	m_deviceAPI
QMutex	m_mutex
XTRXOutputSettings	m_settings
XTRXOutputThread *	m_XTRXOutputThread
QString	m_deviceDescription
bool	m_running
DeviceXTRXShared	m_deviceShared
QNetworkAccessManager *	m_networkManager
QNetworkRequest	m_networkRequest

Additional Inherited Members
Public Types inherited from DeviceSampleSink
enum	fcPos_t { FC_POS_INFRA = 0, FC_POS_SUPRA, FC_POS_CENTER }
Static Public Member Functions inherited from DeviceSampleSink
static qint64	calculateDeviceCenterFrequency (quint64 centerFrequency, qint64 transverterDeltaFrequency, int log2Interp, fcPos_t fcPos, quint32 devSampleRate, bool transverterMode=false)
static qint64	calculateCenterFrequency (quint64 deviceCenterFrequency, qint64 transverterDeltaFrequency, int log2Interp, fcPos_t fcPos, quint32 devSampleRate, bool transverterMode=false)
static qint32	calculateFrequencyShift (int log2Interp, fcPos_t fcPos, quint32 devSampleRate)
Protected Slots inherited from DeviceSampleSink
void	handleInputMessages ()
Protected Attributes inherited from DeviceSampleSink
SampleSourceFifo	m_sampleSourceFifo
MessageQueue	m_inputMessageQueue
	Input queue to the sink. More...
MessageQueue *	m_guiMessageQueue
	Input message queue to the GUI. More...

Detailed Description

Definition at line 37 of file xtrxoutput.h.

Constructor & Destructor Documentation

XTRXOutput()

XTRXOutput::XTRXOutput

(

DeviceAPI *

deviceAPI

)

Definition at line 48 of file xtrxoutput.cpp.

Referenced by XTRXOutput::MsgStartStop::MsgStartStop().

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

Here is the caller graph for this function:

~XTRXOutput()

XTRXOutput::~XTRXOutput ( )

virtual

Definition at line 61 of file xtrxoutput.cpp.

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

Referenced by XTRXOutput::MsgStartStop::MsgStartStop().

{
    disconnect(m_networkManager, SIGNAL(finished(QNetworkReply*)), this, SLOT(networkManagerFinished(QNetworkReply*)));
    delete m_networkManager;

    if (m_running) {
        stop();
    }

    closeDevice();
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Function Documentation

applySettings()

bool XTRXOutput::applySettings ( const XTRXOutputSettings &  settings, bool  force = false, bool  forceNCOFrequency = false  )

private

Definition at line 757 of file xtrxoutput.cpp.

References DeviceXTRXShared::MsgReportBuddyChange::create(), DeviceXTRXShared::MsgReportClockSourceChange::create(), XTRXOutput::MsgReportClockGenChange::create(), findThread(), DeviceXTRX::getActualOutputRate(), DeviceXTRX::getDevice(), DeviceAPI::getDeviceEngineInputMessageQueue(), DeviceAPI::getDeviceItemIndex(), getDevSampleRate(), getLog2HardInterp(), DeviceSampleSink::getMessageQueueToGUI(), getSampleRate(), DeviceAPI::getSinkBuddies(), DeviceAPI::getSourceBuddies(), XTRXOutputThread::isRunning(), XTRXOutputSettings::m_antennaPath, XTRXOutputSettings::m_centerFrequency, DeviceXTRXShared::m_channel, DeviceXTRXShared::m_dev, m_deviceAPI, m_deviceShared, XTRXOutputSettings::m_devSampleRate, XTRXOutputSettings::m_extClock, XTRXOutputSettings::m_extClockFreq, XTRXOutputSettings::m_gain, XTRXOutputSettings::m_log2HardInterp, XTRXOutputSettings::m_log2SoftInterp, XTRXOutputSettings::m_lpfBW, XTRXOutputSettings::m_ncoEnable, XTRXOutputSettings::m_ncoFrequency, XTRXOutputSettings::m_pwrmode, XTRXOutputSettings::m_reverseAPIAddress, XTRXOutputSettings::m_reverseAPIDeviceIndex, XTRXOutputSettings::m_reverseAPIPort, m_settings, XTRXOutputSettings::m_useReverseAPI, MessageQueue::push(), resumeRxThread(), DeviceXTRX::set_samplerate(), XTRXOutputThread::setLog2Interpolation(), XTRXOutputThread::startWork(), XTRXOutputThread::stopWork(), suspendRxThread(), and webapiReverseSendSettings().

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

{
    int requestedChannel = m_deviceAPI->getDeviceItemIndex();
    XTRXOutputThread *outputThread = findThread();
    QList<QString> reverseAPIKeys;

    bool forwardChangeOwnDSP = false;
    bool forwardChangeTxDSP  = false;
    bool forwardChangeAllDSP = false;
    bool forwardClockSource  = false;
    bool txThreadWasRunning = false;
    bool doLPCalibration = false;
    bool doChangeSampleRate = false;
    bool doChangeFreq = false;

    // apply settings

    qDebug() << "XTRXOutput::applySettings: m_centerFrequency: " << m_settings.m_centerFrequency
             << " m_devSampleRate: " << m_settings.m_devSampleRate
             << " m_log2SoftInterp: " << m_settings.m_log2SoftInterp
             << " 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;

    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("XTRXOutput::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("XTRXOutput::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_log2HardInterp != settings.m_log2HardInterp) || force) {
        reverseAPIKeys.append("log2HardInterp");
    }

    if ((m_settings.m_devSampleRate != settings.m_devSampleRate)
       || (m_settings.m_log2HardInterp != settings.m_log2HardInterp) || force)
    {
        forwardChangeAllDSP = true; //m_settings.m_devSampleRate != settings.m_devSampleRate;

        if (m_deviceShared.m_dev->getDevice() != 0) {
            doChangeSampleRate = true;
        }
    }

    if ((m_settings.m_gain != settings.m_gain) || force)
    {
        reverseAPIKeys.append("gain");

        if (m_deviceShared.m_dev->getDevice() != 0)
        {
            if (xtrx_set_gain(m_deviceShared.m_dev->getDevice(),
                    m_deviceShared.m_channel == 0 ? XTRX_CH_A : XTRX_CH_B,
                    XTRX_TX_PAD_GAIN,
                    settings.m_gain,
                    0) < 0) {
                qDebug("XTRXOutput::applySettings: xtrx_set_gain(PAD) failed");
            } else {
                qDebug() << "XTRXOutput::applySettings: Gain (PAD) set to " << settings.m_gain;
            }
        }
    }

    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("XTRXOutput::applySettings: could %s and set LPF FIR to %f Hz",
                          settings.m_lpfFIREnable ? "enable" : "disable",
                          settings.m_lpfFIRBW);
            }
            else
            {
                //doCalibration = true;
                qDebug("XTRXOutput::applySettings: %sd and set LPF FIR to %f Hz",
                       settings.m_lpfFIREnable ? "enable" : "disable",
                       settings.m_lpfFIRBW);
            }
        }
    }
#endif

    if ((m_settings.m_log2SoftInterp != settings.m_log2SoftInterp) || force)
    {
        reverseAPIKeys.append("log2SoftInterp");
        forwardChangeOwnDSP = true;

        if (outputThread != 0)
        {
            outputThread->setLog2Interpolation(requestedChannel, settings.m_log2SoftInterp);
            qDebug() << "XTRXOutput::applySettings: set soft interpolation to " << (1<<settings.m_log2SoftInterp);
        }
    }

    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("XTRXOutput::applySettings: could not set antenna path to %d", (int) settings.m_antennaPath);
            } else {
                qDebug("XTRXOutput::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)
    {
        XTRXOutputThread *txThread = findThread();

        if (txThread && txThread->isRunning())
        {
            txThread->stopWork();
            txThreadWasRunning = true;
        }

        suspendRxThread();

        double master = (settings.m_log2HardInterp == 0) ? 0 : (settings.m_devSampleRate * 4 * (1 << settings.m_log2HardInterp));

        if (m_deviceShared.m_dev->set_samplerate(settings.m_devSampleRate,
                master, //(settings.m_devSampleRate<<settings.m_log2HardDecim)*4,
                true) < 0)
        {
            qCritical("XTRXOutput::applySettings: could not set sample rate to %f with oversampling of %d",
                      settings.m_devSampleRate,
                      1<<settings.m_log2HardInterp);
        }
        else
        {
            doChangeFreq = true;
            forceNCOFrequency = true;
            forwardChangeAllDSP = true;

            qDebug("XTRXOutput::applySettings: sample rate set to %f with oversampling of %d",
                   m_deviceShared.m_dev->getActualOutputRate(),
                   1 << getLog2HardInterp());
        }

        resumeRxThread();

        if (txThreadWasRunning) {
            txThread->startWork();
        }
    }

    if (doLPCalibration)
    {
        if (xtrx_tune_tx_bandwidth(m_deviceShared.m_dev->getDevice(),
                m_deviceShared.m_channel == 0 ? XTRX_CH_A : XTRX_CH_B,
                m_settings.m_lpfBW,
                0) < 0) {
            qCritical("XTRXOutput::applySettings: could not set LPF to %f Hz", m_settings.m_lpfBW);
        } else {
            qDebug("XTRXOutput::applySettings: LPF set to %f Hz", m_settings.m_lpfBW);
        }
    }

    if (doChangeFreq)
    {
        forwardChangeTxDSP = true;

        if (m_deviceShared.m_dev->getDevice() != 0)
        {
            if (xtrx_tune(m_deviceShared.m_dev->getDevice(),
                    XTRX_TUNE_TX_FDD,
                    settings.m_centerFrequency,
                    0) < 0) {
                qCritical("XTRXOutput::applySettings: could not set frequency to %lu", settings.m_centerFrequency);
            } else {
                //doCalibration = true;
                qDebug("XTRXOutput::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_TX,
                    m_deviceShared.m_channel == 0 ? XTRX_CH_A : XTRX_CH_B,
                    (settings.m_ncoEnable) ? settings.m_ncoFrequency : 0,
                    NULL) < 0)
            {
                qCritical("XTRXOutput::applySettings: could not %s and set NCO to %d Hz",
                          settings.m_ncoEnable ? "enable" : "disable",
                          settings.m_ncoFrequency);
            }
            else
            {
                forwardChangeOwnDSP = true;
                qDebug("XTRXOutput::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("XTRXOutput::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(), getLog2HardInterp(), 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(), getLog2HardInterp(), m_settings.m_centerFrequency, true);
            (*itSink)->getSamplingDeviceInputMessageQueue()->push(report);
        }
    }
    else if (forwardChangeTxDSP)
    {
        qDebug("XTRXOutput::applySettings: forward change to Tx 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 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(), getLog2HardInterp(), m_settings.m_centerFrequency, true);
            (*itSink)->getSamplingDeviceInputMessageQueue()->push(report);
        }
    }
    else if (forwardChangeOwnDSP)
    {
        qDebug("XTRXOutput::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_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);
        }
    }

    qDebug() << "XTRXOutput::applySettings:"
             << " device stream sample rate: " << getDevSampleRate() << "S/s"
             << " sample rate with soft interpolation: " << getSampleRate() << "S/s"
             << " forceNCOFrequency: " << forceNCOFrequency
             << " doLPCalibration: " << doLPCalibration
             << " doChangeFreq: " << doChangeFreq
             << " doChangeSampleRate: " << doChangeSampleRate;

    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

closeDevice()

void XTRXOutput::closeDevice ( )

private

Definition at line 152 of file xtrxoutput.cpp.

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

Referenced by ~XTRXOutput().

{
    if (m_deviceShared.m_dev == 0) { // was never open
        return;
    }

    if (m_running) {
        stop();
    }

    if (m_XTRXOutputThread) { // stills own the thread => transfer to a buddy
        moveThreadToBuddy();
    }

    m_deviceShared.m_channel = -1; // publicly release channel
    m_deviceShared.m_sink = 0;

    // No buddies so effectively close the device

    if ((m_deviceAPI->getSinkBuddies().size() == 0) && (m_deviceAPI->getSourceBuddies().size() == 0))
    {
        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 XTRXOutput::deserialize ( const QByteArray &  data )

virtual

Implements DeviceSampleSink.

Definition at line 466 of file xtrxoutput.cpp.

References XTRXOutput::MsgConfigureXTRX::create(), XTRXOutputSettings::deserialize(), DeviceSampleSink::m_guiMessageQueue, DeviceSampleSink::m_inputMessageQueue, m_settings, MessageQueue::push(), and XTRXOutputSettings::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 XTRXOutput::destroy ( )

virtual

Implements DeviceSampleSink.

Definition at line 73 of file xtrxoutput.cpp.

Referenced by XTRXOutput::MsgStartStop::MsgStartStop().

{
    delete this;
}

Here is the caller graph for this function:

findThread()

XTRXOutputThread * XTRXOutput::findThread ( )

private

Definition at line 184 of file xtrxoutput.cpp.

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

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

{
    if (m_XTRXOutputThread == 0) // this does not own the thread
    {
        XTRXOutputThread *xtrxOutputThread = 0;

        // find a buddy that has allocated the thread
        const std::vector<DeviceAPI*>& sinkBuddies = m_deviceAPI->getSinkBuddies();
        std::vector<DeviceAPI*>::const_iterator it = sinkBuddies.begin();

        for (; it != sinkBuddies.end(); ++it)
        {
            XTRXOutput *buddySink = ((DeviceXTRXShared*) (*it)->getBuddySharedPtr())->m_sink;

            if (buddySink)
            {
                xtrxOutputThread = buddySink->getThread();

                if (xtrxOutputThread) {
                    break;
                }
            }
        }

        return xtrxOutputThread;
    }
    else
    {
        return m_XTRXOutputThread; // own thread
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

getCenterFrequency()

quint64 XTRXOutput::getCenterFrequency ( ) const

virtual

Center frequency exposed by the sink.

Implements DeviceSampleSink.

Definition at line 535 of file xtrxoutput.cpp.

References XTRXOutputSettings::m_centerFrequency, XTRXOutputSettings::m_ncoEnable, XTRXOutputSettings::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 XTRXOutput::getChannelIndex

(

)

Definition at line 555 of file xtrxoutput.cpp.

References DeviceXTRXShared::m_channel, and m_deviceShared.

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

{
    return m_deviceShared.m_channel;
}

Here is the caller graph for this function:

getClockGen()

double XTRXOutput::getClockGen

(

)

const

Definition at line 526 of file xtrxoutput.cpp.

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

Referenced by setSampleRate(), and XTRXOutputGUI::updateDACRate().

{
    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 & XTRXOutput::getDeviceDescription ( ) const

virtual

Implements DeviceSampleSink.

Definition at line 488 of file xtrxoutput.cpp.

References m_deviceDescription.

Referenced by setMessageQueueToGUI().

{
    return m_deviceDescription;
}

Here is the caller graph for this function:

getDevSampleRate()

uint32_t XTRXOutput::getDevSampleRate

(

)

const

Definition at line 504 of file xtrxoutput.cpp.

References DeviceXTRX::getActualOutputRate(), DeviceXTRXShared::m_dev, m_deviceShared, XTRXOutputSettings::m_devSampleRate, and m_settings.

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

{
    uint32_t devSampleRate = m_settings.m_devSampleRate;

    if (m_deviceShared.m_dev) {
        devSampleRate = m_deviceShared.m_dev->getActualOutputRate();
    }

    return devSampleRate;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getLog2HardInterp()

uint32_t XTRXOutput::getLog2HardInterp

(

)

const

Definition at line 515 of file xtrxoutput.cpp.

References DeviceXTRX::getActualOutputRate(), DeviceXTRX::getClockGen(), DeviceXTRXShared::m_dev, m_deviceShared, XTRXOutputSettings::m_log2HardInterp, and m_settings.

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

{
    uint32_t log2HardInterp = m_settings.m_log2HardInterp;

    if (m_deviceShared.m_dev && (m_deviceShared.m_dev->getActualOutputRate() != 0.0)) {
        log2HardInterp = log2(m_deviceShared.m_dev->getClockGen() / m_deviceShared.m_dev->getActualOutputRate() / 4);
    }

    return log2HardInterp;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getLORange()

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

Definition at line 560 of file xtrxoutput.cpp.

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

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

Here is the caller graph for this function:

getLPRange()

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

Definition at line 578 of file xtrxoutput.cpp.

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

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

Here is the caller graph for this function:

getSampleRate()

int XTRXOutput::getSampleRate ( ) const

virtual

Sample rate exposed by the sink.

Implements DeviceSampleSink.

Definition at line 493 of file xtrxoutput.cpp.

References DeviceXTRX::getActualOutputRate(), DeviceXTRXShared::m_dev, m_deviceShared, XTRXOutputSettings::m_devSampleRate, XTRXOutputSettings::m_log2SoftInterp, and m_settings.

Referenced by applySettings(), and setMessageQueueToGUI().

{
    double rate = m_settings.m_devSampleRate;

    if (m_deviceShared.m_dev) {
        rate = m_deviceShared.m_dev->getActualOutputRate();
    }

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

Here is the call graph for this function:

Here is the caller graph for this function:

getSRRange()

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

Definition at line 569 of file xtrxoutput.cpp.

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

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

Here is the caller graph for this function:

getThread()

XTRXOutputThread* XTRXOutput::getThread ( )

inline

Definition at line 180 of file xtrxoutput.h.

References m_XTRXOutputThread.

Referenced by findThread().

{ return m_XTRXOutputThread; }

Here is the caller graph for this function:

handleMessage()

bool XTRXOutput::handleMessage ( const Message &  message )

virtual

Implements DeviceSampleSink.

Definition at line 587 of file xtrxoutput.cpp.

References applySettings(), DeviceXTRXShared::MsgReportBuddyChange::create(), DeviceXTRXShared::MsgReportClockSourceChange::create(), DeviceXTRXShared::MsgReportDeviceInfo::create(), XTRXOutput::MsgReportStreamInfo::create(), DeviceXTRXShared::get_board_temperature(), DeviceXTRXShared::get_gps_status(), DeviceXTRX::getActualOutputRate(), DeviceXTRXShared::MsgReportBuddyChange::getCenterFrequency(), DeviceXTRX::getClockGen(), DeviceXTRX::getDevice(), DeviceAPI::getDeviceEngineInputMessageQueue(), DeviceXTRXShared::MsgReportBuddyChange::getDevSampleRate(), DeviceXTRXShared::MsgReportClockSourceChange::getExtClock(), DeviceXTRXShared::MsgReportClockSourceChange::getExtClockFeq(), XTRXOutput::MsgConfigureXTRX::getForce(), DeviceXTRXShared::MsgReportBuddyChange::getLog2HardDecimInterp(), getLog2HardInterp(), DeviceSampleSink::getMessageQueueToGUI(), DeviceXTRXShared::MsgReportBuddyChange::getRxElseTx(), DeviceAPI::getSamplingDeviceGUIMessageQueue(), XTRXOutput::MsgConfigureXTRX::getSettings(), DeviceAPI::getSinkBuddies(), DeviceAPI::getSourceBuddies(), XTRXOutput::MsgStartStop::getStartStop(), DeviceAPI::initDeviceEngine(), XTRXOutputSettings::m_centerFrequency, DeviceXTRXShared::m_dev, m_deviceAPI, m_deviceShared, XTRXOutputSettings::m_devSampleRate, XTRXOutputSettings::m_extClock, XTRXOutputSettings::m_extClockFreq, XTRXOutputSettings::m_log2HardInterp, XTRXOutputSettings::m_log2SoftInterp, XTRXOutputSettings::m_ncoEnable, XTRXOutputSettings::m_ncoFrequency, m_settings, Message::match(), MessageQueue::push(), DeviceAPI::startDeviceEngine(), and DeviceAPI::stopDeviceEngine().

Referenced by setSampleRate().

{
    if (MsgConfigureXTRX::match(message))
    {
        MsgConfigureXTRX& conf = (MsgConfigureXTRX&) message;
        qDebug() << "XTRXOutput::handleMessage: MsgConfigureXTRX";

        if (!applySettings(conf.getSettings(), conf.getForce()))
        {
            qDebug("XTRXOutput::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_log2HardInterp   = report.getLog2HardDecimInterp();
            m_settings.m_centerFrequency = report.getCenterFrequency();
        }
        else
        {
            m_settings.m_devSampleRate = m_deviceShared.m_dev->getActualOutputRate();
            m_settings.m_log2HardInterp = getLog2HardInterp();

            qDebug() << "XTRXOutput::handleMessage: MsgReportBuddyChange:"
                     << " host_Hz: " << m_deviceShared.m_dev->getActualOutputRate()
                     << " dac_Hz: " << m_deviceShared.m_dev->getClockGen() / 4
                     << " m_log2HardInterp: " << m_settings.m_log2HardInterp;
        }

        if (m_settings.m_ncoEnable) // need to reset NCO after sample rate change
        {
            applySettings(m_settings, false, true);
        }

        int ncoShift = m_settings.m_ncoEnable ? m_settings.m_ncoFrequency : 0;

        DSPSignalNotification *notif = new DSPSignalNotification(
                    m_settings.m_devSampleRate/(1<<m_settings.m_log2SoftInterp),
                    m_settings.m_centerFrequency + ncoShift);
        m_deviceAPI->getDeviceEngineInputMessageQueue()->push(notif);

        if (getMessageQueueToGUI())
        {
            DeviceXTRXShared::MsgReportBuddyChange *reportToGUI = DeviceXTRXShared::MsgReportBuddyChange::create(
                        m_settings.m_devSampleRate, m_settings.m_log2HardInterp, 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_TX, 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("XTRXOutput::handleMessage: MsgGetDeviceInfo: cannot get board temperature");
        }

        if (!m_deviceShared.m_dev->getDevice()) {
            qDebug("XTRXOutput::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 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);
            }
        }

        // 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);
            }
        }

        return true;
    }
    else if (MsgStartStop::match(message))
    {
        MsgStartStop& cmd = (MsgStartStop&) message;
        qDebug() << "XTRXOutput::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 XTRXOutput::init ( )

virtual

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

Implements DeviceSampleSink.

Definition at line 179 of file xtrxoutput.cpp.

References applySettings(), and m_settings.

Referenced by XTRXOutput::MsgStartStop::MsgStartStop().

{
    applySettings(m_settings, true, false);
}

Here is the call graph for this function:

Here is the caller graph for this function:

moveThreadToBuddy()

void XTRXOutput::moveThreadToBuddy ( )

private

Definition at line 216 of file xtrxoutput.cpp.

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

Referenced by closeDevice().

{
    const std::vector<DeviceAPI*>& sinkBuddies = m_deviceAPI->getSinkBuddies();
    std::vector<DeviceAPI*>::const_iterator it = sinkBuddies.begin();

    for (; it != sinkBuddies.end(); ++it)
    {
        XTRXOutput *buddySink = ((DeviceXTRXShared*) (*it)->getBuddySharedPtr())->m_sink;

        if (buddySink)
        {
            buddySink->setThread(m_XTRXOutputThread);
            m_XTRXOutputThread = 0;  // zero for others
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

networkManagerFinished

void XTRXOutput::networkManagerFinished ( QNetworkReply *  reply )

privateslot

Definition at line 1435 of file xtrxoutput.cpp.

Referenced by ~XTRXOutput().

{
    QNetworkReply::NetworkError replyError = reply->error();

    if (replyError)
    {
        qWarning() << "XTRXOutput::networkManagerFinished:"
                << " error(" << (int) replyError
                << "): " << replyError
                << ": " << reply->errorString();
        return;
    }

    QString answer = reply->readAll();
    answer.chop(1); // remove last \n
    qDebug("XTRXOutput::networkManagerFinished: reply:\n%s", answer.toStdString().c_str());
}

Here is the caller graph for this function:

openDevice()

bool XTRXOutput::openDevice ( )

private

Definition at line 78 of file xtrxoutput.cpp.

References DeviceAPI::getBuddySharedPtr(), DeviceAPI::getDeviceItemIndex(), DeviceAPI::getSamplingDeviceSerial(), DeviceAPI::getSinkBuddies(), DeviceAPI::getSourceBuddies(), DeviceXTRXShared::m_channel, DeviceXTRXShared::m_dev, m_deviceAPI, m_deviceShared, XTRXOutputSettings::m_devSampleRate, XTRXOutputSettings::m_log2SoftInterp, DeviceSampleSink::m_sampleSourceFifo, m_settings, DeviceXTRXShared::m_sink, DeviceXTRX::open(), SampleSourceFifo::resize(), and DeviceAPI::setBuddySharedPtr().

{
    m_sampleSourceFifo.resize(m_settings.m_devSampleRate/(1<<(m_settings.m_log2SoftInterp <= 4 ? m_settings.m_log2SoftInterp : 4)));

    // look for Tx buddies and get reference to the device object
    if (m_deviceAPI->getSinkBuddies().size() > 0) // then sink
    {
        qDebug("XTRXOutput::openDevice: look in Tx buddies");

        DeviceAPI *sinkBuddy = m_deviceAPI->getSinkBuddies()[0];
        DeviceXTRXShared *deviceXTRXShared = (DeviceXTRXShared*) sinkBuddy->getBuddySharedPtr();

        if (deviceXTRXShared == 0)
        {
            qCritical("XTRXOutput::openDevice: the sink buddy shared pointer is null");
            return false;
        }

        DeviceXTRX *device = deviceXTRXShared->m_dev;

        if (device == 0)
        {
            qCritical("XTRXOutput::openDevice: cannot get device pointer from Tx buddy");
            return false;
        }

        m_deviceShared.m_dev = device;
    }
    // look for Rx buddies and get reference to the device object
    else if (m_deviceAPI->getSourceBuddies().size() > 0) // look source sibling first
    {
        qDebug("XTRXOutput::openDevice: look in Rx buddies");

        DeviceAPI *sourceBuddy = m_deviceAPI->getSourceBuddies()[0];
        DeviceXTRXShared *deviceXTRXShared = (DeviceXTRXShared*) sourceBuddy->getBuddySharedPtr();

        if (deviceXTRXShared == 0)
        {
            qCritical("XTRXOutput::openDevice: the source buddy shared pointer is null");
            return false;
        }

        DeviceXTRX *device = deviceXTRXShared->m_dev;

        if (device == 0)
        {
            qCritical("XTRXOutput::openDevice: cannot get device pointer from Rx buddy");
            return false;
        }

        m_deviceShared.m_dev = device;
    }
    // There are no buddies then create the first BladeRF2 device
    else
    {
        qDebug("XTRXOutput::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("XTRXOutput::openDevice: cannot open BladeRF2 device");
            return false;
        }
    }

    m_deviceShared.m_channel = m_deviceAPI->getDeviceItemIndex(); // publicly allocate channel
    m_deviceShared.m_sink = this;
    m_deviceAPI->setBuddySharedPtr(&m_deviceShared); // propagate common parameters to API
    return true;
}

Here is the call graph for this function:

resumeRxThread()

void XTRXOutput::resumeRxThread ( )

private

Definition at line 444 of file xtrxoutput.cpp.

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

Referenced by applySettings().

{
    const std::vector<DeviceAPI*>& sourceBuddies = m_deviceAPI->getSourceBuddies();
    std::vector<DeviceAPI*>::const_iterator itSource = sourceBuddies.begin();

    qDebug("XTRXOutput::resumeRxThread (%lu)", sourceBuddies.size());

    for (; itSource != sourceBuddies.end(); ++itSource)
    {
        DeviceXTRXShared *buddySharedPtr = (DeviceXTRXShared *) (*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:

serialize()

QByteArray XTRXOutput::serialize ( ) const

virtual

Implements DeviceSampleSink.

Definition at line 461 of file xtrxoutput.cpp.

References m_settings, and XTRXOutputSettings::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 XTRXOutput::setCenterFrequency ( qint64  centerFrequency )

virtual

Implements DeviceSampleSink.

Definition at line 540 of file xtrxoutput.cpp.

References XTRXOutput::MsgConfigureXTRX::create(), XTRXOutputSettings::m_centerFrequency, DeviceSampleSink::m_guiMessageQueue, DeviceSampleSink::m_inputMessageQueue, XTRXOutputSettings::m_ncoEnable, XTRXOutputSettings::m_ncoFrequency, m_settings, and MessageQueue::push().

Referenced by setSampleRate().

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

inlinevirtual

Implements DeviceSampleSink.

Definition at line 186 of file xtrxoutput.h.

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

{ m_guiMessageQueue = queue; }

Here is the call graph for this function:

setSampleRate()

virtual void XTRXOutput::setSampleRate ( int  sampleRate )

inlinevirtual

For when the sink sample rate is set externally.

Implements DeviceSampleSink.

Definition at line 189 of file xtrxoutput.h.

References getCenterFrequency(), getChannelIndex(), getClockGen(), getDevSampleRate(), getLog2HardInterp(), getLORange(), getLPRange(), getSRRange(), handleMessage(), setCenterFrequency(), webapiReportGet(), webapiRun(), webapiRunGet(), webapiSettingsGet(), and webapiSettingsPutPatch().

{ (void) sampleRate; }

Here is the call graph for this function:

setThread()

void XTRXOutput::setThread ( XTRXOutputThread *  thread )

inline

Definition at line 181 of file xtrxoutput.h.

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

Referenced by moveThreadToBuddy().

{ m_XTRXOutputThread = thread; }

Here is the call graph for this function:

Here is the caller graph for this function:

start()

bool XTRXOutput::start ( )

virtual

Implements DeviceSampleSink.

Definition at line 233 of file xtrxoutput.cpp.

References applySettings(), findThread(), DeviceXTRX::getDevice(), DeviceAPI::getDeviceItemIndex(), XTRXOutputThread::getFifo(), XTRXOutputThread::getLog2Interpolation(), XTRXOutputThread::getNbChannels(), DeviceAPI::getSinkBuddies(), i, DeviceXTRXShared::m_dev, m_deviceAPI, m_deviceShared, XTRXOutputSettings::m_log2SoftInterp, m_running, DeviceSampleSink::m_sampleSourceFifo, m_settings, DeviceXTRXShared::m_thread, m_XTRXOutputThread, XTRXOutputThread::setFifo(), XTRXOutputThread::setLog2Interpolation(), XTRXOutputThread::startWork(), and XTRXOutputThread::stopWork().

Referenced by XTRXOutput::MsgStartStop::MsgStartStop().

{
    // There is a single thread per physical device (Tx side). This thread is unique and referenced by a unique
    // buddy in the group of sink buddies associated with this physical device.
    //
    // This start method is responsible for managing the thread when the streaming of a Tx channel is started
    //
    // It checks the following conditions
    //   - the thread is allocated or not (by itself or one of its buddies). If it is it grabs the thread pointer.
    //   - the requested channel is another channel (one is already streaming).
    //
    // The XTRX support library lets you work in two possible modes:
    //   - Single Output (SO) with only one channel streaming. This can be channel 0 or 1 (channels can be swapped - unlike with BladeRF2).
    //   - Multiple Output (MO) with two channels streaming using interleaved samples. It MUST be in this configuration if both channels are
    //     streaming.
    //
    // It manages the transition form SO where only one channel is running to the  Multiple Input (MO) 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 SO 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("XTRXOutput::start: no device object");
        return false;
    }

    int requestedChannel = m_deviceAPI->getDeviceItemIndex();
    XTRXOutputThread *xtrxOutputThread = findThread();
    bool needsStart = false;

    if (xtrxOutputThread) // if thread is already allocated
    {
        qDebug("XTRXOutput::start: thread is already allocated");

        unsigned int nbOriginalChannels = xtrxOutputThread->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("XTRXOutput::start: expand channels. Re-allocate thread and take ownership");

            SampleSourceFifo **fifos = new SampleSourceFifo*[2];
            unsigned int *log2Interps = new unsigned int[2];

            for (int i = 0; i < 2; i++) // save original FIFO references and data
            {
                fifos[i] = xtrxOutputThread->getFifo(i);
                log2Interps[i] = xtrxOutputThread->getLog2Interpolation(i);
            }

            xtrxOutputThread->stopWork();
            delete xtrxOutputThread;
            xtrxOutputThread = new XTRXOutputThread(m_deviceShared.m_dev->getDevice(), 2); // MO mode (2 channels)
            m_XTRXOutputThread = xtrxOutputThread; // take ownership
            m_deviceShared.m_thread = xtrxOutputThread;

            for (int i = 0; i < 2; i++) // restore original FIFO references
            {
                xtrxOutputThread->setFifo(i, fifos[i]);
                xtrxOutputThread->setLog2Interpolation(i, log2Interps[i]);
            }

            // remove old thread address from buddies (reset in all buddies). The address being held only in the owning source.
            const std::vector<DeviceAPI*>& sinkBuddies = m_deviceAPI->getSinkBuddies();
            std::vector<DeviceAPI*>::const_iterator it = sinkBuddies.begin();

            for (; it != sinkBuddies.end(); ++it)
            {
                ((DeviceXTRXShared*) (*it)->getBuddySharedPtr())->m_sink->setThread(0);
                ((DeviceXTRXShared*) (*it)->getBuddySharedPtr())->m_thread = 0;
            }

            // was used as temporary storage:
            delete[] fifos;
            delete[] log2Interps;

            needsStart = true;
        }
        else
        {
            qDebug("XTRXOutput::start: keep buddy thread");
        }
    }
    else // first allocation
    {
        qDebug("XTRXOutput::start: allocate thread and take ownership");
        xtrxOutputThread = new XTRXOutputThread(m_deviceShared.m_dev->getDevice(), 1, requestedChannel);
        m_XTRXOutputThread = xtrxOutputThread; // take ownership
        m_deviceShared.m_thread = xtrxOutputThread;
        needsStart = true;
    }

    xtrxOutputThread->setFifo(requestedChannel, &m_sampleSourceFifo);
    xtrxOutputThread->setLog2Interpolation(requestedChannel, m_settings.m_log2SoftInterp);

    applySettings(m_settings, true);

    if (needsStart)
    {
        qDebug("XTRXOutput::start: (re)start thread");
        xtrxOutputThread->startWork();
    }

    qDebug("XTRXOutput::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 XTRXOutput::stop ( )

virtual

Implements DeviceSampleSink.

Definition at line 349 of file xtrxoutput.cpp.

References applySettings(), findThread(), DeviceXTRX::getDevice(), DeviceAPI::getDeviceItemIndex(), XTRXOutputThread::getNbChannels(), DeviceAPI::getSinkBuddies(), DeviceXTRXShared::m_dev, m_deviceAPI, m_deviceShared, XTRXOutputSettings::m_log2SoftInterp, m_running, DeviceSampleSink::m_sampleSourceFifo, m_settings, DeviceXTRXShared::m_thread, m_XTRXOutputThread, XTRXOutputThread::setFifo(), XTRXOutputThread::setLog2Interpolation(), XTRXOutputThread::startWork(), and XTRXOutputThread::stopWork().

Referenced by closeDevice(), XTRXOutput::MsgStartStop::MsgStartStop(), and ~XTRXOutput().

{
    // 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 (SO mode). The thread can be just stopped and deleted.
    // Then the channel is closed.
    //
    // If the thread is currently managing both channels (MO mode) then we are removing one channel. Thus we must
    // transition from MO to SO. 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)
    XTRXOutputThread *xtrxOutputThread = findThread();

    if (xtrxOutputThread == 0) { // no thread allocated
        return;
    }

    int nbOriginalChannels = xtrxOutputThread->getNbChannels();

    if (nbOriginalChannels == 1) // SO mode => just stop and delete the thread
    {
        qDebug("XTRXOutput::stop: SO mode. Just stop and delete the thread");
        xtrxOutputThread->stopWork();
        delete xtrxOutputThread;
        m_XTRXOutputThread = 0;
        m_deviceShared.m_thread = 0;

        // remove old thread address from buddies (reset in all buddies)
        const std::vector<DeviceAPI*>& sinkBuddies = m_deviceAPI->getSinkBuddies();
        std::vector<DeviceAPI*>::const_iterator it = sinkBuddies.begin();

        for (; it != sinkBuddies.end(); ++it)
        {
            ((DeviceXTRXShared*) (*it)->getBuddySharedPtr())->m_sink->setThread(0);
            ((DeviceXTRXShared*) (*it)->getBuddySharedPtr())->m_thread = 0;
        }
    }
    else if (nbOriginalChannels == 2) // Reduce from MO to SO by deleting and re-creating the thread
    {
        qDebug("XTRXOutput::stop: MO mode. Reduce by deleting and re-creating the thread");
        xtrxOutputThread->stopWork();
        delete xtrxOutputThread;
        xtrxOutputThread = new XTRXOutputThread(m_deviceShared.m_dev->getDevice(), 1, requestedChannel);
        m_XTRXOutputThread = xtrxOutputThread; // take ownership
        m_deviceShared.m_thread = xtrxOutputThread;

        xtrxOutputThread->setFifo(requestedChannel, &m_sampleSourceFifo);
        xtrxOutputThread->setLog2Interpolation(requestedChannel, m_settings.m_log2SoftInterp);

        // remove old thread address from buddies (reset in all buddies). The address being held only in the owning source.
        const std::vector<DeviceAPI*>& sinkBuddies = m_deviceAPI->getSinkBuddies();
        std::vector<DeviceAPI*>::const_iterator it = sinkBuddies.begin();

        for (; it != sinkBuddies.end(); ++it)
        {
            ((DeviceXTRXShared*) (*it)->getBuddySharedPtr())->m_sink->setThread(0);
            ((DeviceXTRXShared*) (*it)->getBuddySharedPtr())->m_thread = 0;
        }

        applySettings(m_settings, true);
        xtrxOutputThread->startWork();
    }

    m_running = false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

suspendRxThread()

void XTRXOutput::suspendRxThread ( )

private

Definition at line 421 of file xtrxoutput.cpp.

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

Referenced by applySettings().

{
    const std::vector<DeviceAPI*>& sourceBuddies = m_deviceAPI->getSourceBuddies();
    std::vector<DeviceAPI*>::const_iterator itSource = sourceBuddies.begin();

    qDebug("XTRXOutput::suspendRxThread (%lu)", sourceBuddies.size());

    for (; itSource != sourceBuddies.end(); ++itSource)
    {
        DeviceXTRXShared *buddySharedPtr = (DeviceXTRXShared *) (*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:

webapiFormatDeviceReport()

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

private

Definition at line 1316 of file xtrxoutput.cpp.

References DeviceXTRXShared::get_board_temperature(), DeviceXTRXShared::get_gps_status(), DeviceXTRX::getDevice(), SWGSDRangel::SWGDeviceReport::getXtrxOutputReport(), DeviceXTRXShared::m_dev, m_deviceShared, SWGSDRangel::SWGXtrxOutputReport::setFifoFill(), SWGSDRangel::SWGXtrxOutputReport::setFifoSize(), SWGSDRangel::SWGXtrxOutputReport::setGpsLock(), SWGSDRangel::SWGXtrxOutputReport::setSuccess(), and SWGSDRangel::SWGXtrxOutputReport::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_TX, 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.getXtrxOutputReport()->setSuccess(success ? 1 : 0);
    response.getXtrxOutputReport()->setFifoSize(fifosize);
    response.getXtrxOutputReport()->setFifoFill(fifolevel);
    response.getXtrxOutputReport()->setTemperature(temp);
    response.getXtrxOutputReport()->setGpsLock(gpsStatus ? 1 : 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

webapiFormatDeviceSettings()

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

private

Definition at line 1251 of file xtrxoutput.cpp.

References SWGSDRangel::SWGXtrxOutputSettings::getReverseApiAddress(), SWGSDRangel::SWGDeviceSettings::getXtrxOutputSettings(), XTRXOutputSettings::m_antennaPath, XTRXOutputSettings::m_centerFrequency, XTRXOutputSettings::m_devSampleRate, XTRXOutputSettings::m_extClock, XTRXOutputSettings::m_extClockFreq, XTRXOutputSettings::m_gain, XTRXOutputSettings::m_log2HardInterp, XTRXOutputSettings::m_log2SoftInterp, XTRXOutputSettings::m_lpfBW, XTRXOutputSettings::m_ncoEnable, XTRXOutputSettings::m_ncoFrequency, XTRXOutputSettings::m_pwrmode, XTRXOutputSettings::m_reverseAPIAddress, XTRXOutputSettings::m_reverseAPIDeviceIndex, XTRXOutputSettings::m_reverseAPIPort, XTRXOutputSettings::m_useReverseAPI, SWGSDRangel::SWGXtrxOutputSettings::setAntennaPath(), SWGSDRangel::SWGXtrxOutputSettings::setCenterFrequency(), SWGSDRangel::SWGXtrxOutputSettings::setDevSampleRate(), SWGSDRangel::SWGXtrxOutputSettings::setExtClock(), SWGSDRangel::SWGXtrxOutputSettings::setExtClockFreq(), SWGSDRangel::SWGXtrxOutputSettings::setGain(), SWGSDRangel::SWGXtrxOutputSettings::setLog2HardInterp(), SWGSDRangel::SWGXtrxOutputSettings::setLog2SoftInterp(), SWGSDRangel::SWGXtrxOutputSettings::setLpfBw(), SWGSDRangel::SWGXtrxOutputSettings::setNcoEnable(), SWGSDRangel::SWGXtrxOutputSettings::setNcoFrequency(), SWGSDRangel::SWGXtrxOutputSettings::setPwrmode(), SWGSDRangel::SWGXtrxOutputSettings::setReverseApiAddress(), SWGSDRangel::SWGXtrxOutputSettings::setReverseApiDeviceIndex(), SWGSDRangel::SWGXtrxOutputSettings::setReverseApiPort(), and SWGSDRangel::SWGXtrxOutputSettings::setUseReverseApi().

Referenced by webapiSettingsGet(), and webapiSettingsPutPatch().

{
    response.getXtrxOutputSettings()->setCenterFrequency(settings.m_centerFrequency);
    response.getXtrxOutputSettings()->setDevSampleRate(settings.m_devSampleRate);
    response.getXtrxOutputSettings()->setLog2HardInterp(settings.m_log2HardInterp);
    response.getXtrxOutputSettings()->setLog2SoftInterp(settings.m_log2SoftInterp);
    response.getXtrxOutputSettings()->setLpfBw(settings.m_lpfBW);
    response.getXtrxOutputSettings()->setGain(settings.m_gain);
    response.getXtrxOutputSettings()->setNcoEnable(settings.m_ncoEnable ? 1 : 0);
    response.getXtrxOutputSettings()->setNcoFrequency(settings.m_ncoFrequency);
    response.getXtrxOutputSettings()->setAntennaPath((int) settings.m_antennaPath);
    response.getXtrxOutputSettings()->setExtClock(settings.m_extClock ? 1 : 0);
    response.getXtrxOutputSettings()->setExtClockFreq(settings.m_extClockFreq);
    response.getXtrxOutputSettings()->setPwrmode(settings.m_pwrmode);
    response.getXtrxOutputSettings()->setUseReverseApi(settings.m_useReverseAPI ? 1 : 0);

    if (response.getXtrxOutputSettings()->getReverseApiAddress()) {
        *response.getXtrxOutputSettings()->getReverseApiAddress() = settings.m_reverseAPIAddress;
    } else {
        response.getXtrxOutputSettings()->setReverseApiAddress(new QString(settings.m_reverseAPIAddress));
    }

    response.getXtrxOutputSettings()->setReverseApiPort(settings.m_reverseAPIPort);
    response.getXtrxOutputSettings()->setReverseApiDeviceIndex(settings.m_reverseAPIDeviceIndex);
}

Here is the call graph for this function:

Here is the caller graph for this function:

webapiReportGet()

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

virtual

Reimplemented from DeviceSampleSink.

Definition at line 1277 of file xtrxoutput.cpp.

References SWGSDRangel::SWGDeviceReport::getXtrxOutputReport(), SWGSDRangel::SWGXtrxOutputReport::init(), SWGSDRangel::SWGDeviceReport::setXtrxOutputReport(), and webapiFormatDeviceReport().

Referenced by setSampleRate().

{
    (void) errorMessage;
    response.setXtrxOutputReport(new SWGSDRangel::SWGXtrxOutputReport());
    response.getXtrxOutputReport()->init();
    webapiFormatDeviceReport(response);
    return 200;
}

Here is the call graph for this function:

Here is the caller graph for this function:

webapiReverseSendSettings()

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

private

Definition at line 1341 of file xtrxoutput.cpp.

References SWGSDRangel::SWGDeviceSettings::asJson(), DeviceAPI::getDeviceSetIndex(), SWGSDRangel::SWGDeviceSettings::getXtrxOutputSettings(), XTRXOutputSettings::m_antennaPath, XTRXOutputSettings::m_centerFrequency, m_deviceAPI, XTRXOutputSettings::m_devSampleRate, XTRXOutputSettings::m_extClock, XTRXOutputSettings::m_extClockFreq, XTRXOutputSettings::m_gain, XTRXOutputSettings::m_log2HardInterp, XTRXOutputSettings::m_log2SoftInterp, XTRXOutputSettings::m_lpfBW, XTRXOutputSettings::m_ncoEnable, XTRXOutputSettings::m_ncoFrequency, m_networkManager, m_networkRequest, XTRXOutputSettings::m_pwrmode, XTRXOutputSettings::m_reverseAPIAddress, XTRXOutputSettings::m_reverseAPIDeviceIndex, XTRXOutputSettings::m_reverseAPIPort, SWGSDRangel::SWGXtrxOutputSettings::setAntennaPath(), SWGSDRangel::SWGXtrxOutputSettings::setCenterFrequency(), SWGSDRangel::SWGDeviceSettings::setDeviceHwType(), SWGSDRangel::SWGXtrxOutputSettings::setDevSampleRate(), SWGSDRangel::SWGDeviceSettings::setDirection(), SWGSDRangel::SWGXtrxOutputSettings::setExtClock(), SWGSDRangel::SWGXtrxOutputSettings::setExtClockFreq(), SWGSDRangel::SWGXtrxOutputSettings::setGain(), SWGSDRangel::SWGXtrxOutputSettings::setLog2HardInterp(), SWGSDRangel::SWGXtrxOutputSettings::setLog2SoftInterp(), SWGSDRangel::SWGXtrxOutputSettings::setLpfBw(), SWGSDRangel::SWGXtrxOutputSettings::setNcoEnable(), SWGSDRangel::SWGXtrxOutputSettings::setNcoFrequency(), SWGSDRangel::SWGDeviceSettings::setOriginatorIndex(), SWGSDRangel::SWGXtrxOutputSettings::setPwrmode(), and SWGSDRangel::SWGDeviceSettings::setXtrxOutputSettings().

Referenced by applySettings().

{
    SWGSDRangel::SWGDeviceSettings *swgDeviceSettings = new SWGSDRangel::SWGDeviceSettings();
    swgDeviceSettings->setDirection(1); // Single Tx
    swgDeviceSettings->setOriginatorIndex(m_deviceAPI->getDeviceSetIndex());
    swgDeviceSettings->setDeviceHwType(new QString("XTRX"));
    swgDeviceSettings->setXtrxOutputSettings(new SWGSDRangel::SWGXtrxOutputSettings());
    SWGSDRangel::SWGXtrxOutputSettings *swgXtrxOutputSettings = swgDeviceSettings->getXtrxOutputSettings();

    // transfer data that has been modified. When force is on transfer all data except reverse API data

    if (deviceSettingsKeys.contains("centerFrequency") || force) {
        swgXtrxOutputSettings->setCenterFrequency(settings.m_centerFrequency);
    }
    if (deviceSettingsKeys.contains("devSampleRate") || force) {
        swgXtrxOutputSettings->setDevSampleRate(settings.m_devSampleRate);
    }
    if (deviceSettingsKeys.contains("log2HardInterp") || force) {
        swgXtrxOutputSettings->setLog2HardInterp(settings.m_log2HardInterp);
    }
    if (deviceSettingsKeys.contains("log2SoftInterp") || force) {
        swgXtrxOutputSettings->setLog2SoftInterp(settings.m_log2SoftInterp);
    }
    if (deviceSettingsKeys.contains("ncoEnable") || force) {
        swgXtrxOutputSettings->setNcoEnable(settings.m_ncoEnable ? 1 : 0);
    }
    if (deviceSettingsKeys.contains("ncoFrequency") || force) {
        swgXtrxOutputSettings->setNcoFrequency(settings.m_ncoFrequency);
    }
    if (deviceSettingsKeys.contains("lpfBW") || force) {
        swgXtrxOutputSettings->setLpfBw(settings.m_lpfBW);
    }
    if (deviceSettingsKeys.contains("antennaPath") || force) {
        swgXtrxOutputSettings->setAntennaPath((int) settings.m_antennaPath);
    }
    if (deviceSettingsKeys.contains("gain") || force) {
        swgXtrxOutputSettings->setGain(settings.m_gain);
    }
    if (deviceSettingsKeys.contains("extClock") || force) {
        swgXtrxOutputSettings->setExtClock(settings.m_extClock ? 1 : 0);
    }
    if (deviceSettingsKeys.contains("extClockFreq") || force) {
        swgXtrxOutputSettings->setExtClockFreq(settings.m_extClockFreq);
    }
    if (deviceSettingsKeys.contains("pwrmode") || force) {
        swgXtrxOutputSettings->setPwrmode(settings.m_pwrmode);
    }

    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 XTRXOutput::webapiReverseSendStartStop ( bool  start )

private

Definition at line 1407 of file xtrxoutput.cpp.

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

{
    SWGSDRangel::SWGDeviceSettings *swgDeviceSettings = new SWGSDRangel::SWGDeviceSettings();
    swgDeviceSettings->setDirection(1); // Single Tx
    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 XTRXOutput::webapiRun ( bool  run, SWGSDRangel::SWGDeviceState &  response, QString &  errorMessage  )

virtual

Reimplemented from DeviceSampleSink.

Definition at line 1297 of file xtrxoutput.cpp.

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

Referenced by setSampleRate().

{
    (void) errorMessage;
    m_deviceAPI->getDeviceEngineStateStr(*response.getState());
    MsgStartStop *message = MsgStartStop::create(run);
    m_inputMessageQueue.push(message);

    if (m_guiMessageQueue) // 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 XTRXOutput::webapiRunGet ( SWGSDRangel::SWGDeviceState &  response, QString &  errorMessage  )

virtual

Reimplemented from DeviceSampleSink.

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

virtual

Reimplemented from DeviceSampleSink.

Definition at line 1169 of file xtrxoutput.cpp.

References SWGSDRangel::SWGDeviceSettings::getXtrxOutputSettings(), SWGSDRangel::SWGXtrxOutputSettings::init(), m_settings, SWGSDRangel::SWGDeviceSettings::setXtrxOutputSettings(), and webapiFormatDeviceSettings().

Referenced by setSampleRate().

{
    (void) errorMessage;
    response.setXtrxOutputSettings(new SWGSDRangel::SWGXtrxOutputSettings());
    response.getXtrxOutputSettings()->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 XTRXOutput::webapiSettingsPutPatch ( bool  force, const QStringList &  deviceSettingsKeys, SWGSDRangel::SWGDeviceSettings &  response, QString &  errorMessage  )

virtual

Reimplemented from DeviceSampleSink.

Definition at line 1180 of file xtrxoutput.cpp.

References XTRXOutput::MsgConfigureXTRX::create(), SWGSDRangel::SWGXtrxOutputSettings::getAntennaPath(), SWGSDRangel::SWGXtrxOutputSettings::getCenterFrequency(), SWGSDRangel::SWGXtrxOutputSettings::getDevSampleRate(), SWGSDRangel::SWGXtrxOutputSettings::getExtClock(), SWGSDRangel::SWGXtrxOutputSettings::getExtClockFreq(), SWGSDRangel::SWGXtrxOutputSettings::getGain(), SWGSDRangel::SWGXtrxOutputSettings::getLog2HardInterp(), SWGSDRangel::SWGXtrxOutputSettings::getLog2SoftInterp(), SWGSDRangel::SWGXtrxOutputSettings::getLpfBw(), SWGSDRangel::SWGXtrxOutputSettings::getNcoEnable(), SWGSDRangel::SWGXtrxOutputSettings::getNcoFrequency(), SWGSDRangel::SWGXtrxOutputSettings::getPwrmode(), SWGSDRangel::SWGXtrxOutputSettings::getReverseApiAddress(), SWGSDRangel::SWGXtrxOutputSettings::getReverseApiDeviceIndex(), SWGSDRangel::SWGXtrxOutputSettings::getReverseApiPort(), SWGSDRangel::SWGXtrxOutputSettings::getUseReverseApi(), SWGSDRangel::SWGDeviceSettings::getXtrxOutputSettings(), XTRXOutputSettings::m_antennaPath, XTRXOutputSettings::m_centerFrequency, XTRXOutputSettings::m_devSampleRate, XTRXOutputSettings::m_extClock, XTRXOutputSettings::m_extClockFreq, XTRXOutputSettings::m_gain, DeviceSampleSink::m_guiMessageQueue, DeviceSampleSink::m_inputMessageQueue, XTRXOutputSettings::m_log2HardInterp, XTRXOutputSettings::m_log2SoftInterp, XTRXOutputSettings::m_lpfBW, XTRXOutputSettings::m_ncoEnable, XTRXOutputSettings::m_ncoFrequency, XTRXOutputSettings::m_pwrmode, XTRXOutputSettings::m_reverseAPIAddress, XTRXOutputSettings::m_reverseAPIDeviceIndex, XTRXOutputSettings::m_reverseAPIPort, m_settings, XTRXOutputSettings::m_useReverseAPI, MessageQueue::push(), and webapiFormatDeviceSettings().

Referenced by setSampleRate().

{
    (void) errorMessage;
    XTRXOutputSettings settings = m_settings;

    if (deviceSettingsKeys.contains("centerFrequency")) {
        settings.m_centerFrequency = response.getXtrxOutputSettings()->getCenterFrequency();
    }
    if (deviceSettingsKeys.contains("devSampleRate")) {
        settings.m_devSampleRate = response.getXtrxOutputSettings()->getDevSampleRate();
    }
    if (deviceSettingsKeys.contains("log2HardInterp")) {
        settings.m_log2HardInterp = response.getXtrxOutputSettings()->getLog2HardInterp();
    }
    if (deviceSettingsKeys.contains("log2SoftInterp")) {
        settings.m_log2SoftInterp = response.getXtrxOutputSettings()->getLog2SoftInterp();
    }
    if (deviceSettingsKeys.contains("lpfBW")) {
        settings.m_lpfBW = response.getXtrxOutputSettings()->getLpfBw();
    }
    if (deviceSettingsKeys.contains("gain")) {
        settings.m_gain = response.getXtrxOutputSettings()->getGain();
    }
    if (deviceSettingsKeys.contains("ncoEnable")) {
        settings.m_ncoEnable = response.getXtrxOutputSettings()->getNcoEnable() != 0;
    }
    if (deviceSettingsKeys.contains("ncoFrequency")) {
        settings.m_ncoFrequency = response.getXtrxOutputSettings()->getNcoFrequency();
    }
    if (deviceSettingsKeys.contains("antennaPath")) {
        settings.m_antennaPath = (xtrx_antenna_t) response.getXtrxOutputSettings()->getAntennaPath();
    }
    if (deviceSettingsKeys.contains("extClock")) {
        settings.m_extClock = response.getXtrxOutputSettings()->getExtClock() != 0;
    }
    if (deviceSettingsKeys.contains("extClockFreq")) {
        settings.m_extClockFreq = response.getXtrxOutputSettings()->getExtClockFreq();
    }
    if (deviceSettingsKeys.contains("pwrmode")) {
        settings.m_pwrmode = response.getXtrxOutputSettings()->getPwrmode();
    }
    if (deviceSettingsKeys.contains("useReverseAPI")) {
        settings.m_useReverseAPI = response.getXtrxOutputSettings()->getUseReverseApi() != 0;
    }
    if (deviceSettingsKeys.contains("reverseAPIAddress")) {
        settings.m_reverseAPIAddress = *response.getXtrxOutputSettings()->getReverseApiAddress();
    }
    if (deviceSettingsKeys.contains("reverseAPIPort")) {
        settings.m_reverseAPIPort = response.getXtrxOutputSettings()->getReverseApiPort();
    }
    if (deviceSettingsKeys.contains("reverseAPIDeviceIndex")) {
        settings.m_reverseAPIDeviceIndex = response.getXtrxOutputSettings()->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* XTRXOutput::m_deviceAPI

private

Definition at line 227 of file xtrxoutput.h.

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

m_deviceDescription

QString XTRXOutput::m_deviceDescription

private

Definition at line 231 of file xtrxoutput.h.

Referenced by getDeviceDescription().

m_deviceShared

DeviceXTRXShared XTRXOutput::m_deviceShared

private

Definition at line 233 of file xtrxoutput.h.

Referenced by applySettings(), closeDevice(), getChannelIndex(), getClockGen(), getDevSampleRate(), getLog2HardInterp(), getSampleRate(), handleMessage(), openDevice(), start(), stop(), and webapiFormatDeviceReport().

m_mutex

QMutex XTRXOutput::m_mutex

private

Definition at line 228 of file xtrxoutput.h.

m_networkManager

QNetworkAccessManager* XTRXOutput::m_networkManager

private

Definition at line 234 of file xtrxoutput.h.

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

m_networkRequest

QNetworkRequest XTRXOutput::m_networkRequest

private

Definition at line 235 of file xtrxoutput.h.

Referenced by webapiReverseSendSettings(), and webapiReverseSendStartStop().

m_running

bool XTRXOutput::m_running

private

Definition at line 232 of file xtrxoutput.h.

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

m_settings

XTRXOutputSettings XTRXOutput::m_settings

private

Definition at line 229 of file xtrxoutput.h.

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

m_XTRXOutputThread

XTRXOutputThread* XTRXOutput::m_XTRXOutputThread

private

Definition at line 230 of file xtrxoutput.h.

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

---

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

• plugins/samplesink/xtrxoutput/xtrxoutput.h
• plugins/samplesink/xtrxoutput/xtrxoutput.cpp