VE7UWU/sdrangel
1
0
Fork 0
mirror of https://github.com/f4exb/sdrangel.git synced 2024-11-22 16:08:39 -05:00
Code Issues Projects Releases Wiki Activity

BladeRF2 MIMO: Make settings assignments atomic. Part of #1329

Browse Source
This commit is contained in:
f4exb 2022-10-31 16:56:52 +01:00
parent 795753738c
commit 89beb182a7
6 changed files with 345 additions and 177 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

213
plugins/samplemimo/bladerf2mimo/bladerf2mimo.cpp
View File

@ -140,7 +140,7 @@ void BladeRF2MIMO::closeDevice()
void BladeRF2MIMO::init()
{
applySettings(m_settings, true);
applySettings(m_settings, QList<QString>(), true);
}
bool BladeRF2MIMO::startRx()
@ -271,12 +271,12 @@ bool BladeRF2MIMO::deserialize(const QByteArray& data)
success = false;
}
MsgConfigureBladeRF2MIMO* message = MsgConfigureBladeRF2MIMO::create(m_settings, true);
MsgConfigureBladeRF2MIMO* message = MsgConfigureBladeRF2MIMO::create(m_settings, QList<QString>(), true);
m_inputMessageQueue.push(message);
if (m_guiMessageQueue)
{
MsgConfigureBladeRF2MIMO* messageToGUI = MsgConfigureBladeRF2MIMO::create(m_settings, true);
MsgConfigureBladeRF2MIMO* messageToGUI = MsgConfigureBladeRF2MIMO::create(m_settings, QList<QString>(), true);
m_guiMessageQueue->push(messageToGUI);
}
@ -314,12 +314,12 @@ void BladeRF2MIMO::setSourceCenterFrequency(qint64 centerFrequency, int index)
BladeRF2MIMOSettings settings = m_settings;
settings.m_rxCenterFrequency = centerFrequency;
MsgConfigureBladeRF2MIMO* message = MsgConfigureBladeRF2MIMO::create(settings, false);
MsgConfigureBladeRF2MIMO* message = MsgConfigureBladeRF2MIMO::create(settings, QList<QString>{"rxCenterFrequency"}, false);
m_inputMessageQueue.push(message);
if (m_guiMessageQueue)
{
MsgConfigureBladeRF2MIMO* messageToGUI = MsgConfigureBladeRF2MIMO::create(settings, false);
MsgConfigureBladeRF2MIMO* messageToGUI = MsgConfigureBladeRF2MIMO::create(settings, QList<QString>{"rxCenterFrequency"}, false);
m_guiMessageQueue->push(messageToGUI);
}
}
@ -336,12 +336,12 @@ void BladeRF2MIMO::setSinkCenterFrequency(qint64 centerFrequency, int index)
BladeRF2MIMOSettings settings = m_settings;
settings.m_txCenterFrequency = centerFrequency;
MsgConfigureBladeRF2MIMO* message = MsgConfigureBladeRF2MIMO::create(settings, false);
MsgConfigureBladeRF2MIMO* message = MsgConfigureBladeRF2MIMO::create(settings, QList<QString>{"txCenterFrequency"}, false);
m_inputMessageQueue.push(message);
if (m_guiMessageQueue)
{
MsgConfigureBladeRF2MIMO* messageToGUI = MsgConfigureBladeRF2MIMO::create(settings, false);
MsgConfigureBladeRF2MIMO* messageToGUI = MsgConfigureBladeRF2MIMO::create(settings, QList<QString>{"txCenterFrequency"}, false);
m_guiMessageQueue->push(messageToGUI);
}
}
@ -353,7 +353,7 @@ bool BladeRF2MIMO::handleMessage(const Message& message)
MsgConfigureBladeRF2MIMO& conf = (MsgConfigureBladeRF2MIMO&) message;
qDebug() << "BladeRF2MIMO::handleMessage: MsgConfigureBladeRF2MIMO";
bool success = applySettings(conf.getSettings(), conf.getForce());
bool success = applySettings(conf.getSettings(), conf.getSettingsKeys(), conf.getForce());
if (!success) {
qDebug("BladeRF2MIMO::handleMessage: config error");
@ -393,43 +393,12 @@ bool BladeRF2MIMO::handleMessage(const Message& message)
}
}
bool BladeRF2MIMO::applySettings(const BladeRF2MIMOSettings& settings, bool force)
bool BladeRF2MIMO::applySettings(const BladeRF2MIMOSettings& settings, const QList<QString>& settingsKeys, bool force)
{
QList<QString> reverseAPIKeys;
bool forwardChangeRxDSP = false;
bool forwardChangeTxDSP = false;
qDebug() << "BladeRF2MIMO::applySettings: common: "
<< " m_devSampleRate: " << settings.m_devSampleRate
<< " m_LOppmTenths: " << settings.m_LOppmTenths
<< " m_rxCenterFrequency: " << settings.m_rxCenterFrequency
<< " m_log2Decim: " << settings.m_log2Decim
<< " m_iqOrder: " << settings.m_iqOrder
<< " m_fcPosRx: " << settings.m_fcPosRx
<< " m_rxBandwidth: " << settings.m_rxBandwidth
<< " m_rx0GainMode: " << settings.m_rx0GainMode
<< " m_rx0GlobalGain: " << settings.m_rx0GlobalGain
<< " m_rx1GainMode: " << settings.m_rx1GainMode
<< " m_rx1GlobalGain: " << settings.m_rx1GlobalGain
<< " m_rxBiasTee: " << settings.m_rxBiasTee
<< " m_dcBlock: " << settings.m_dcBlock
<< " m_iqCorrection: " << settings.m_iqCorrection
<< " m_rxTransverterMode: " << settings.m_rxTransverterMode
<< " m_rxTransverterDeltaFrequency: " << settings.m_rxTransverterDeltaFrequency
<< " m_txCenterFrequency: " << settings.m_txCenterFrequency
<< " m_log2Interp: " << settings.m_log2Interp
<< " m_fcPosTx: " << settings.m_fcPosTx
<< " m_txBandwidth: " << settings.m_txBandwidth
<< " m_tx0GlobalGain: " << settings.m_tx0GlobalGain
<< " m_tx1GlobalGain: " << settings.m_tx1GlobalGain
<< " m_txBiasTee: " << settings.m_txBiasTee
<< " m_txTransverterMode: " << settings.m_txTransverterMode
<< " m_txTransverterDeltaFrequency: " << settings.m_txTransverterDeltaFrequency
<< " m_useReverseAPI: " << settings.m_useReverseAPI
<< " m_reverseAPIAddress: " << settings.m_reverseAPIAddress
<< " m_reverseAPIPort: " << settings.m_reverseAPIPort
<< " m_reverseAPIDeviceIndex: " << settings.m_reverseAPIDeviceIndex
<< " force: " << force;
qDebug() << "BladeRF2MIMO::applySettings: force:" << force << settings.getDebugString(settingsKeys, force);
struct bladerf *dev = m_dev ? m_dev->getDev() : nullptr;
@ -442,10 +411,8 @@ bool BladeRF2MIMO::applySettings(const BladeRF2MIMOSettings& settings, bool forc
txXlatedDeviceCenterFrequency -= settings.m_txTransverterMode ? settings.m_txTransverterDeltaFrequency : 0;
txXlatedDeviceCenterFrequency = txXlatedDeviceCenterFrequency < 0 ? 0 : txXlatedDeviceCenterFrequency;
if ((m_settings.m_devSampleRate != settings.m_devSampleRate) || force)
if (settingsKeys.contains("devSampleRate") || force)
{
reverseAPIKeys.append("devSampleRate");
if (dev)
{
unsigned int actualSamplerate;
@ -466,24 +433,15 @@ bool BladeRF2MIMO::applySettings(const BladeRF2MIMOSettings& settings, bool forc
// Rx settings
if ((m_settings.m_dcBlock != settings.m_dcBlock) || force) {
reverseAPIKeys.append("dcBlock");
}
if ((m_settings.m_iqCorrection != settings.m_iqCorrection) || force) {
reverseAPIKeys.append("iqCorrection");
}
if ((m_settings.m_dcBlock != settings.m_dcBlock) ||
(m_settings.m_iqCorrection != settings.m_iqCorrection) || force)
if (settingsKeys.contains("dcBlock") ||
settingsKeys.contains("iqCorrection") || force)
{
m_deviceAPI->configureCorrections(settings.m_dcBlock, settings.m_iqCorrection, 0);
m_deviceAPI->configureCorrections(settings.m_dcBlock, settings.m_iqCorrection, 1);
}
if ((m_settings.m_rxBandwidth != settings.m_rxBandwidth) || force)
if (settingsKeys.contains("rxBandwidth") || force)
{
reverseAPIKeys.append("rxBandwidth");
if (dev)
{
unsigned int actualBandwidth;
@ -505,10 +463,8 @@ bool BladeRF2MIMO::applySettings(const BladeRF2MIMOSettings& settings, bool forc
}
}
if ((m_settings.m_fcPosRx != settings.m_fcPosRx) || force)
if (settingsKeys.contains("fcPosRx") || force)
{
reverseAPIKeys.append("fcPosRx");
if (m_sourceThread)
{
m_sourceThread->setFcPos((int) settings.m_fcPosRx);
@ -516,10 +472,8 @@ bool BladeRF2MIMO::applySettings(const BladeRF2MIMOSettings& settings, bool forc
}
}
if ((m_settings.m_log2Decim != settings.m_log2Decim) || force)
if (settingsKeys.contains("log2Decim") || force)
{
reverseAPIKeys.append("log2Decim");
if (m_sourceThread)
{
m_sourceThread->setLog2Decimation(settings.m_log2Decim);
@ -527,10 +481,8 @@ bool BladeRF2MIMO::applySettings(const BladeRF2MIMOSettings& settings, bool forc
}
}
if ((m_settings.m_iqOrder != settings.m_iqOrder) || force)
if (settingsKeys.contains("iqOrder") || force)
{
reverseAPIKeys.append("iqOrder");
if (m_sourceThread)
{
m_sourceThread->setIQOrder(settings.m_iqOrder);
@ -538,10 +490,8 @@ bool BladeRF2MIMO::applySettings(const BladeRF2MIMOSettings& settings, bool forc
}
}
if ((m_settings.m_fcPosTx != settings.m_fcPosTx) || force)
if (settingsKeys.contains("fcPosTx") || force)
{
reverseAPIKeys.append("fcPosTx");
if (m_sourceThread)
{
m_sourceThread->setFcPos((int) settings.m_fcPosTx);
@ -549,10 +499,8 @@ bool BladeRF2MIMO::applySettings(const BladeRF2MIMOSettings& settings, bool forc
}
}
if ((m_settings.m_log2Interp != settings.m_log2Interp) || force)
if (settingsKeys.contains("log2Interp") || force)
{
reverseAPIKeys.append("log2Interp");
if (m_sinkThread)
{
m_sinkThread->setLog2Interpolation(settings.m_log2Interp);
@ -560,26 +508,20 @@ bool BladeRF2MIMO::applySettings(const BladeRF2MIMOSettings& settings, bool forc
}
}
if ((m_settings.m_rxCenterFrequency != settings.m_rxCenterFrequency) || force) {
reverseAPIKeys.append("rxCenterFrequency");
}
if ((m_settings.m_rxTransverterMode != settings.m_rxTransverterMode) || force) {
reverseAPIKeys.append("rxTransverterMode");
}
if ((m_settings.m_rxTransverterDeltaFrequency != settings.m_rxTransverterDeltaFrequency) || force) {
reverseAPIKeys.append("rxTransverterDeltaFrequency");
}
if ((m_settings.m_LOppmTenths != settings.m_LOppmTenths) || force) {
reverseAPIKeys.append("LOppmTenths");
}
if ((m_settings.m_rxCenterFrequency != settings.m_rxCenterFrequency)
|| (m_settings.m_rxTransverterMode != settings.m_rxTransverterMode)
|| (m_settings.m_rxTransverterDeltaFrequency != settings.m_rxTransverterDeltaFrequency)
|| (m_settings.m_LOppmTenths != settings.m_LOppmTenths)
|| (m_settings.m_devSampleRate != settings.m_devSampleRate)
|| (m_settings.m_fcPosRx != settings.m_fcPosRx)
|| (m_settings.m_log2Decim != settings.m_log2Decim) || force)
// if ((m_settings.m_rxCenterFrequency != settings.m_rxCenterFrequency)
// || (m_settings.m_rxTransverterMode != settings.m_rxTransverterMode)
// || (m_settings.m_rxTransverterDeltaFrequency != settings.m_rxTransverterDeltaFrequency)
// || (m_settings.m_LOppmTenths != settings.m_LOppmTenths)
// || (m_settings.m_devSampleRate != settings.m_devSampleRate)
// || (m_settings.m_fcPosRx != settings.m_fcPosRx)
// || (m_settings.m_log2Decim != settings.m_log2Decim) || force)
if (settingsKeys.contains("rxCenterFrequency")
|| settingsKeys.contains("rxTransverterMode")
|| settingsKeys.contains("rxTransverterDeltaFrequency")
|| settingsKeys.contains("LOppmTenths")
|| settingsKeys.contains("devSampleRate")
|| settingsKeys.contains("fcPosRx")
|| settingsKeys.contains("log2Decim") || force)
{
if (dev)
{
@ -597,19 +539,15 @@ bool BladeRF2MIMO::applySettings(const BladeRF2MIMOSettings& settings, bool forc
forwardChangeRxDSP = true;
}
if ((m_settings.m_rxBiasTee != settings.m_rxBiasTee) || force)
if (settingsKeys.contains("rxBiasTee") || force)
{
reverseAPIKeys.append("rxBiasTee");
if (m_dev) {
m_dev->setBiasTeeRx(settings.m_rxBiasTee);
}
}
if ((m_settings.m_rx0GainMode != settings.m_rx0GainMode) || force)
if (settingsKeys.contains("rx0GainMode") || force)
{
reverseAPIKeys.append("rx0GainMode");
if (dev)
{
int status = bladerf_set_gain_mode(dev, BLADERF_CHANNEL_RX(0), (bladerf_gain_mode) settings.m_rx0GainMode);
@ -623,10 +561,8 @@ bool BladeRF2MIMO::applySettings(const BladeRF2MIMOSettings& settings, bool forc
}
}
if ((m_settings.m_rx1GainMode != settings.m_rx1GainMode) || force)
if (settingsKeys.contains("rx1GainMode") || force)
{
reverseAPIKeys.append("rx1GainMode");
if (dev)
{
int status = bladerf_set_gain_mode(dev, BLADERF_CHANNEL_RX(1), (bladerf_gain_mode) settings.m_rx1GainMode);
@ -640,15 +576,8 @@ bool BladeRF2MIMO::applySettings(const BladeRF2MIMOSettings& settings, bool forc
}
}
if ((m_settings.m_rx0GlobalGain != settings.m_rx0GlobalGain) || force) {
reverseAPIKeys.append("rx0GlobalGain");
}
if ((m_settings.m_rx1GlobalGain != settings.m_rx1GlobalGain) || force) {
reverseAPIKeys.append("rx1GlobalGain");
}
if ((m_settings.m_rx0GlobalGain != settings.m_rx0GlobalGain)
|| ((m_settings.m_rx0GlobalGain != settings.m_rx0GlobalGain) && (settings.m_rx0GlobalGain == BLADERF_GAIN_MANUAL)) || force)
if (settingsKeys.contains("rx0GlobalGain")
|| (settingsKeys.contains("rx0GlobalGain") && (settings.m_rx0GlobalGain == BLADERF_GAIN_MANUAL)) || force)
{
if (dev)
{
@ -663,8 +592,8 @@ bool BladeRF2MIMO::applySettings(const BladeRF2MIMOSettings& settings, bool forc
}
}
if ((m_settings.m_rx1GlobalGain != settings.m_rx1GlobalGain)
|| ((m_settings.m_rx1GlobalGain != settings.m_rx1GlobalGain) && (settings.m_rx1GlobalGain == BLADERF_GAIN_MANUAL)) || force)
if (settingsKeys.contains("rx1GlobalGain")
|| (settingsKeys.contains("rx1GlobalGain") && (settings.m_rx1GlobalGain == BLADERF_GAIN_MANUAL)) || force)
{
if (dev)
{
@ -681,23 +610,13 @@ bool BladeRF2MIMO::applySettings(const BladeRF2MIMOSettings& settings, bool forc
// Tx settings
if ((m_settings.m_txCenterFrequency != settings.m_txCenterFrequency) || force) {
reverseAPIKeys.append("txCenterFrequency");
}
if ((m_settings.m_txTransverterMode != settings.m_txTransverterMode) || force) {
reverseAPIKeys.append("txTransverterMode");
}
if ((m_settings.m_txTransverterDeltaFrequency != settings.m_txTransverterDeltaFrequency) || force) {
reverseAPIKeys.append("txTransverterDeltaFrequency");
}
if ((m_settings.m_txCenterFrequency != settings.m_txCenterFrequency)
|| (m_settings.m_txTransverterMode != settings.m_txTransverterMode)
|| (m_settings.m_txTransverterDeltaFrequency != settings.m_txTransverterDeltaFrequency)
|| (m_settings.m_fcPosTx != settings.m_fcPosTx)
|| (m_settings.m_log2Interp != settings.m_log2Interp)
|| (m_settings.m_LOppmTenths != settings.m_LOppmTenths)
|| (m_settings.m_devSampleRate != settings.m_devSampleRate) || force)
if (settingsKeys.contains("txCenterFrequency")
|| settingsKeys.contains("txTransverterMode")
|| settingsKeys.contains("txTransverterDeltaFrequency")
|| settingsKeys.contains("fcPosTx")
|| settingsKeys.contains("log2Interp")
|| settingsKeys.contains("LOppmTenths")
|| settingsKeys.contains("devSampleRate") || force)
{
if (dev)
{
@ -714,10 +633,8 @@ bool BladeRF2MIMO::applySettings(const BladeRF2MIMOSettings& settings, bool forc
forwardChangeTxDSP = true;
}
if ((m_settings.m_txBandwidth != settings.m_txBandwidth) || force)
if (settingsKeys.contains("txBandwidth") || force)
{
reverseAPIKeys.append("txBandwidth");
if (dev)
{
unsigned int actualBandwidth;
@ -747,10 +664,8 @@ bool BladeRF2MIMO::applySettings(const BladeRF2MIMOSettings& settings, bool forc
}
}
if ((m_settings.m_log2Interp != settings.m_log2Interp) || force)
if (settingsKeys.contains("log2Interp") || force)
{
reverseAPIKeys.append("log2Interp");
if (m_sinkThread)
{
m_sinkThread->setLog2Interpolation(settings.m_log2Interp);
@ -758,19 +673,15 @@ bool BladeRF2MIMO::applySettings(const BladeRF2MIMOSettings& settings, bool forc
}
}
if ((m_settings.m_txBiasTee != settings.m_txBiasTee) || force)
if (settingsKeys.contains("txBiasTee") || force)
{
reverseAPIKeys.append("txBiasTee");
if (m_dev) {
m_dev->setBiasTeeTx(settings.m_txBiasTee);
}
}
if ((m_settings.m_tx0GlobalGain != settings.m_tx0GlobalGain) || force)
if (settingsKeys.contains("tx0GlobalGain") || force)
{
reverseAPIKeys.append("tx0GlobalGain");
if (dev)
{
int status = bladerf_set_gain(dev, BLADERF_CHANNEL_TX(0), settings.m_tx0GlobalGain);
@ -784,10 +695,8 @@ bool BladeRF2MIMO::applySettings(const BladeRF2MIMOSettings& settings, bool forc
}
}
if ((m_settings.m_tx1GlobalGain != settings.m_tx1GlobalGain) || force)
if (settingsKeys.contains("tx1GlobalGain") || force)
{
reverseAPIKeys.append("tx1GlobalGain");
if (dev)
{
int status = bladerf_set_gain(dev, BLADERF_CHANNEL_TX(1), settings.m_tx1GlobalGain);
@ -821,13 +730,13 @@ bool BladeRF2MIMO::applySettings(const BladeRF2MIMOSettings& settings, bool forc
// Reverse API settings
if (settings.m_useReverseAPI)
if (settingsKeys.contains("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);
bool fullUpdate = (settingsKeys.contains("useReverseAPI") && settings.m_useReverseAPI) ||
settingsKeys.contains("reverseAPIAddress") ||
settingsKeys.contains("reverseAPIPort") ||
settingsKeys.contains("reverseAPIDeviceIndex");
webapiReverseSendSettings(settingsKeys, settings, fullUpdate || force);
}
m_settings = settings;
@ -977,12 +886,12 @@ int BladeRF2MIMO::webapiSettingsPutPatch(
BladeRF2MIMOSettings settings = m_settings;
webapiUpdateDeviceSettings(settings, deviceSettingsKeys, response);
MsgConfigureBladeRF2MIMO *msg = MsgConfigureBladeRF2MIMO::create(settings, force);
MsgConfigureBladeRF2MIMO *msg = MsgConfigureBladeRF2MIMO::create(settings, deviceSettingsKeys, force);
m_inputMessageQueue.push(msg);
if (m_guiMessageQueue) // forward to GUI if any
{
MsgConfigureBladeRF2MIMO *msgToGUI = MsgConfigureBladeRF2MIMO::create(settings, force);
MsgConfigureBladeRF2MIMO *msgToGUI = MsgConfigureBladeRF2MIMO::create(settings, deviceSettingsKeys, force);
m_guiMessageQueue->push(msgToGUI);
}
@ -1174,7 +1083,7 @@ int BladeRF2MIMO::webapiRun(
}
}
void BladeRF2MIMO::webapiReverseSendSettings(QList<QString>& deviceSettingsKeys, const BladeRF2MIMOSettings& settings, bool force)
void BladeRF2MIMO::webapiReverseSendSettings(const QList<QString>& deviceSettingsKeys, const BladeRF2MIMOSettings& settings, bool force)
{
SWGSDRangel::SWGDeviceSettings *swgDeviceSettings = new SWGSDRangel::SWGDeviceSettings();
swgDeviceSettings->setDirection(2); // MIMO

14
plugins/samplemimo/bladerf2mimo/bladerf2mimo.h
View File

@ -46,20 +46,22 @@ public:
public:
const BladeRF2MIMOSettings& getSettings() const { return m_settings; }
const QList<QString>& getSettingsKeys() const { return m_settingsKeys; }
bool getForce() const { return m_force; }
static MsgConfigureBladeRF2MIMO* create(const BladeRF2MIMOSettings& settings, bool force)
{
return new MsgConfigureBladeRF2MIMO(settings, force);
static MsgConfigureBladeRF2MIMO* create(const BladeRF2MIMOSettings& settings, const QList<QString>& settingsKeys, bool force) {
return new MsgConfigureBladeRF2MIMO(settings, settingsKeys, force);
}
private:
BladeRF2MIMOSettings m_settings;
QList<QString> m_settingsKeys;
bool m_force;
MsgConfigureBladeRF2MIMO(const BladeRF2MIMOSettings& settings, bool force) :
MsgConfigureBladeRF2MIMO(const BladeRF2MIMOSettings& settings, const QList<QString>& settingsKeys, bool force) :
Message(),
m_settings(settings),
m_settingsKeys(settingsKeys),
m_force(force)
{ }
};
@ -192,10 +194,10 @@ private:
bool openDevice();
void closeDevice();
bool applySettings(const BladeRF2MIMOSettings& settings, bool force);
bool applySettings(const BladeRF2MIMOSettings& settings, const QList<QString>& settingsKeys, bool force);
bool setRxDeviceCenterFrequency(struct bladerf *dev, quint64 freq_hz, int loPpmTenths);
bool setTxDeviceCenterFrequency(struct bladerf *dev, quint64 freq_hz, int loPpmTenths);
void webapiReverseSendSettings(QList<QString>& deviceSettingsKeys, const BladeRF2MIMOSettings& settings, bool force);
void webapiReverseSendSettings(const QList<QString>& deviceSettingsKeys, const BladeRF2MIMOSettings& settings, bool force);
void webapiReverseSendStartStop(bool start);
void webapiFormatDeviceReport(SWGSDRangel::SWGDeviceReport& response);

105
plugins/samplemimo/bladerf2mimo/bladerf2mimogui.cpp
View File

@ -120,6 +120,7 @@ void BladeRF2MIMOGui::resetToDefaults()
{
m_settings.resetToDefaults();
displaySettings();
m_forceSettings = true;
sendSettings();
}
@ -358,7 +359,13 @@ bool BladeRF2MIMOGui::handleMessage(const Message& message)
else if (BladeRF2MIMO::MsgConfigureBladeRF2MIMO::match(message))
{
const BladeRF2MIMO::MsgConfigureBladeRF2MIMO& notif = (const BladeRF2MIMO::MsgConfigureBladeRF2MIMO&) message;
m_settings = notif.getSettings();
if (notif.getForce()) {
m_settings = notif.getSettings();
} else {
m_settings.applySettings(notif.getSettingsKeys(), notif.getSettings());
}
displaySettings();
return true;
@ -383,7 +390,7 @@ void BladeRF2MIMOGui::handleInputMessages()
void BladeRF2MIMOGui::sendSettings()
{
if(!m_updateTimer.isActive()) {
if (!m_updateTimer.isActive()) {
m_updateTimer.start(100);
}
}
@ -392,9 +399,10 @@ void BladeRF2MIMOGui::updateHardware()
{
if (m_doApplySettings)
{
BladeRF2MIMO::MsgConfigureBladeRF2MIMO* message = BladeRF2MIMO::MsgConfigureBladeRF2MIMO::create(m_settings, m_forceSettings);
BladeRF2MIMO::MsgConfigureBladeRF2MIMO* message = BladeRF2MIMO::MsgConfigureBladeRF2MIMO::create(m_settings, m_settingsKeys, m_forceSettings);
m_sampleMIMO->getInputMessageQueue()->push(message);
m_forceSettings = false;
m_settingsKeys.clear();
m_updateTimer.stop();
}
}
@ -463,10 +471,15 @@ void BladeRF2MIMOGui::on_startStopTx_toggled(bool checked)
void BladeRF2MIMOGui::on_centerFrequency_changed(quint64 value)
{
if (m_rxElseTx) {
if (m_rxElseTx)
{
m_settings.m_rxCenterFrequency = value * 1000;
} else {
m_settingsKeys.append("rxCenterFrequency");
}
else
{
m_settings.m_txCenterFrequency = value * 1000;
m_settingsKeys.append("txCenterFrequency");
}
sendSettings();
@ -476,27 +489,35 @@ void BladeRF2MIMOGui::on_LOppm_valueChanged(int value)
{
ui->LOppmText->setText(QString("%1").arg(QString::number(value/10.0, 'f', 1)));
m_settings.m_LOppmTenths = value;
m_settingsKeys.append("LOppmTenths");
sendSettings();
}
void BladeRF2MIMOGui::on_dcOffset_toggled(bool checked)
{
m_settings.m_dcBlock = checked;
m_settingsKeys.append("dcBlock");
sendSettings();
}
void BladeRF2MIMOGui::on_iqImbalance_toggled(bool checked)
{
m_settings.m_iqCorrection = checked;
m_settingsKeys.append("iqCorrection");
sendSettings();
}
void BladeRF2MIMOGui::on_bandwidth_changed(quint64 value)
{
if (m_rxElseTx) {
if (m_rxElseTx)
{
m_settings.m_rxBandwidth = value * 1000;
} else {
m_settingsKeys.append("rxBandwidth");
}
else
{
m_settings.m_txBandwidth = value * 1000;
m_settingsKeys.append("txBandwidth");
}
sendSettings();
@ -519,15 +540,21 @@ void BladeRF2MIMOGui::on_sampleRate_changed(quint64 value)
displaySampleRate();
displayFcTooltip();
m_settingsKeys.append("devSampleRate");
sendSettings();
}
void BladeRF2MIMOGui::on_fcPos_currentIndexChanged(int index)
{
if (m_rxElseTx) {
if (m_rxElseTx)
{
m_settings.m_fcPosRx = (BladeRF2MIMOSettings::fcPos_t) (index < 0 ? 0 : index > 2 ? 2 : index);
} else {
m_settingsKeys.append("fcPosRx");
}
else
{
m_settings.m_fcPosTx = (BladeRF2MIMOSettings::fcPos_t) (index < 0 ? 0 : index > 2 ? 2 : index);
m_settingsKeys.append("fcPosTx");
}
displayFcTooltip();
@ -540,10 +567,15 @@ void BladeRF2MIMOGui::on_decim_currentIndexChanged(int index)
return;
}
if (m_rxElseTx) {
if (m_rxElseTx)
{
m_settings.m_log2Decim = index;
} else {
m_settingsKeys.append("log2Decim");
}
else
{
m_settings.m_log2Interp = index;
m_settingsKeys.append("log2Interp");
}
displaySampleRate();
@ -554,6 +586,7 @@ void BladeRF2MIMOGui::on_decim_currentIndexChanged(int index)
m_settings.m_devSampleRate = ui->sampleRate->getValueNew() * (1 << (m_rxElseTx ? m_settings.m_log2Decim : m_settings.m_log2Interp));
}
m_settingsKeys.append("devSampleRate");
sendSettings();
}
@ -564,6 +597,9 @@ void BladeRF2MIMOGui::on_gainLock_toggled(bool checked)
m_settings.m_rx1GlobalGain = m_settings.m_rx0GlobalGain;
m_settings.m_rx1GainMode = m_settings.m_rx0GainMode;
m_settings.m_tx1GlobalGain = m_settings.m_tx0GlobalGain;
m_settingsKeys.append("rx1GlobalGain");
m_settingsKeys.append("rx1GainMode");
m_settingsKeys.append("tx1GlobalGain");
sendSettings();
}
@ -597,6 +633,7 @@ void BladeRF2MIMOGui::on_gainMode_currentIndexChanged(int index)
}
m_settings.m_rx0GainMode = mode.m_value;
m_settingsKeys.append("rx0GainMode");
}
if (m_streamIndex == 1 || m_gainLock)
@ -613,6 +650,7 @@ void BladeRF2MIMOGui::on_gainMode_currentIndexChanged(int index)
}
m_settings.m_rx1GainMode = mode.m_value;
m_settingsKeys.append("rx1GainMode");
}
sendSettings();
@ -636,11 +674,15 @@ float BladeRF2MIMOGui::setGainFromValue(int value)
m_sampleMIMO->getRxGlobalGainRange(min, max, step, scale);
gainDB = getGainDB(value, min, max, step, scale);
if (m_streamIndex == 0 || m_gainLock) {
if (m_streamIndex == 0 || m_gainLock)
{
m_settings.m_rx0GlobalGain = (int) gainDB;
m_settingsKeys.append("rx0GlobalGain");
}
if (m_streamIndex == 1 || m_gainLock) {
if (m_streamIndex == 1 || m_gainLock)
{
m_settings.m_rx1GlobalGain = (int) gainDB;
m_settingsKeys.append("rx1GlobalGain");
}
}
else
@ -648,11 +690,15 @@ float BladeRF2MIMOGui::setGainFromValue(int value)
m_sampleMIMO->getTxGlobalGainRange(min, max, step, scale);
gainDB = getGainDB(value, min, max, step, scale);
if (m_streamIndex == 0 || m_gainLock) {
if (m_streamIndex == 0 || m_gainLock)
{
m_settings.m_tx0GlobalGain = (int) gainDB;
m_settingsKeys.append("tx0GlobalGain");
}
if (m_streamIndex == 1 || m_gainLock) {
if (m_streamIndex == 1 || m_gainLock)
{
m_settings.m_tx1GlobalGain = (int) gainDB;
m_settingsKeys.append("tx1GlobalGain");
}
}
@ -661,10 +707,15 @@ float BladeRF2MIMOGui::setGainFromValue(int value)
void BladeRF2MIMOGui::on_biasTee_toggled(bool checked)
{
if (m_rxElseTx) {
if (m_rxElseTx)
{
m_settings.m_rxBiasTee = checked;
} else {
m_settingsKeys.append("rxBiasTee");
}
else
{
m_settings.m_txBiasTee = checked;
m_settingsKeys.append("txBiasTee");
}
sendSettings();
@ -677,12 +728,19 @@ void BladeRF2MIMOGui::on_transverter_clicked()
m_settings.m_rxTransverterMode = ui->transverter->getDeltaFrequencyAcive();
m_settings.m_rxTransverterDeltaFrequency = ui->transverter->getDeltaFrequency();
m_settings.m_iqOrder = ui->transverter->getIQOrder();
m_settingsKeys.append("rxTransverterMode");
m_settingsKeys.append("rxTransverterDeltaFrequency");
m_settingsKeys.append("iqOrder");
m_settingsKeys.append("rxCenterFrequency");
qDebug("BladeRF2InputGui::on_transverter_clicked: Rx: %lld Hz %s", m_settings.m_rxTransverterDeltaFrequency, m_settings.m_rxTransverterMode ? "on" : "off");
}
else
{
m_settings.m_txTransverterMode = ui->transverter->getDeltaFrequencyAcive();
m_settings.m_txTransverterDeltaFrequency = ui->transverter->getDeltaFrequency();
m_settingsKeys.append("txTransverterMode");
m_settingsKeys.append("txTransverterDeltaFrequency");
m_settingsKeys.append("txCenterFrequency");
qDebug("BladeRF2InputGui::on_transverter_clicked: Tx: %lld Hz %s", m_settings.m_txTransverterDeltaFrequency, m_settings.m_txTransverterMode ? "on" : "off");
}
@ -746,10 +804,15 @@ void BladeRF2MIMOGui::setCenterFrequencySetting(uint64_t kHzValue)
{
int64_t centerFrequency = kHzValue*1000;
if (m_rxElseTx) {
if (m_rxElseTx)
{
m_settings.m_rxCenterFrequency = centerFrequency < 0 ? 0 : (uint64_t) centerFrequency;
} else {
m_settingsKeys.append("rxCenterFrequency");
}
else
{
m_settings.m_txCenterFrequency = centerFrequency < 0 ? 0 : (uint64_t) centerFrequency;
m_settingsKeys.append("txCenterFrequency");
}
ui->centerFrequency->setToolTip(QString("Main center frequency in kHz (LO: %1 kHz)").arg(centerFrequency/1000));
@ -828,6 +891,10 @@ void BladeRF2MIMOGui::openDeviceSettingsDialog(const QPoint& p)
m_settings.m_reverseAPIAddress = dialog.getReverseAPIAddress();
m_settings.m_reverseAPIPort = dialog.getReverseAPIPort();
m_settings.m_reverseAPIDeviceIndex = dialog.getReverseAPIDeviceIndex();
m_settingsKeys.append("useReverseAPI");
m_settingsKeys.append("reverseAPIAddress");
m_settingsKeys.append("reverseAPIPort");
m_settingsKeys.append("reverseAPIDeviceIndex");
sendSettings();
}

1
plugins/samplemimo/bladerf2mimo/bladerf2mimogui.h
View File

@ -52,6 +52,7 @@ private:
Ui::BladeRF2MIMOGui* ui;
BladeRF2MIMOSettings m_settings;
QList<QString> m_settingsKeys;
bool m_rxElseTx; //!< Which side is being dealt with
int m_streamIndex; //!< Current stream index being dealt with
bool m_spectrumRxElseTx;

187
plugins/samplemimo/bladerf2mimo/bladerf2mimosettings.cpp
View File

@ -167,4 +167,191 @@ bool BladeRF2MIMOSettings::deserialize(const QByteArray& data)
}
}
void BladeRF2MIMOSettings::applySettings(const QStringList& settingsKeys, const BladeRF2MIMOSettings& settings)
{
if (settingsKeys.contains("devSampleRate")) {
m_devSampleRate = settings.m_devSampleRate;
}
if (settingsKeys.contains("LOppmTenths")) {
m_LOppmTenths = settings.m_LOppmTenths;
}
if (settingsKeys.contains("rxCenterFrequency")) {
m_rxCenterFrequency = settings.m_rxCenterFrequency;
}
if (settingsKeys.contains("log2Decim")) {
m_log2Decim = settings.m_log2Decim;
}
if (settingsKeys.contains("fcPosRx")) {
m_fcPosRx = settings.m_fcPosRx;
}
if (settingsKeys.contains("rxBandwidth")) {
m_rxBandwidth = settings.m_rxBandwidth;
}
if (settingsKeys.contains("rx0GainMode")) {
m_rx0GainMode = settings.m_rx0GainMode;
}
if (settingsKeys.contains("rx0GlobalGain")) {
m_rx0GlobalGain = settings.m_rx0GlobalGain;
}
if (settingsKeys.contains("rx1GainMode")) {
m_rx1GainMode = settings.m_rx1GainMode;
}
if (settingsKeys.contains("rx1GlobalGain")) {
m_rx1GlobalGain = settings.m_rx1GlobalGain;
}
if (settingsKeys.contains("rxBiasTee")) {
m_rxBiasTee = settings.m_rxBiasTee;
}
if (settingsKeys.contains("dcBlock")) {
m_dcBlock = settings.m_dcBlock;
}
if (settingsKeys.contains("iqCorrection")) {
m_iqCorrection = settings.m_iqCorrection;
}
if (settingsKeys.contains("rxTransverterMode")) {
m_rxTransverterMode = settings.m_rxTransverterMode;
}
if (settingsKeys.contains("rxTransverterDeltaFrequency")) {
m_rxTransverterDeltaFrequency = settings.m_rxTransverterDeltaFrequency;
}
if (settingsKeys.contains("iqOrder")) {
m_iqOrder = settings.m_iqOrder;
}
if (settingsKeys.contains("txCenterFrequency")) {
m_txCenterFrequency = settings.m_txCenterFrequency;
}
if (settingsKeys.contains("log2Interp")) {
m_log2Interp = settings.m_log2Interp;
}
if (settingsKeys.contains("fcPosTx")) {
m_fcPosTx = settings.m_fcPosTx;
}
if (settingsKeys.contains("txBandwidth")) {
m_txBandwidth = settings.m_txBandwidth;
}
if (settingsKeys.contains("tx0GlobalGain")) {
m_tx0GlobalGain = settings.m_tx0GlobalGain;
}
if (settingsKeys.contains("tx1GlobalGain")) {
m_tx1GlobalGain = settings.m_tx1GlobalGain;
}
if (settingsKeys.contains("txBiasTee")) {
m_txBiasTee = settings.m_txBiasTee;
}
if (settingsKeys.contains("txTransverterMode")) {
m_txTransverterMode = settings.m_txTransverterMode;
}
if (settingsKeys.contains("txTransverterDeltaFrequency")) {
m_txTransverterDeltaFrequency = settings.m_txTransverterDeltaFrequency;
}
if (settingsKeys.contains("useReverseAPI")) {
m_useReverseAPI = settings.m_useReverseAPI;
}
if (settingsKeys.contains("reverseAPIAddress")) {
m_reverseAPIAddress = settings.m_reverseAPIAddress;
}
if (settingsKeys.contains("reverseAPIPort")) {
m_reverseAPIPort = settings.m_reverseAPIPort;
}
if (settingsKeys.contains("reverseAPIDeviceIndex")) {
m_reverseAPIDeviceIndex = settings.m_reverseAPIDeviceIndex;
}
}
QString BladeRF2MIMOSettings::getDebugString(const QStringList& settingsKeys, bool force) const
{
std::ostringstream ostr;
if (settingsKeys.contains("devSampleRate") || force) {
ostr << " m_devSampleRate: " << m_devSampleRate;
}
if (settingsKeys.contains("LOppmTenths") || force) {
ostr << " m_LOppmTenths: " << m_LOppmTenths;
}
if (settingsKeys.contains("rxCenterFrequency") || force) {
ostr << " m_rxCenterFrequency: " << m_rxCenterFrequency;
}
if (settingsKeys.contains("log2Decim") || force) {
ostr << " m_log2Decim: " << m_log2Decim;
}
if (settingsKeys.contains("fcPosRx") || force) {
ostr << " m_fcPosRx: " << m_fcPosRx;
}
if (settingsKeys.contains("rxBandwidth") || force) {
ostr << " m_rxBandwidth: " << m_rxBandwidth;
}
if (settingsKeys.contains("rx0GainMode") || force) {
ostr << " m_rx0GainMode: " << m_rx0GainMode;
}
if (settingsKeys.contains("rx0GlobalGain") || force) {
ostr << " m_rx0GlobalGain: " << m_rx0GlobalGain;
}
if (settingsKeys.contains("rx1GainMode") || force) {
ostr << " m_rx1GainMode: " << m_rx1GainMode;
}
if (settingsKeys.contains("rx1GlobalGain") || force) {
ostr << " m_rx1GlobalGain: " << m_rx1GlobalGain;
}
if (settingsKeys.contains("rxBiasTee") || force) {
ostr << " m_rxBiasTee: " << m_rxBiasTee;
}
if (settingsKeys.contains("dcBlock") || force) {
ostr << " m_dcBlock: " << m_dcBlock;
}
if (settingsKeys.contains("iqCorrection") || force) {
ostr << " m_iqCorrection: " << m_iqCorrection;
}
if (settingsKeys.contains("rxTransverterMode") || force) {
ostr << " m_rxTransverterMode: " << m_rxTransverterMode;
}
if (settingsKeys.contains("rxTransverterDeltaFrequency") || force) {
ostr << " m_rxTransverterDeltaFrequency: " << m_rxTransverterDeltaFrequency;
}
if (settingsKeys.contains("iqOrder") || force) {
ostr << " m_iqOrder: " << m_iqOrder;
}
if (settingsKeys.contains("txCenterFrequency") || force) {
ostr << " m_txCenterFrequency: " << m_txCenterFrequency;
}
if (settingsKeys.contains("log2Interp") || force) {
ostr << " m_log2Interp: " << m_log2Interp;
}
if (settingsKeys.contains("fcPosTx") || force) {
ostr << " m_fcPosTx: " << m_fcPosTx;
}
if (settingsKeys.contains("txBandwidth") || force) {
ostr << " m_txBandwidth: " << m_txBandwidth;
}
if (settingsKeys.contains("tx0GlobalGain") || force) {
ostr << " m_tx0GlobalGain: " << m_tx0GlobalGain;
}
if (settingsKeys.contains("tx1GlobalGain") || force) {
ostr << " m_tx1GlobalGain: " << m_tx1GlobalGain;
}
if (settingsKeys.contains("txBiasTee") || force) {
ostr << " m_txBiasTee: " << m_txBiasTee;
}
if (settingsKeys.contains("txTransverterMode") || force) {
ostr << " m_txTransverterMode: " << m_txTransverterMode;
}
if (settingsKeys.contains("txTransverterDeltaFrequency") || force) {
ostr << " m_txTransverterDeltaFrequency: " << m_txTransverterDeltaFrequency;
}
if (settingsKeys.contains("useReverseAPI") || force) {
ostr << " m_useReverseAPI: " << m_useReverseAPI;
}
if (settingsKeys.contains("reverseAPIAddress") || force) {
ostr << " m_reverseAPIAddress: " << m_reverseAPIAddress.toStdString();
}
if (settingsKeys.contains("reverseAPIPort") || force) {
ostr << " m_reverseAPIPort: " << m_reverseAPIPort;
}
if (settingsKeys.contains("reverseAPIDeviceIndex") || force) {
ostr << " m_reverseAPIDeviceIndex: " << m_reverseAPIDeviceIndex;
}
return QString(ostr.str().c_str());
}

2
plugins/samplemimo/bladerf2mimo/bladerf2mimosettings.h
View File

@ -65,6 +65,8 @@ struct BladeRF2MIMOSettings {
void resetToDefaults();
QByteArray serialize() const;
bool deserialize(const QByteArray& data);
void applySettings(const QStringList& settingsKeys, const BladeRF2MIMOSettings& settings);
QString getDebugString(const QStringList& settingsKeys, bool force=false) const;
};