VE7UWU/sdrangel
1
0
Fork 0
mirror of https://github.com/f4exb/sdrangel.git synced 2025-11-09 15:50:24 -05:00
Code Issues Projects Releases Wiki Activity

BladeRF2 MIMO: implement Tx (2)

Browse Source
This commit is contained in:
f4exb 2019-10-18 18:27:13 +02:00
parent 584c1d2f40
commit d0b64daa4a
9 changed files with 318 additions and 130 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -51,7 +51,7 @@ BladeRF2MIMO::BladeRF2MIMO(DeviceAPI *deviceAPI) :
m_sourceThread(nullptr), m_sourceThread(nullptr),
m_sinkThread(nullptr), m_sinkThread(nullptr),
m_deviceDescription("BladeRF2MIMO"), m_deviceDescription("BladeRF2MIMO"),
m_rxElseTx(true), m_startStopRxElseTx(true),
m_runningRx(false), m_runningRx(false),
m_runningTx(false), m_runningTx(false),
m_dev(nullptr), m_dev(nullptr),
@ -74,7 +74,9 @@ BladeRF2MIMO::BladeRF2MIMO(DeviceAPI *deviceAPI) :
m_mimoType = MIMOHalfSynchronous; m_mimoType = MIMOHalfSynchronous;
m_sampleMIFifo.init(2, 96000 * 4); m_sampleMIFifo.init(2, 96000 * 4);
m_sampleMOFifo.init(2, 96000 * 4);
m_deviceAPI->setNbSourceStreams(2); m_deviceAPI->setNbSourceStreams(2);
m_deviceAPI->setNbSinkStreams(2);
m_networkManager = new QNetworkAccessManager(); m_networkManager = new QNetworkAccessManager();
connect(m_networkManager, SIGNAL(finished(QNetworkReply*)), this, SLOT(networkManagerFinished(QNetworkReply*))); connect(m_networkManager, SIGNAL(finished(QNetworkReply*)), this, SLOT(networkManagerFinished(QNetworkReply*)));
} }
@ -84,9 +86,7 @@ BladeRF2MIMO::~BladeRF2MIMO()
disconnect(m_networkManager, SIGNAL(finished(QNetworkReply*)), this, SLOT(networkManagerFinished(QNetworkReply*))); disconnect(m_networkManager, SIGNAL(finished(QNetworkReply*)), this, SLOT(networkManagerFinished(QNetworkReply*)));
delete m_networkManager; delete m_networkManager;
if (m_runningRx) { closeDevice();
stop();
}
std::vector<FileRecord*>::iterator it = m_fileSinks.begin(); std::vector<FileRecord*>::iterator it = m_fileSinks.begin();
int istream = 0; int istream = 0;
@ -128,12 +128,17 @@ void BladeRF2MIMO::closeDevice()
} }
if (m_runningRx) { if (m_runningRx) {
stop(); stopRx();
}
if (m_runningTx) {
stopTx();
} }
m_dev->close(); m_dev->close();
delete m_dev; delete m_dev;
m_dev = nullptr; m_dev = nullptr;
m_open = false;
} }
void BladeRF2MIMO::init() void BladeRF2MIMO::init()
@ -154,7 +159,7 @@ bool BladeRF2MIMO::start()
applySettings(m_settings, true); applySettings(m_settings, true);
if (m_rxElseTx) { if (m_startStopRxElseTx) {
startRx(); startRx();
} else { } else {
startTx(); startTx();
@ -165,23 +170,23 @@ bool BladeRF2MIMO::start()
void BladeRF2MIMO::startRx() void BladeRF2MIMO::startRx()
{ {
qDebug("BladeRF2MIMO::start"); qDebug("BladeRF2MIMO::startRx");
QMutexLocker mutexLocker(&m_mutex); QMutexLocker mutexLocker(&m_mutex);
if (m_runningRx) { if (m_runningRx) {
stop(); stopRx();
} }
m_sourceThread = new BladeRF2MIThread(m_dev->getDev()); m_sourceThread = new BladeRF2MIThread(m_dev->getDev());
m_sampleMIFifo.reset(); m_sampleMIFifo.reset();
m_sourceThread->setFifo(&m_sampleMIFifo); m_sourceThread->setFifo(&m_sampleMIFifo);
m_sourceThread->setFcPos(m_settings.m_fcPos); m_sourceThread->setFcPos(m_settings.m_fcPosRx);
m_sourceThread->setLog2Decimation(m_settings.m_log2Decim); m_sourceThread->setLog2Decimation(m_settings.m_log2Decim);
for (int i = 0; i < 2; i++) for (int i = 0; i < 2; i++)
{ {
if (!m_dev->openRx(i)) { if (!m_dev->openRx(i)) {
qCritical("BladeRF2MIMO::start: Rx channel %u cannot be enabled", i); qCritical("BladeRF2MIMO::startRx: Rx channel %u cannot be enabled", i);
} }
} }
@ -192,12 +197,34 @@ void BladeRF2MIMO::startRx()
void BladeRF2MIMO::startTx() void BladeRF2MIMO::startTx()
{ {
// TODO qDebug("BladeRF2MIMO::startTx");
QMutexLocker mutexLocker(&m_mutex);
if (m_runningTx) {
stopTx();
}
m_sinkThread = new BladeRF2MOThread(m_dev->getDev());
m_sampleMOFifo.reset();
m_sinkThread->setFifo(&m_sampleMOFifo);
m_sinkThread->setFcPos(m_settings.m_fcPosTx);
m_sinkThread->setLog2Interpolation(m_settings.m_log2Interp);
for (int i = 0; i < 2; i++)
{
if (!m_dev->openRx(i)) {
qCritical("BladeRF2MIMO::startTx: Rx channel %u cannot be enabled", i);
}
}
m_sourceThread->startWork();
mutexLocker.unlock();
m_runningRx = true;
} }
void BladeRF2MIMO::stop() void BladeRF2MIMO::stop()
{ {
if (m_rxElseTx) { if (m_startStopRxElseTx) {
stopRx(); stopRx();
} else { } else {
stopTx(); stopTx();
@ -206,7 +233,7 @@ void BladeRF2MIMO::stop()
void BladeRF2MIMO::stopRx() void BladeRF2MIMO::stopRx()
{ {
qDebug("BladeRF2MIMO::stop"); qDebug("BladeRF2MIMO::stopRx");
if (!m_sourceThread) { if (!m_sourceThread) {
return; return;
@ -226,7 +253,22 @@ void BladeRF2MIMO::stopRx()
void BladeRF2MIMO::stopTx() void BladeRF2MIMO::stopTx()
{ {
// TODO qDebug("BladeRF2MIMO::stopTx");
if (!m_sinkThread) {
return;
}
QMutexLocker mutexLocker(&m_mutex);
m_sinkThread->stopWork();
delete m_sinkThread;
m_sinkThread = nullptr;
m_runningTx = false;
for (int i = 0; i < 2; i++) {
m_dev->closeTx(i);
}
} }
QByteArray BladeRF2MIMO::serialize() const QByteArray BladeRF2MIMO::serialize() const
@ -364,17 +406,22 @@ bool BladeRF2MIMO::handleMessage(const Message& message)
<< " " << (cmd.getRxElseTx() ? "Rx" : "Tx") << " " << (cmd.getRxElseTx() ? "Rx" : "Tx")
<< " MsgStartStop: " << (cmd.getStartStop() ? "start" : "stop"); << " MsgStartStop: " << (cmd.getStartStop() ? "start" : "stop");
m_rxElseTx = cmd.getRxElseTx(); m_startStopRxElseTx = cmd.getRxElseTx();
if (cmd.getStartStop()) if (cmd.getStartStop()) // start engine if not started yet
{ {
if (m_deviceAPI->initDeviceEngine()) { if ((m_deviceAPI->state() == DeviceAPI::StNotStarted) || (m_deviceAPI->state() == DeviceAPI::StIdle))
m_deviceAPI->startDeviceEngine(); {
if (m_deviceAPI->initDeviceEngine()) {
m_deviceAPI->startDeviceEngine();
}
} }
} }
else else // stop engine if the other part is not running
{ {
m_deviceAPI->stopDeviceEngine(); if ((m_startStopRxElseTx && !m_runningTx) || (!m_startStopRxElseTx && m_runningRx)) {
m_deviceAPI->stopDeviceEngine();
}
} }
if (m_settings.m_useReverseAPI) { if (m_settings.m_useReverseAPI) {
@ -400,7 +447,7 @@ bool BladeRF2MIMO::applySettings(const BladeRF2MIMOSettings& settings, bool forc
<< " m_LOppmTenths: " << settings.m_LOppmTenths << " m_LOppmTenths: " << settings.m_LOppmTenths
<< " m_rxCenterFrequency: " << settings.m_rxCenterFrequency << " m_rxCenterFrequency: " << settings.m_rxCenterFrequency
<< " m_log2Decim: " << settings.m_log2Decim << " m_log2Decim: " << settings.m_log2Decim
<< " m_fcPos: " << settings.m_fcPos << " m_fcPosRx: " << settings.m_fcPosRx
<< " m_rxBandwidth: " << settings.m_rxBandwidth << " m_rxBandwidth: " << settings.m_rxBandwidth
<< " m_rx0GainMode: " << settings.m_rx0GainMode << " m_rx0GainMode: " << settings.m_rx0GainMode
<< " m_rx0GlobalGain: " << settings.m_rx0GlobalGain << " m_rx0GlobalGain: " << settings.m_rx0GlobalGain
@ -413,6 +460,7 @@ bool BladeRF2MIMO::applySettings(const BladeRF2MIMOSettings& settings, bool forc
<< " m_rxTransverterDeltaFrequency: " << settings.m_rxTransverterDeltaFrequency << " m_rxTransverterDeltaFrequency: " << settings.m_rxTransverterDeltaFrequency
<< " m_txCenterFrequency: " << settings.m_txCenterFrequency << " m_txCenterFrequency: " << settings.m_txCenterFrequency
<< " m_log2Interp: " << settings.m_log2Interp << " m_log2Interp: " << settings.m_log2Interp
<< " m_fcPosTx: " << settings.m_fcPosTx
<< " m_txBandwidth: " << settings.m_txBandwidth << " m_txBandwidth: " << settings.m_txBandwidth
<< " m_tx0GlobalGain: " << settings.m_tx0GlobalGain << " m_tx0GlobalGain: " << settings.m_tx0GlobalGain
<< " m_tx1GlobalGain: " << settings.m_tx1GlobalGain << " m_tx1GlobalGain: " << settings.m_tx1GlobalGain
@ -500,14 +548,14 @@ bool BladeRF2MIMO::applySettings(const BladeRF2MIMOSettings& settings, bool forc
} }
} }
if ((m_settings.m_fcPos != settings.m_fcPos) || force) if ((m_settings.m_fcPosRx != settings.m_fcPosRx) || force)
{ {
reverseAPIKeys.append("fcPos"); reverseAPIKeys.append("fcPosRx");
if (m_sourceThread) if (m_sourceThread)
{ {
m_sourceThread->setFcPos((int) settings.m_fcPos); m_sourceThread->setFcPos((int) settings.m_fcPosRx);
qDebug() << "BladeRF2MIMO::applySettings: set fc pos (enum) to " << (int) settings.m_fcPos; qDebug() << "BladeRF2MIMO::applySettings: set Rx fc pos (enum) to " << (int) settings.m_fcPosRx;
} }
} }
@ -522,6 +570,17 @@ bool BladeRF2MIMO::applySettings(const BladeRF2MIMOSettings& settings, bool forc
} }
} }
if ((m_settings.m_fcPosTx != settings.m_fcPosTx) || force)
{
reverseAPIKeys.append("fcPosTx");
if (m_sourceThread)
{
m_sourceThread->setFcPos((int) settings.m_fcPosTx);
qDebug() << "BladeRF2MIMO::applySettings: set Tx fc pos (enum) to " << (int) settings.m_fcPosTx;
}
}
if ((m_settings.m_log2Interp != settings.m_log2Interp) || force) if ((m_settings.m_log2Interp != settings.m_log2Interp) || force)
{ {
reverseAPIKeys.append("log2Interp"); reverseAPIKeys.append("log2Interp");
@ -551,14 +610,14 @@ bool BladeRF2MIMO::applySettings(const BladeRF2MIMOSettings& settings, bool forc
|| (m_settings.m_rxTransverterDeltaFrequency != settings.m_rxTransverterDeltaFrequency) || (m_settings.m_rxTransverterDeltaFrequency != settings.m_rxTransverterDeltaFrequency)
|| (m_settings.m_LOppmTenths != settings.m_LOppmTenths) || (m_settings.m_LOppmTenths != settings.m_LOppmTenths)
|| (m_settings.m_devSampleRate != settings.m_devSampleRate) || (m_settings.m_devSampleRate != settings.m_devSampleRate)
|| (m_settings.m_fcPos != settings.m_fcPos) || (m_settings.m_fcPosRx != settings.m_fcPosRx)
|| (m_settings.m_log2Decim != settings.m_log2Decim) || force) || (m_settings.m_log2Decim != settings.m_log2Decim) || force)
{ {
qint64 deviceCenterFrequency = DeviceSampleSource::calculateDeviceCenterFrequency( qint64 deviceCenterFrequency = DeviceSampleSource::calculateDeviceCenterFrequency(
rxXlatedDeviceCenterFrequency, rxXlatedDeviceCenterFrequency,
0, 0,
settings.m_log2Decim, settings.m_log2Decim,
(DeviceSampleSource::fcPos_t) settings.m_fcPos, (DeviceSampleSource::fcPos_t) settings.m_fcPosRx,
settings.m_devSampleRate, settings.m_devSampleRate,
DeviceSampleSource::FrequencyShiftScheme::FSHIFT_STD, DeviceSampleSource::FrequencyShiftScheme::FSHIFT_STD,
false); false);
@ -678,6 +737,7 @@ bool BladeRF2MIMO::applySettings(const BladeRF2MIMOSettings& settings, bool forc
if ((m_settings.m_txCenterFrequency != settings.m_txCenterFrequency) if ((m_settings.m_txCenterFrequency != settings.m_txCenterFrequency)
|| (m_settings.m_txTransverterMode != settings.m_txTransverterMode) || (m_settings.m_txTransverterMode != settings.m_txTransverterMode)
|| (m_settings.m_txTransverterDeltaFrequency != settings.m_txTransverterDeltaFrequency) || (m_settings.m_txTransverterDeltaFrequency != settings.m_txTransverterDeltaFrequency)
|| (m_settings.m_fcPosTx != settings.m_fcPosTx)
|| (m_settings.m_LOppmTenths != settings.m_LOppmTenths) || (m_settings.m_LOppmTenths != settings.m_LOppmTenths)
|| (m_settings.m_devSampleRate != settings.m_devSampleRate) || force) || (m_settings.m_devSampleRate != settings.m_devSampleRate) || force)
{ {
@ -687,7 +747,7 @@ bool BladeRF2MIMO::applySettings(const BladeRF2MIMOSettings& settings, bool forc
settings.m_txCenterFrequency, settings.m_txCenterFrequency,
settings.m_txTransverterDeltaFrequency, settings.m_txTransverterDeltaFrequency,
settings.m_log2Interp, settings.m_log2Interp,
(DeviceSampleSink::fcPos_t) DeviceSampleSink::FC_POS_CENTER, (DeviceSampleSink::fcPos_t) settings.m_fcPosTx,
settings.m_devSampleRate, settings.m_devSampleRate,
settings.m_txTransverterMode); settings.m_txTransverterMode);
@ -1004,8 +1064,8 @@ void BladeRF2MIMO::webapiUpdateDeviceSettings(
if (deviceSettingsKeys.contains("log2Decim")) { if (deviceSettingsKeys.contains("log2Decim")) {
settings.m_log2Decim = response.getBladeRf2MimoSettings()->getLog2Decim(); settings.m_log2Decim = response.getBladeRf2MimoSettings()->getLog2Decim();
} }
if (deviceSettingsKeys.contains("fcPos")) { if (deviceSettingsKeys.contains("fcPosRx")) {
settings.m_fcPos = static_cast<BladeRF2MIMOSettings::fcPos_t>(response.getBladeRf2MimoSettings()->getFcPos()); settings.m_fcPosRx = static_cast<BladeRF2MIMOSettings::fcPos_t>(response.getBladeRf2MimoSettings()->getFcPosRx());
} }
if (deviceSettingsKeys.contains("rxBandwidth")) { if (deviceSettingsKeys.contains("rxBandwidth")) {
settings.m_rxBandwidth = response.getBladeRf2MimoSettings()->getRxBandwidth(); settings.m_rxBandwidth = response.getBladeRf2MimoSettings()->getRxBandwidth();
@ -1044,6 +1104,9 @@ void BladeRF2MIMO::webapiUpdateDeviceSettings(
if (deviceSettingsKeys.contains("log2Interp")) { if (deviceSettingsKeys.contains("log2Interp")) {
settings.m_log2Interp = response.getBladeRf2MimoSettings()->getLog2Interp(); settings.m_log2Interp = response.getBladeRf2MimoSettings()->getLog2Interp();
} }
if (deviceSettingsKeys.contains("fcPosTx")) {
settings.m_fcPosRx = static_cast<BladeRF2MIMOSettings::fcPos_t>(response.getBladeRf2MimoSettings()->getFcPosTx());
}
if (deviceSettingsKeys.contains("txBandwidth")) { if (deviceSettingsKeys.contains("txBandwidth")) {
settings.m_txBandwidth = response.getBladeRf2MimoSettings()->getTxBandwidth(); settings.m_txBandwidth = response.getBladeRf2MimoSettings()->getTxBandwidth();
} }
@ -1087,7 +1150,7 @@ void BladeRF2MIMO::webapiFormatDeviceSettings(SWGSDRangel::SWGDeviceSettings& re
response.getBladeRf2MimoSettings()->setRxCenterFrequency(settings.m_rxCenterFrequency); response.getBladeRf2MimoSettings()->setRxCenterFrequency(settings.m_rxCenterFrequency);
response.getBladeRf2MimoSettings()->setLog2Decim(settings.m_log2Decim); response.getBladeRf2MimoSettings()->setLog2Decim(settings.m_log2Decim);
response.getBladeRf2MimoSettings()->setFcPos((int) settings.m_fcPos); response.getBladeRf2MimoSettings()->setFcPosRx((int) settings.m_fcPosRx);
response.getBladeRf2MimoSettings()->setRxBandwidth(settings.m_rxBandwidth); response.getBladeRf2MimoSettings()->setRxBandwidth(settings.m_rxBandwidth);
response.getBladeRf2MimoSettings()->setRx0GainMode(settings.m_rx0GainMode); response.getBladeRf2MimoSettings()->setRx0GainMode(settings.m_rx0GainMode);
response.getBladeRf2MimoSettings()->setRx0GlobalGain(settings.m_rx0GlobalGain); response.getBladeRf2MimoSettings()->setRx0GlobalGain(settings.m_rx0GlobalGain);
@ -1101,6 +1164,7 @@ void BladeRF2MIMO::webapiFormatDeviceSettings(SWGSDRangel::SWGDeviceSettings& re
response.getBladeRf2MimoSettings()->setTxCenterFrequency(settings.m_txCenterFrequency); response.getBladeRf2MimoSettings()->setTxCenterFrequency(settings.m_txCenterFrequency);
response.getBladeRf2MimoSettings()->setLog2Interp(settings.m_log2Interp); response.getBladeRf2MimoSettings()->setLog2Interp(settings.m_log2Interp);
response.getBladeRf2MimoSettings()->setFcPosTx((int) settings.m_fcPosTx);
response.getBladeRf2MimoSettings()->setTxBandwidth(settings.m_txBandwidth); response.getBladeRf2MimoSettings()->setTxBandwidth(settings.m_txBandwidth);
response.getBladeRf2MimoSettings()->setTx0GlobalGain(settings.m_tx0GlobalGain); response.getBladeRf2MimoSettings()->setTx0GlobalGain(settings.m_tx0GlobalGain);
response.getBladeRf2MimoSettings()->setTx1GlobalGain(settings.m_tx1GlobalGain); response.getBladeRf2MimoSettings()->setTx1GlobalGain(settings.m_tx1GlobalGain);
@ -1178,8 +1242,8 @@ void BladeRF2MIMO::webapiReverseSendSettings(QList<QString>& deviceSettingsKeys,
if (deviceSettingsKeys.contains("log2Decim") || force) { if (deviceSettingsKeys.contains("log2Decim") || force) {
swgBladeRF2MIMOSettings->setLog2Decim(settings.m_log2Decim); swgBladeRF2MIMOSettings->setLog2Decim(settings.m_log2Decim);
} }
if (deviceSettingsKeys.contains("fcPos") || force) { if (deviceSettingsKeys.contains("fcPosRx") || force) {
swgBladeRF2MIMOSettings->setFcPos((int) settings.m_fcPos); swgBladeRF2MIMOSettings->setFcPosRx((int) settings.m_fcPosRx);
} }
if (deviceSettingsKeys.contains("rxBandwidth") || force) { if (deviceSettingsKeys.contains("rxBandwidth") || force) {
swgBladeRF2MIMOSettings->setRxBandwidth(settings.m_rxBandwidth); swgBladeRF2MIMOSettings->setRxBandwidth(settings.m_rxBandwidth);
@ -1218,6 +1282,9 @@ void BladeRF2MIMO::webapiReverseSendSettings(QList<QString>& deviceSettingsKeys,
if (deviceSettingsKeys.contains("log2Interp") || force) { if (deviceSettingsKeys.contains("log2Interp") || force) {
swgBladeRF2MIMOSettings->setLog2Interp(settings.m_log2Interp); swgBladeRF2MIMOSettings->setLog2Interp(settings.m_log2Interp);
} }
if (deviceSettingsKeys.contains("fcPosTx") || force) {
swgBladeRF2MIMOSettings->setFcPosTx((int) settings.m_fcPosTx);
}
if (deviceSettingsKeys.contains("txBandwidth") || force) { if (deviceSettingsKeys.contains("txBandwidth") || force) {
swgBladeRF2MIMOSettings->setTxBandwidth(settings.m_txBandwidth); swgBladeRF2MIMOSettings->setTxBandwidth(settings.m_txBandwidth);
} }

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

@ -212,6 +212,9 @@ public:
void getTxBandwidthRange(int& min, int& max, int& step); void getTxBandwidthRange(int& min, int& max, int& step);
void getTxGlobalGainRange(int& min, int& max, int& step); void getTxGlobalGainRange(int& min, int& max, int& step);
bool getRxRunning() const { return m_runningRx; }
bool getTxRunning() const { return m_runningTx; }
private: private:
DeviceAPI *m_deviceAPI; DeviceAPI *m_deviceAPI;
std::vector<FileRecord *> m_fileSinks; //!< File sinks to record device I/Q output std::vector<FileRecord *> m_fileSinks; //!< File sinks to record device I/Q output
@ -220,7 +223,7 @@ private:
BladeRF2MIThread* m_sourceThread; BladeRF2MIThread* m_sourceThread;
BladeRF2MOThread* m_sinkThread; BladeRF2MOThread* m_sinkThread;
QString m_deviceDescription; QString m_deviceDescription;
bool m_rxElseTx; bool m_startStopRxElseTx;
bool m_runningRx; bool m_runningRx;
bool m_runningTx; bool m_runningTx;
QNetworkAccessManager *m_networkManager; QNetworkAccessManager *m_networkManager;

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

@ -90,7 +90,7 @@ BladeRF2MIMOGui::BladeRF2MIMOGui(DeviceUISet *deviceUISet, QWidget* parent) :
connect(&m_inputMessageQueue, SIGNAL(messageEnqueued()), this, SLOT(handleInputMessages()), Qt::QueuedConnection); connect(&m_inputMessageQueue, SIGNAL(messageEnqueued()), this, SLOT(handleInputMessages()), Qt::QueuedConnection);
m_sampleMIMO->setMessageQueueToGUI(&m_inputMessageQueue); m_sampleMIMO->setMessageQueueToGUI(&m_inputMessageQueue);
CRightClickEnabler *startStopRightClickEnabler = new CRightClickEnabler(ui->startStop); CRightClickEnabler *startStopRightClickEnabler = new CRightClickEnabler(ui->startStopRx);
connect(startStopRightClickEnabler, SIGNAL(rightClick(const QPoint &)), this, SLOT(openDeviceSettingsDialog(const QPoint &))); connect(startStopRightClickEnabler, SIGNAL(rightClick(const QPoint &)), this, SLOT(openDeviceSettingsDialog(const QPoint &)));
} }
@ -173,6 +173,7 @@ void BladeRF2MIMOGui::displaySettings()
ui->label_decim->setText(QString("Dec")); ui->label_decim->setText(QString("Dec"));
ui->decim->setToolTip(QString("Decimation factor")); ui->decim->setToolTip(QString("Decimation factor"));
ui->gainMode->setEnabled(true); ui->gainMode->setEnabled(true);
ui->fcPos->setCurrentIndex((int) m_settings.m_fcPosRx);
if (m_streamIndex == 0) if (m_streamIndex == 0)
{ {
@ -205,6 +206,7 @@ void BladeRF2MIMOGui::displaySettings()
ui->label_decim->setText(QString("Int")); ui->label_decim->setText(QString("Int"));
ui->decim->setToolTip(QString("Interpolation factor")); ui->decim->setToolTip(QString("Interpolation factor"));
ui->gainMode->setEnabled(false); ui->gainMode->setEnabled(false);
ui->fcPos->setCurrentIndex((int) m_settings.m_fcPosTx);
if (m_streamIndex == 0) if (m_streamIndex == 0)
{ {
@ -221,7 +223,6 @@ void BladeRF2MIMOGui::displaySettings()
ui->sampleRate->setValue(m_settings.m_devSampleRate); ui->sampleRate->setValue(m_settings.m_devSampleRate);
ui->LOppm->setValue(m_settings.m_LOppmTenths); ui->LOppm->setValue(m_settings.m_LOppmTenths);
ui->LOppmText->setText(QString("%1").arg(QString::number(m_settings.m_LOppmTenths/10.0, 'f', 1))); ui->LOppmText->setText(QString("%1").arg(QString::number(m_settings.m_LOppmTenths/10.0, 'f', 1)));
ui->fcPos->setCurrentIndex((int) m_settings.m_fcPos);
displaySampleRate(); displaySampleRate();
} }
@ -267,7 +268,7 @@ void BladeRF2MIMOGui::displayFcTooltip()
{ {
fShift = DeviceSampleStatic::calculateSourceFrequencyShift( fShift = DeviceSampleStatic::calculateSourceFrequencyShift(
m_settings.m_log2Decim, m_settings.m_log2Decim,
(DeviceSampleStatic::fcPos_t) m_settings.m_fcPos, (DeviceSampleStatic::fcPos_t) m_settings.m_fcPosRx,
m_settings.m_devSampleRate, m_settings.m_devSampleRate,
DeviceSampleStatic::FrequencyShiftScheme::FSHIFT_STD DeviceSampleStatic::FrequencyShiftScheme::FSHIFT_STD
); );
@ -275,8 +276,8 @@ void BladeRF2MIMOGui::displayFcTooltip()
else else
{ {
fShift = DeviceSampleStatic::calculateSinkFrequencyShift( fShift = DeviceSampleStatic::calculateSinkFrequencyShift(
m_settings.m_log2Decim, m_settings.m_log2Interp,
(DeviceSampleStatic::fcPos_t) m_settings.m_fcPos, (DeviceSampleStatic::fcPos_t) m_settings.m_fcPosTx,
m_settings.m_devSampleRate m_settings.m_devSampleRate
); );
} }
@ -300,6 +301,7 @@ void BladeRF2MIMOGui::displayGainModes()
else else
{ {
ui->gainMode->clear(); ui->gainMode->clear();
ui->gainMode->addItem("automatic");
} }
ui->gainMode->blockSignals(false); ui->gainMode->blockSignals(false);
@ -413,11 +415,20 @@ void BladeRF2MIMOGui::on_spectrumIndex_currentIndexChanged(int index)
updateSampleRateAndFrequency(); updateSampleRateAndFrequency();
} }
void BladeRF2MIMOGui::on_startStop_toggled(bool checked) void BladeRF2MIMOGui::on_startStopRx_toggled(bool checked)
{ {
if (m_doApplySettings) if (m_doApplySettings)
{ {
BladeRF2MIMO::MsgStartStop *message = BladeRF2MIMO::MsgStartStop::create(checked, m_rxElseTx); BladeRF2MIMO::MsgStartStop *message = BladeRF2MIMO::MsgStartStop::create(checked, true);
m_sampleMIMO->getInputMessageQueue()->push(message);
}
}
void BladeRF2MIMOGui::on_startStopTx_toggled(bool checked)
{
if (m_doApplySettings)
{
BladeRF2MIMO::MsgStartStop *message = BladeRF2MIMO::MsgStartStop::create(checked, false);
m_sampleMIMO->getInputMessageQueue()->push(message); m_sampleMIMO->getInputMessageQueue()->push(message);
} }
} }
@ -497,7 +508,12 @@ void BladeRF2MIMOGui::on_sampleRate_changed(quint64 value)
void BladeRF2MIMOGui::on_fcPos_currentIndexChanged(int index) void BladeRF2MIMOGui::on_fcPos_currentIndexChanged(int index)
{ {
m_settings.m_fcPos = (BladeRF2MIMOSettings::fcPos_t) (index < 0 ? 0 : index > 2 ? 2 : index); if (m_rxElseTx) {
m_settings.m_fcPosRx = (BladeRF2MIMOSettings::fcPos_t) (index < 0 ? 0 : index > 2 ? 2 : index);
} else {
m_settings.m_fcPosTx = (BladeRF2MIMOSettings::fcPos_t) (index < 0 ? 0 : index > 2 ? 2 : index);
}
displayFcTooltip(); displayFcTooltip();
sendSettings(); sendSettings();
} }
@ -681,21 +697,38 @@ void BladeRF2MIMOGui::updateStatus()
{ {
int state = m_deviceUISet->m_deviceAPI->state(); int state = m_deviceUISet->m_deviceAPI->state();
if(m_lastEngineState != state) if (m_lastEngineState != state)
{ {
switch(state) switch(state)
{ {
case DeviceAPI::StNotStarted: case DeviceAPI::StNotStarted:
ui->startStop->setStyleSheet("QToolButton { background:rgb(79,79,79); }"); ui->startStopRx->setStyleSheet("QToolButton { background:rgb(79,79,79); }");
ui->startStopTx->setStyleSheet("QToolButton { background:rgb(79,79,79); }");
break; break;
case DeviceAPI::StIdle: case DeviceAPI::StIdle:
ui->startStop->setStyleSheet("QToolButton { background-color : blue; }"); ui->startStopRx->setStyleSheet("QToolButton { background-color : blue; }");
ui->startStopTx->setStyleSheet("QToolButton { background-color : blue; }");
break; break;
case DeviceAPI::StRunning: case DeviceAPI::StRunning:
ui->startStop->setStyleSheet("QToolButton { background-color : green; }"); {
if (m_sampleMIMO->getRxRunning()) {
ui->startStopRx->setStyleSheet("QToolButton { background-color : green; }");
} else {
ui->startStopRx->setStyleSheet("QToolButton { background-color : blue; }");
}
if (m_sampleMIMO->getTxRunning()) {
ui->startStopTx->setStyleSheet("QToolButton { background-color : green; }");
} else {
ui->startStopTx->setStyleSheet("QToolButton { background-color : blue; }");
}
}
break; break;
case DeviceAPI::StError: case DeviceAPI::StError:
ui->startStop->setStyleSheet("QToolButton { background-color : red; }"); if (m_rxElseTx) {
ui->startStopRx->setStyleSheet("QToolButton { background-color : red; }");
} else {
ui->startStopTx->setStyleSheet("QToolButton { background-color : red; }");
}
QMessageBox::information(this, tr("Message"), m_deviceUISet->m_deviceAPI->errorMessage()); QMessageBox::information(this, tr("Message"), m_deviceUISet->m_deviceAPI->errorMessage());
break; break;
default: default:

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

@ -100,7 +100,8 @@ private slots:
void on_streamIndex_currentIndexChanged(int index); void on_streamIndex_currentIndexChanged(int index);
void on_spectrumSide_currentIndexChanged(int index); void on_spectrumSide_currentIndexChanged(int index);
void on_spectrumIndex_currentIndexChanged(int index); void on_spectrumIndex_currentIndexChanged(int index);
void on_startStop_toggled(bool checked); void on_startStopRx_toggled(bool checked);
void on_startStopTx_toggled(bool checked);
void on_record_toggled(bool checked); void on_record_toggled(bool checked);
void on_centerFrequency_changed(quint64 value); void on_centerFrequency_changed(quint64 value);
void on_LOppm_valueChanged(int value); void on_LOppm_valueChanged(int value);

68
plugins/samplemimo/bladerf2mimo/bladerf2mimogui.ui
View File

@ -6,7 +6,7 @@
<rect> <rect>
<x>0</x> <x>0</x>
<y>0</y> <y>0</y>
<width>350</width> <width>366</width>
<height>220</height> <height>220</height>
</rect> </rect>
</property> </property>
@ -182,6 +182,57 @@
</item> </item>
</widget> </widget>
</item> </item>
<item>
<widget class="Line" name="line">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="startStopRxLabel">
<property name="text">
<string>Rx</string>
</property>
</widget>
</item>
<item>
<widget class="ButtonSwitch" name="startStopRx">
<property name="toolTip">
<string>start/stop acquisition (Rx)</string>
</property>
<property name="text">
<string/>
</property>
<property name="icon">
<iconset resource="../../../sdrgui/resources/res.qrc">
<normaloff>:/play.png</normaloff>
<normalon>:/stop.png</normalon>:/play.png</iconset>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="startStopTxLabel">
<property name="text">
<string>Tx</string>
</property>
</widget>
</item>
<item>
<widget class="ButtonSwitch" name="startStopTx">
<property name="toolTip">
<string>start/stop generation (Tx)</string>
</property>
<property name="text">
<string/>
</property>
<property name="icon">
<iconset resource="../../../sdrgui/resources/res.qrc">
<normaloff>:/play.png</normaloff>
<normalon>:/stop.png</normalon>:/play.png</iconset>
</property>
</widget>
</item>
<item> <item>
<spacer name="horizontalSpacer"> <spacer name="horizontalSpacer">
<property name="orientation"> <property name="orientation">
@ -206,21 +257,6 @@
<layout class="QVBoxLayout" name="deviceUILayout"> <layout class="QVBoxLayout" name="deviceUILayout">
<item> <item>
<layout class="QHBoxLayout" name="deviceButtonsLayout"> <layout class="QHBoxLayout" name="deviceButtonsLayout">
<item>
<widget class="ButtonSwitch" name="startStop">
<property name="toolTip">
<string>start/stop acquisition</string>
</property>
<property name="text">
<string/>
</property>
<property name="icon">
<iconset resource="../../../sdrgui/resources/res.qrc">
<normaloff>:/play.png</normaloff>
<normalon>:/stop.png</normalon>:/play.png</iconset>
</property>
</widget>
</item>
<item> <item>
<widget class="ButtonSwitch" name="record"> <widget class="ButtonSwitch" name="record">
<property name="toolTip"> <property name="toolTip">

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

@ -31,7 +31,7 @@ void BladeRF2MIMOSettings::resetToDefaults()
m_rxCenterFrequency = 435000*1000; m_rxCenterFrequency = 435000*1000;
m_log2Decim = 0; m_log2Decim = 0;
m_fcPos = FC_POS_INFRA; m_fcPosRx = FC_POS_INFRA;
m_rxBandwidth = 1500000; m_rxBandwidth = 1500000;
m_rx0GainMode = 0; m_rx0GainMode = 0;
m_rx0GlobalGain = 0; m_rx0GlobalGain = 0;
@ -45,6 +45,7 @@ void BladeRF2MIMOSettings::resetToDefaults()
m_txCenterFrequency = 435000*1000; m_txCenterFrequency = 435000*1000;
m_log2Interp = 0; m_log2Interp = 0;
m_fcPosTx = FC_POS_CENTER;
m_txBandwidth = 1500000; m_txBandwidth = 1500000;
m_tx0GlobalGain = -3; m_tx0GlobalGain = -3;
m_tx1GlobalGain = -3; m_tx1GlobalGain = -3;
@ -68,7 +69,7 @@ QByteArray BladeRF2MIMOSettings::serialize() const
s.writeU64(10, m_rxCenterFrequency); s.writeU64(10, m_rxCenterFrequency);
s.writeU32(11, m_log2Decim); s.writeU32(11, m_log2Decim);
s.writeS32(12, (int) m_fcPos); s.writeS32(12, (int) m_fcPosRx);
s.writeS32(13, m_rxBandwidth); s.writeS32(13, m_rxBandwidth);
s.writeS32(14, m_rx0GainMode); s.writeS32(14, m_rx0GainMode);
s.writeS32(15, m_rx0GlobalGain); s.writeS32(15, m_rx0GlobalGain);
@ -88,6 +89,7 @@ QByteArray BladeRF2MIMOSettings::serialize() const
s.writeBool(35, m_txBiasTee); s.writeBool(35, m_txBiasTee);
s.writeBool(36, m_txTransverterMode); s.writeBool(36, m_txTransverterMode);
s.writeS64(37, m_txTransverterDeltaFrequency); s.writeS64(37, m_txTransverterDeltaFrequency);
s.writeS32(38, (int) m_fcPosTx);
s.writeString(50, m_fileRecordName); s.writeString(50, m_fileRecordName);
s.writeBool(51, m_useReverseAPI); s.writeBool(51, m_useReverseAPI);
@ -118,8 +120,8 @@ bool BladeRF2MIMOSettings::deserialize(const QByteArray& data)
d.readU64(10, &m_rxCenterFrequency, 435000*1000); d.readU64(10, &m_rxCenterFrequency, 435000*1000);
d.readU32(11, &m_log2Decim); d.readU32(11, &m_log2Decim);
d.readS32(12, &intval); d.readS32(12, &intval, 0);
m_fcPos = (fcPos_t) intval; m_fcPosRx = (fcPos_t) intval;
d.readS32(13, &m_rxBandwidth); d.readS32(13, &m_rxBandwidth);
d.readS32(14, &m_rx0GainMode); d.readS32(14, &m_rx0GainMode);
d.readS32(15, &m_rx0GlobalGain); d.readS32(15, &m_rx0GlobalGain);
@ -139,6 +141,8 @@ bool BladeRF2MIMOSettings::deserialize(const QByteArray& data)
d.readBool(35, &m_txBiasTee); d.readBool(35, &m_txBiasTee);
d.readBool(36, &m_txTransverterMode, false); d.readBool(36, &m_txTransverterMode, false);
d.readS64(37, &m_txTransverterDeltaFrequency, 0); d.readS64(37, &m_txTransverterDeltaFrequency, 0);
d.readS32(38, &intval, 2);
m_fcPosTx = (fcPos_t) intval;
d.readString(50, &m_fileRecordName, ""); d.readString(50, &m_fileRecordName, "");
d.readBool(51, &m_useReverseAPI, false); d.readBool(51, &m_useReverseAPI, false);

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

@ -33,7 +33,7 @@ struct BladeRF2MIMOSettings {
quint64 m_rxCenterFrequency; quint64 m_rxCenterFrequency;
quint32 m_log2Decim; quint32 m_log2Decim;
fcPos_t m_fcPos; fcPos_t m_fcPosRx;
qint32 m_rxBandwidth; qint32 m_rxBandwidth;
int m_rx0GainMode; int m_rx0GainMode;
int m_rx0GlobalGain; int m_rx0GlobalGain;
@ -47,6 +47,7 @@ struct BladeRF2MIMOSettings {
quint64 m_txCenterFrequency; quint64 m_txCenterFrequency;
quint32 m_log2Interp; quint32 m_log2Interp;
fcPos_t m_fcPosTx;
qint32 m_txBandwidth; qint32 m_txBandwidth;
int m_tx0GlobalGain; int m_tx0GlobalGain;
int m_tx1GlobalGain; int m_tx1GlobalGain;

152
plugins/samplemimo/bladerf2mimo/bladerf2mothread.cpp
View File

@ -16,7 +16,7 @@
/////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////
#include "bladerf2/devicebladerf2shared.h" #include "bladerf2/devicebladerf2shared.h"
#include "dsp/samplesourcefifo.h" #include "dsp/samplemofifo.h"
#include "bladerf2mothread.h" #include "bladerf2mothread.h"
@ -106,31 +106,30 @@ unsigned int BladeRF2MOThread::getLog2Interpolation() const
return m_log2Interp; return m_log2Interp;
} }
void BladeRF2MOThread::setFifo(unsigned int channel, SampleSourceFifo *sampleFifo) void BladeRF2MOThread::setFcPos(int fcPos)
{ {
if (channel < 2) { m_fcPos = fcPos;
m_sampleFifo[channel] = sampleFifo;
}
} }
SampleSourceFifo *BladeRF2MOThread::getFifo(unsigned int channel) int BladeRF2MOThread::getFcPos() const
{ {
if (channel < 2) { return m_fcPos;
return m_sampleFifo[channel];
} else {
return nullptr;
}
} }
void BladeRF2MOThread::callback(qint16* buf, qint32 samplesPerChannel) void BladeRF2MOThread::callback(qint16* buf, qint32 samplesPerChannel)
{ {
for (unsigned int channel = 0; channel < 2; channel++) unsigned int iPart1Begin, iPart1End, iPart2Begin, iPart2End;
m_sampleFifo->readSync(samplesPerChannel, iPart1Begin, iPart1End, iPart2Begin, iPart2End);
if (iPart1Begin != iPart1End)
{ {
if (m_sampleFifo[channel]) { callbackPart(buf, samplesPerChannel, iPart1Begin, iPart1End - iPart1Begin);
channelCallback(&buf[2*samplesPerChannel*channel], samplesPerChannel, channel); }
} else {
std::fill(&buf[2*samplesPerChannel*channel], &buf[2*samplesPerChannel*channel]+2*samplesPerChannel, 0); // fill with zero samples if (iPart2Begin != iPart2End)
} {
unsigned int part1Size = iPart1End - iPart1End;
callbackPart(buf + 2*part1Size, samplesPerChannel, iPart2Begin, iPart2End - iPart2Begin);
} }
int status = bladerf_interleave_stream_buffer(BLADERF_TX_X2, BLADERF_FORMAT_SC16_Q11 , samplesPerChannel*2, (void *) buf); int status = bladerf_interleave_stream_buffer(BLADERF_TX_X2, BLADERF_FORMAT_SC16_Q11 , samplesPerChannel*2, (void *) buf);
@ -143,55 +142,96 @@ void BladeRF2MOThread::callback(qint16* buf, qint32 samplesPerChannel)
} }
// Interpolate according to specified log2 (ex: log2=4 => decim=16). len is a number of samples (not a number of I or Q) // Interpolate according to specified log2 (ex: log2=4 => decim=16). len is a number of samples (not a number of I or Q)
void BladeRF2MOThread::channelCallback(qint16* buf, qint32 len, unsigned int channel) void BladeRF2MOThread::callbackPart(qint16* buf, qint32 samplesPerChannel, int iBegin, qint32 nSamples)
{ {
if (m_sampleFifo[channel]) for (unsigned int channel = 0; channel < 2; channel++)
{ {
float bal = m_sampleFifo[channel]->getRWBalance(); SampleVector::iterator begin = m_sampleFifo->getData(channel).begin() + iBegin;
if (bal < -0.25) {
qDebug("BladeRF2MOThread::channelCallback: read lags: %f", bal);
} else if (bal > 0.25) {
qDebug("BladeRF2MOThread::channelCallback: read leads: %f", bal);
}
SampleVector::iterator beginRead;
m_sampleFifo[channel]->readAdvance(beginRead, len/(1<<m_log2Interp));
beginRead -= len;
if (m_log2Interp == 0) if (m_log2Interp == 0)
{ {
m_interpolators[channel].interpolate1(&beginRead, buf, len*2); m_interpolators[channel].interpolate1(&begin, &buf[channel*2*samplesPerChannel], nSamples*2);
} }
else else
{ {
switch (m_log2Interp) if (m_fcPos == 0) // Infra
{ {
case 1: switch (m_log2Interp)
m_interpolators[channel].interpolate2_cen(&beginRead, buf, len*2); {
break; case 1:
case 2: m_interpolators[channel].interpolate2_inf(&begin, &buf[channel*2*samplesPerChannel], nSamples*2);
m_interpolators[channel].interpolate4_cen(&beginRead, buf, len*2); break;
break; case 2:
case 3: m_interpolators[channel].interpolate4_inf(&begin, &buf[channel*2*samplesPerChannel], nSamples*2);
m_interpolators[channel].interpolate8_cen(&beginRead, buf, len*2); break;
break; case 3:
case 4: m_interpolators[channel].interpolate8_inf(&begin, &buf[channel*2*samplesPerChannel], nSamples*2);
m_interpolators[channel].interpolate16_cen(&beginRead, buf, len*2); break;
break; case 4:
case 5: m_interpolators[channel].interpolate16_inf(&begin, &buf[channel*2*samplesPerChannel], nSamples*2);
m_interpolators[channel].interpolate32_cen(&beginRead, buf, len*2); break;
break; case 5:
case 6: m_interpolators[channel].interpolate32_inf(&begin, &buf[channel*2*samplesPerChannel], nSamples*2);
m_interpolators[channel].interpolate64_cen(&beginRead, buf, len*2); break;
break; case 6:
default: m_interpolators[channel].interpolate64_inf(&begin, &buf[channel*2*samplesPerChannel], nSamples*2);
break; break;
default:
break;
}
}
else if (m_fcPos == 1) // Supra
{
switch (m_log2Interp)
{
case 1:
m_interpolators[channel].interpolate2_sup(&begin, &buf[channel*2*samplesPerChannel], nSamples*2);
break;
case 2:
m_interpolators[channel].interpolate4_sup(&begin, &buf[channel*2*samplesPerChannel], nSamples*2);
break;
case 3:
m_interpolators[channel].interpolate8_sup(&begin, &buf[channel*2*samplesPerChannel], nSamples*2);
break;
case 4:
m_interpolators[channel].interpolate16_sup(&begin, &buf[channel*2*samplesPerChannel], nSamples*2);
break;
case 5:
m_interpolators[channel].interpolate32_sup(&begin, &buf[channel*2*samplesPerChannel], nSamples*2);
break;
case 6:
m_interpolators[channel].interpolate64_sup(&begin, &buf[channel*2*samplesPerChannel], nSamples*2);
break;
default:
break;
}
}
else if (m_fcPos == 2) // Center
{
switch (m_log2Interp)
{
case 1:
m_interpolators[channel].interpolate2_cen(&begin, &buf[channel*2*samplesPerChannel], nSamples*2);
break;
case 2:
m_interpolators[channel].interpolate4_cen(&begin, &buf[channel*2*samplesPerChannel], nSamples*2);
break;
case 3:
m_interpolators[channel].interpolate8_cen(&begin, &buf[channel*2*samplesPerChannel], nSamples*2);
break;
case 4:
m_interpolators[channel].interpolate16_cen(&begin, &buf[channel*2*samplesPerChannel], nSamples*2);
break;
case 5:
m_interpolators[channel].interpolate32_cen(&begin, &buf[channel*2*samplesPerChannel], nSamples*2);
break;
case 6:
m_interpolators[channel].interpolate64_cen(&begin, &buf[channel*2*samplesPerChannel], nSamples*2);
break;
default:
break;
}
} }
} }
} }
else
{
std::fill(buf, buf+2*len, 0);
}
} }

13
plugins/samplemimo/bladerf2mimo/bladerf2mothread.h
View File

@ -25,7 +25,7 @@
#include "dsp/interpolators.h" #include "dsp/interpolators.h"
class SampleSourceFifo; class SampleMOFifo;
class BladeRF2MOThread : public QThread { class BladeRF2MOThread : public QThread {
Q_OBJECT Q_OBJECT
@ -39,8 +39,10 @@ public:
bool isRunning() const { return m_running; } bool isRunning() const { return m_running; }
void setLog2Interpolation(unsigned int log2_interp); void setLog2Interpolation(unsigned int log2_interp);
unsigned int getLog2Interpolation() const; unsigned int getLog2Interpolation() const;
void setFifo(unsigned int channel, SampleSourceFifo *sampleFifo); void setFcPos(int fcPos);
SampleSourceFifo *getFifo(unsigned int channel); int getFcPos() const;
void setFifo(SampleMOFifo *sampleFifo) { m_sampleFifo = sampleFifo; }
SampleMOFifo *getFifo() { return m_sampleFifo; }
private: private:
QMutex m_startWaitMutex; QMutex m_startWaitMutex;
@ -49,13 +51,14 @@ private:
struct bladerf* m_dev; struct bladerf* m_dev;
qint16 *m_buf; //!< Full buffer for SISO or MIMO operation qint16 *m_buf; //!< Full buffer for SISO or MIMO operation
SampleSourceFifo* m_sampleFifo[2]; SampleMOFifo* m_sampleFifo;
Interpolators<qint16, SDR_TX_SAMP_SZ, 12> m_interpolators[2]; Interpolators<qint16, SDR_TX_SAMP_SZ, 12> m_interpolators[2];
unsigned int m_log2Interp; unsigned int m_log2Interp;
int m_fcPos;
void run(); void run();
unsigned int getNbFifos(); unsigned int getNbFifos();
void channelCallback(qint16* buf, qint32 len, unsigned int channel = 0); void callbackPart(qint16* buf, qint32 samplesPerChannel, int iBegin, qint32 nSamples);
void callback(qint16* buf, qint32 samplesPerChannel); void callback(qint16* buf, qint32 samplesPerChannel);
}; };