SDRAngel  4.11.5
Developer docs for <a href="https://github.com/f4exb/sdrangel">SDRangel<\a>, an Open Source Qt5 / OpenGL 3.0+ SDR and signal analyzer frontend to various hardware.
xtrxinputgui.cpp
Go to the documentation of this file.
1 // Copyright (C) 2017, 2018 Edouard Griffiths, F4EXB //
3 // Copyright (C) 2017 Sergey Kostanbaev, Fairwaves Inc. //
4 // //
5 // This program is free software; you can redistribute it and/or modify //
6 // it under the terms of the GNU General Public License as published by //
7 // the Free Software Foundation as version 3 of the License, or //
8 // (at your option) any later version. //
9 // //
10 // This program is distributed in the hope that it will be useful, //
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of //
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
13 // GNU General Public License V3 for more details. //
14 // //
15 // You should have received a copy of the GNU General Public License //
16 // along with this program. If not, see <http://www.gnu.org/licenses/>. //
18 
19 #include "xtrxinputgui.h"
20 
21 #include <QDebug>
22 #include <QMessageBox>
23 
24 #include <algorithm>
25 
26 #include "ui_xtrxinputgui.h"
27 #include "gui/colormapper.h"
28 #include "gui/glspectrum.h"
29 #include "gui/crightclickenabler.h"
31 #include "dsp/dspengine.h"
32 #include "dsp/dspcommands.h"
33 #include "device/deviceapi.h"
34 #include "device/deviceuiset.h"
35 
36 XTRXInputGUI::XTRXInputGUI(DeviceUISet *deviceUISet, QWidget* parent) :
37  QWidget(parent),
38  ui(new Ui::XTRXInputGUI),
39  m_deviceUISet(deviceUISet),
40  m_settings(),
41  m_sampleRateMode(true),
42  m_sampleRate(0),
43  m_lastEngineState(DeviceAPI::StNotStarted),
44  m_doApplySettings(true),
45  m_forceSettings(true),
46  m_statusCounter(0),
47  m_deviceStatusCounter(0)
48 {
50 
51  ui->setupUi(this);
52 
53  float minF, maxF, stepF;
54 
55  m_XTRXInput->getLORange(minF, maxF, stepF);
56  ui->centerFrequency->setColorMapper(ColorMapper(ColorMapper::GrayGold));
57  ui->centerFrequency->setValueRange(7, ((uint32_t) minF)/1000, ((uint32_t) maxF)/1000); // frequency dial is in kHz
58 
59  m_XTRXInput->getSRRange(minF, maxF, stepF);
60  ui->sampleRate->setColorMapper(ColorMapper(ColorMapper::GrayGreenYellow));
61  ui->sampleRate->setValueRange(8, (uint32_t) minF, (uint32_t) maxF);
62 
63  m_XTRXInput->getLPRange(minF, maxF, stepF);
64  ui->lpf->setColorMapper(ColorMapper(ColorMapper::GrayYellow));
65  ui->lpf->setValueRange(6, (minF/1000)+1, maxF/1000);
66 
67  ui->ncoFrequency->setColorMapper(ColorMapper(ColorMapper::GrayGold));
68 
69  ui->channelNumberText->setText(tr("#%1").arg(m_XTRXInput->getChannelIndex()));
70 
71  connect(&m_updateTimer, SIGNAL(timeout()), this, SLOT(updateHardware()));
72  connect(&m_statusTimer, SIGNAL(timeout()), this, SLOT(updateStatus()));
73  m_statusTimer.start(500);
74 
75  CRightClickEnabler *startStopRightClickEnabler = new CRightClickEnabler(ui->startStop);
76  connect(startStopRightClickEnabler, SIGNAL(rightClick(const QPoint &)), this, SLOT(openDeviceSettingsDialog(const QPoint &)));
77 
79 
80  connect(&m_inputMessageQueue, SIGNAL(messageEnqueued()), this, SLOT(handleInputMessages()), Qt::QueuedConnection);
81 }
82 
84 {
85  delete ui;
86 }
87 
89 {
90  delete this;
91 }
92 
93 void XTRXInputGUI::setName(const QString& name)
94 {
95  setObjectName(name);
96 }
97 
98 QString XTRXInputGUI::getName() const
99 {
100  return objectName();
101 }
102 
104 {
106  displaySettings();
107  sendSettings();
108 }
109 
111 {
113 }
114 
115 void XTRXInputGUI::setCenterFrequency(qint64 centerFrequency)
116 {
118  displaySettings();
119  sendSettings();
120 }
121 
122 QByteArray XTRXInputGUI::serialize() const
123 {
124  return m_settings.serialize();
125 }
126 
127 bool XTRXInputGUI::deserialize(const QByteArray& data)
128 {
129  if (m_settings.deserialize(data))
130  {
131  displaySettings();
132  m_forceSettings = true;
133  sendSettings();
134  return true;
135  }
136  else
137  {
138  resetToDefaults();
139  return false;
140  }
141 }
142 
144 {
145 
147  {
151 
152  if (report.getRxElseTx()) {
154  }
155 
156  blockApplySettings(true);
157  displaySettings();
158  blockApplySettings(false);
159 
160  return true;
161  }
163  {
166  m_settings.m_extClock = report.getExtClock();
167 
168  blockApplySettings(true);
169  ui->extClock->setExternalClockFrequency(m_settings.m_extClockFreq);
170  ui->extClock->setExternalClockActive(m_settings.m_extClock);
171  blockApplySettings(false);
172 
173  return true;
174  }
176  {
178 
179  blockApplySettings(true);
180  displaySettings();
181  blockApplySettings(false);
182 
183  return true;
184  }
185  else if (XTRXInput::MsgReportStreamInfo::match(message))
186  {
188 
189  if (report.getSuccess())
190  {
191  if (report.getActive()) {
192  ui->streamStatusLabel->setStyleSheet("QLabel { background-color : green; }");
193  } else {
194  ui->streamStatusLabel->setStyleSheet("QLabel { background-color : blue; }");
195  }
196 
197  ui->fifoBar->setMaximum(report.getFifoSize());
198  ui->fifoBar->setValue(report.getFifoFilledCount());
199  ui->fifoBar->setToolTip(tr("FIFO fill %1/%2 samples").arg(QString::number(report.getFifoFilledCount())).arg(QString::number(report.getFifoSize())));
200  }
201  else
202  {
203  ui->streamStatusLabel->setStyleSheet("QLabel { background:rgb(79,79,79); }");
204  }
205 
206  return true;
207  }
209  {
211  ui->temperatureText->setText(tr("%1C").arg(QString::number(report.getTemperature(), 'f', 0)));
212 
213  if (report.getGPSLocked()) {
214  ui->gpsStatusLabel->setStyleSheet("QLabel { background-color : green; }");
215  } else {
216  ui->gpsStatusLabel->setStyleSheet("QLabel { background:rgb(48,48,48); }");
217  }
218 
219  return true;
220  }
221  else if (XTRXInput::MsgStartStop::match(message))
222  {
224  blockApplySettings(true);
225  ui->startStop->setChecked(notif.getStartStop());
226  blockApplySettings(false);
227 
228  return true;
229  }
230  return false;
231 }
232 
234 {
235  Message* message;
236 
237  while ((message = m_inputMessageQueue.pop()) != 0)
238  {
239  if (DSPSignalNotification::match(*message))
240  {
241  DSPSignalNotification* notif = (DSPSignalNotification*) message;
242  m_sampleRate = notif->getSampleRate();
244  qDebug("XTRXInputGUI::handleInputMessages: DSPSignalNotification: SampleRate: %d, CenterFrequency: %llu", notif->getSampleRate(), notif->getCenterFrequency());
246 
247  delete message;
248  }
249  else if (XTRXInput::MsgConfigureXTRX::match(*message))
250  {
251  qDebug("XTRXInputGUI::handleInputMessages: MsgConfigureXTRX");
253  m_settings = cfg.getSettings();
254  displaySettings();
255 
256  delete message;
257  }
258  else
259  {
260  if (handleMessage(*message)) {
261  delete message;
262  }
263  }
264  }
265 }
266 
268 {
269  uint32_t adcRate = m_XTRXInput->getClockGen() / 4;
270 
271  if (adcRate < 100000000) {
272  ui->adcRateLabel->setText(tr("%1k").arg(QString::number(adcRate / 1000.0f, 'g', 5)));
273  } else {
274  ui->adcRateLabel->setText(tr("%1M").arg(QString::number(adcRate / 1000000.0f, 'g', 5)));
275  }
276 }
277 
279 {
283 }
284 
286 {
287  float minF, maxF, stepF;
288  m_XTRXInput->getSRRange(minF, maxF, stepF);
289 
290  ui->sampleRate->blockSignals(true);
291 
292  if (m_sampleRateMode)
293  {
294  ui->sampleRateMode->setStyleSheet("QToolButton { background:rgb(60,60,60); }");
295  ui->sampleRateMode->setText("SR");
296  ui->sampleRate->setValueRange(8, (uint32_t) minF, (uint32_t) maxF);
297  ui->sampleRate->setValue(m_settings.m_devSampleRate);
298  ui->sampleRate->setToolTip("Device to host sample rate (S/s)");
299  ui->deviceRateText->setToolTip("Baseband sample rate (S/s)");
301  ui->deviceRateText->setText(tr("%1k").arg(QString::number(basebandSampleRate / 1000.0f, 'g', 5)));
302  }
303  else
304  {
305  ui->sampleRateMode->setStyleSheet("QToolButton { background:rgb(50,50,50); }");
306  ui->sampleRateMode->setText("BB");
307  ui->sampleRate->setValueRange(8, (uint32_t) minF/(1<<m_settings.m_log2SoftDecim), (uint32_t) maxF/(1<<m_settings.m_log2SoftDecim));
308  ui->sampleRate->setValue(m_settings.m_devSampleRate/(1<<m_settings.m_log2SoftDecim));
309  ui->sampleRate->setToolTip("Baseband sample rate (S/s)");
310  ui->deviceRateText->setToolTip("Device to host sample rate (S/s)");
311  ui->deviceRateText->setText(tr("%1k").arg(QString::number(m_settings.m_devSampleRate / 1000.0f, 'g', 5)));
312  }
313 
314  ui->sampleRate->blockSignals(false);
315 }
316 
318 {
319  ui->extClock->setExternalClockFrequency(m_settings.m_extClockFreq);
320  ui->extClock->setExternalClockActive(m_settings.m_extClock);
321 
324 
325  ui->dcOffset->setChecked(m_settings.m_dcBlock);
326  ui->iqImbalance->setChecked(m_settings.m_iqCorrection);
327 
328  ui->hwDecim->setCurrentIndex(m_settings.m_log2HardDecim);
329  ui->swDecim->setCurrentIndex(m_settings.m_log2SoftDecim);
330 
331  updateADCRate();
332 
333  ui->lpf->setValue(m_settings.m_lpfBW / 1000);
334  ui->pwrmode->setCurrentIndex(m_settings.m_pwrmode);
335 
336  ui->gain->setValue(m_settings.m_gain);
337  ui->gainText->setText(tr("%1").arg(m_settings.m_gain));
338 
339  ui->antenna->setCurrentIndex((int) m_settings.m_antennaPath);
340 
341  ui->gainMode->setCurrentIndex((int) m_settings.m_gainMode);
342  ui->lnaGain->setValue(m_settings.m_lnaGain);
343  ui->tiaGain->setCurrentIndex(m_settings.m_tiaGain - 1);
344  ui->pgaGain->setValue(m_settings.m_pgaGain);
345 
347  {
348  ui->gain->setEnabled(true);
349  ui->lnaGain->setEnabled(false);
350  ui->tiaGain->setEnabled(false);
351  ui->pgaGain->setEnabled(false);
352  }
353  else
354  {
355  ui->gain->setEnabled(false);
356  ui->lnaGain->setEnabled(true);
357  ui->tiaGain->setEnabled(true);
358  ui->pgaGain->setEnabled(true);
359  }
360 
361  setNCODisplay();
362 
363  ui->ncoEnable->setChecked(m_settings.m_ncoEnable);
364 }
365 
367 {
368  int ncoHalfRange = (m_settings.m_devSampleRate * (1<<(m_settings.m_log2HardDecim)))/2;
369  ui->ncoFrequency->setValueRange(
370  false,
371  8,
372  -ncoHalfRange,
373  ncoHalfRange);
374 
375  ui->ncoFrequency->blockSignals(true);
376  ui->ncoFrequency->setToolTip(QString("NCO frequency shift in Hz (Range: +/- %1 kHz)").arg(ncoHalfRange/1000));
377  ui->ncoFrequency->setValue(m_settings.m_ncoFrequency);
378  ui->ncoFrequency->blockSignals(false);
379 }
380 
382 {
383  int64_t centerFrequency = m_settings.m_centerFrequency;
384  ui->centerFrequency->setToolTip(QString("Main center frequency in kHz (LO: %1 kHz)").arg(centerFrequency/1000));
385 
386  if (m_settings.m_ncoEnable) {
387  centerFrequency += m_settings.m_ncoFrequency;
388  }
389 
390  ui->centerFrequency->blockSignals(true);
391  ui->centerFrequency->setValue(centerFrequency < 0 ? 0 : (uint64_t) centerFrequency/1000); // kHz
392  ui->centerFrequency->blockSignals(false);
393 }
394 
396 {
397  int64_t centerFrequency = kHzValue*1000;
398 
399  if (m_settings.m_ncoEnable) {
400  centerFrequency -= m_settings.m_ncoFrequency;
401  }
402 
403  m_settings.m_centerFrequency = centerFrequency < 0 ? 0 : (uint64_t) centerFrequency;
404  ui->centerFrequency->setToolTip(QString("Main center frequency in kHz (LO: %1 kHz)").arg(centerFrequency/1000));
405 }
406 
408 {
409  if(!m_updateTimer.isActive())
410  m_updateTimer.start(100);
411 }
412 
414 {
415  if (m_doApplySettings)
416  {
417  qDebug() << "XTRXInputGUI::updateHardware";
420  m_forceSettings = false;
421  m_updateTimer.stop();
422  }
423 }
424 
426 {
427  int state = m_deviceUISet->m_deviceAPI->state();
428 
429  if(m_lastEngineState != state)
430  {
431  switch(state)
432  {
434  ui->startStop->setStyleSheet("QToolButton { background:rgb(79,79,79); }");
435  break;
436  case DeviceAPI::StIdle:
437  ui->startStop->setStyleSheet("QToolButton { background-color : blue; }");
438  break;
440  ui->startStop->setStyleSheet("QToolButton { background-color : green; }");
441  break;
442  case DeviceAPI::StError:
443  ui->startStop->setStyleSheet("QToolButton { background-color : red; }");
444  QMessageBox::information(this, tr("Message"), m_deviceUISet->m_deviceAPI->errorMessage());
445  break;
446  default:
447  break;
448  }
449 
450  m_lastEngineState = state;
451  }
452 
453  if (m_statusCounter < 1)
454  {
455  m_statusCounter++;
456  }
457  else
458  {
461  m_statusCounter = 0;
462  }
463 
464  if (m_deviceStatusCounter < 10)
465  {
467  }
468  else
469  {
471  {
474  }
475 
477  }
478 }
479 
481 {
482  m_doApplySettings = !block;
483 }
484 
486 {
487  if (m_doApplySettings)
488  {
491  }
492 }
493 
495 {
496  if (checked) {
497  ui->record->setStyleSheet("QToolButton { background-color : red; }");
498  } else {
499  ui->record->setStyleSheet("QToolButton { background:rgb(79,79,79); }");
500  }
501 
504 }
505 
507 {
509  sendSettings();
510 }
511 
513 {
514  m_settings.m_ncoFrequency = value;
516  sendSettings();
517 }
518 
520 {
521  m_settings.m_ncoEnable = checked;
523  sendSettings();
524 }
525 
527 {
528  m_settings.m_dcBlock = checked;
529  sendSettings();
530 }
531 
533 {
534  m_settings.m_iqCorrection = checked;
535  sendSettings();
536 }
537 
539 {
540  if (m_sampleRateMode) {
541  m_settings.m_devSampleRate = value;
542  } else {
544  }
545 
546  updateADCRate();
547  setNCODisplay();
548  sendSettings();}
549 
551 {
552  if ((index <0) || (index > 5))
553  return;
554  m_settings.m_log2HardDecim = index;
556 
557  if (m_sampleRateMode) {
558  m_settings.m_devSampleRate = ui->sampleRate->getValueNew();
559  } else {
560  m_settings.m_devSampleRate = ui->sampleRate->getValueNew() * (1 << m_settings.m_log2SoftDecim);
561  }
562 
563  updateADCRate();
564  setNCODisplay();
565  sendSettings();
566 }
567 
569 {
570  if ((index <0) || (index > 6)) {
571  return;
572  }
573 
574  m_settings.m_log2SoftDecim = index;
575  sendSettings();
576 }
577 
578 void XTRXInputGUI::on_lpf_changed(quint64 value)
579 {
580  m_settings.m_lpfBW = value * 1000;
581  sendSettings();
582 }
583 
585 {
587 
588  if (index == 0)
589  {
590  ui->gain->setEnabled(true);
591  ui->lnaGain->setEnabled(false);
592  ui->tiaGain->setEnabled(false);
593  ui->pgaGain->setEnabled(false);
594  }
595  else
596  {
597  ui->gain->setEnabled(false);
598  ui->lnaGain->setEnabled(true);
599  ui->tiaGain->setEnabled(true);
600  ui->pgaGain->setEnabled(true);
601  }
602 
603  sendSettings();
604 }
605 
607 {
608  m_settings.m_gain = value;
609  ui->gainText->setText(tr("%1").arg(m_settings.m_gain));
610  sendSettings();
611 }
612 
614 {
615  m_settings.m_lnaGain = value;
616  ui->lnaGainText->setText(tr("%1").arg(m_settings.m_lnaGain));
617  sendSettings();
618 }
619 
621 {
622  m_settings.m_tiaGain = index + 1;
623  sendSettings();
624 }
625 
627 {
628  m_settings.m_pgaGain = value;
629  ui->pgaGainText->setText(tr("%1").arg(m_settings.m_pgaGain));
630  sendSettings();
631 }
632 
634 {
635  m_settings.m_antennaPath = (xtrx_antenna_t) index;
636  sendSettings();
637 }
638 
640 {
641  m_settings.m_extClock = ui->extClock->getExternalClockActive();
642  m_settings.m_extClockFreq = ui->extClock->getExternalClockFrequency();
643  qDebug("XTRXInputGUI::on_extClock_clicked: %u Hz %s", m_settings.m_extClockFreq, m_settings.m_extClock ? "on" : "off");
644  sendSettings();
645 }
646 
648 {
649  m_settings.m_pwrmode = index;
650  sendSettings();
651 }
652 
654 {
655  m_sampleRateMode = checked;
657 }
658 
660 {
661  BasicDeviceSettingsDialog dialog(this);
666 
667  dialog.move(p);
668  dialog.exec();
669 
674 
675  sendSettings();
676 }
QByteArray serialize() const
virtual ~XTRXInputGUI()
void on_centerFrequency_changed(quint64 value)
void on_startStop_toggled(bool checked)
bool m_extClock
True if external clock source.
Message * pop()
Pop message from queue.
const QString & getReverseAPIAddress() const
void resetToDefaults()
bool m_ncoEnable
Enable TSP NCO and mixing.
void push(Message *message, bool emitSignal=true)
Push message onto queue.
void setSampleRate(qint32 sampleRate)
Definition: glspectrum.cpp:211
void updateSampleRateAndFrequency()
void on_record_toggled(bool checked)
QTimer m_statusTimer
Definition: xtrxinputgui.h:63
bool isBuddyLeader() const
Definition: deviceapi.h:163
DeviceSampleSource * getSampleSource()
Return pointer to the device sample source (single Rx) or nullptr.
Definition: deviceapi.cpp:213
void setUseReverseAPI(bool useReverseAPI)
void getLORange(float &minF, float &maxF, float &stepF) const
Definition: xtrxinput.cpp:576
void handleInputMessages()
MessageQueue * getInputMessageQueue()
void on_dcOffset_toggled(bool checked)
void getLPRange(float &minF, float &maxF, float &stepF) const
Definition: xtrxinput.cpp:594
static MsgConfigureXTRX * create(const XTRXInputSettings &settings, bool force)
Definition: xtrxinput.h:49
virtual void destroy()
bool getStartStop() const
Definition: xtrxinput.h:159
void updateADCRate()
MessageQueue m_inputMessageQueue
Definition: xtrxinputgui.h:71
void on_ncoEnable_toggled(bool checked)
bool deserialize(const QByteArray &data)
static MsgGetStreamInfo * create()
Definition: xtrxinput.h:69
void on_swDecim_currentIndexChanged(int index)
void on_gainMode_currentIndexChanged(int index)
QTimer m_updateTimer
Definition: xtrxinputgui.h:62
void on_ncoFrequency_changed(qint64 value)
int m_ncoFrequency
Actual NCO frequency (the resulting frequency with mixing is displayed)
void setCenterFrequencySetting(uint64_t kHzValue)
QString errorMessage()
Last error message from the device engine.
Definition: deviceapi.cpp:290
double getClockGen() const
Definition: xtrxinput.cpp:542
void setNCODisplay()
__int64 int64_t
Definition: rtptypes_win.h:47
XTRXInput * m_XTRXInput
Same object as above but gives easy access to XTRXInput methods and attributes that are used intensiv...
Definition: xtrxinputgui.h:59
XTRXInputSettings m_settings
Definition: xtrxinputgui.h:60
unsigned int uint32_t
Definition: rtptypes_win.h:46
Fixed< IntType, IntBits > arg(const std::complex< Fixed< IntType, IntBits > > &val)
Definition: fixed.h:2401
void on_extClock_clicked()
GLSpectrum * getSpectrum()
Direct spectrum getter.
Definition: deviceuiset.h:57
uint16_t m_reverseAPIDeviceIndex
engine is before initialization
Definition: deviceapi.h:53
qint64 getCenterFrequency() const
Definition: dspcommands.h:329
EngineState state() const
Return the state of the device engine corresponding to the stream type.
Definition: deviceapi.cpp:277
void on_antenna_currentIndexChanged(int index)
uint32_t getFifoSize() const
Definition: xtrxinput.h:117
DeviceAPI * m_deviceAPI
Definition: deviceuiset.h:48
engine is idle
Definition: deviceapi.h:54
GainMode m_gainMode
Gain mode: auto or manual.
float m_lpfBW
LMS analog lowpass filter bandwidth (Hz)
bool m_doApplySettings
Definition: xtrxinputgui.h:67
uint32_t m_gain
Optimally distributed gain (dB)
DeviceUISet * m_deviceUISet
Definition: xtrxinputgui.h:58
bool m_forceSettings
Definition: xtrxinputgui.h:68
uint32_t m_extClockFreq
Frequency (Hz) of external clock source.
void updateHardware()
int m_lastEngineState
Definition: xtrxinputgui.h:66
QByteArray serialize() const
static bool match(const Message *message)
Definition: message.cpp:45
void on_hwDecim_currentIndexChanged(int index)
void on_tiaGain_currentIndexChanged(int index)
static MsgFileRecord * create(bool startStop)
Definition: xtrxinput.h:180
static MsgGetDeviceInfo * create()
Definition: xtrxinput.h:84
void blockApplySettings(bool block)
const XTRXInputSettings & getSettings() const
Definition: xtrxinput.h:46
void updateStatus()
uint32_t m_tiaGain
Manual TIA gain.
void sendSettings()
void setName(const QString &name)
virtual qint64 getCenterFrequency() const
void on_lnaGain_valueChanged(int value)
quint64 m_deviceCenterFrequency
Center frequency in device.
Definition: xtrxinputgui.h:65
void on_iqImbalance_toggled(bool checked)
void openDeviceSettingsDialog(const QPoint &p)
int m_statusCounter
Definition: xtrxinputgui.h:69
void displaySettings()
int getSampleRate() const
Definition: dspcommands.h:328
uint32_t m_lnaGain
Manual LNA gain.
void getSRRange(float &minF, float &maxF, float &stepF) const
Definition: xtrxinput.cpp:585
std::size_t getChannelIndex()
Definition: xtrxinput.cpp:571
void setCenterFrequency(qint64 frequency)
Definition: glspectrum.cpp:175
static MsgStartStop * create(bool startStop)
Definition: xtrxinput.h:161
void on_sampleRateMode_toggled(bool checked)
void setReverseAPIAddress(const QString &address)
QString getName() const
void setReverseAPIDeviceIndex(uint16_t deviceIndex)
engine is running
Definition: deviceapi.h:56
int m_deviceStatusCounter
Definition: xtrxinputgui.h:70
void on_pwrmode_currentIndexChanged(int index)
bool deserialize(const QByteArray &data)
Ui::XTRXInputGUI * ui
Definition: xtrxinputgui.h:56
uint32_t getDevSampleRate() const
Definition: xtrxinput.cpp:520
void displaySampleRate()
xtrx_antenna_t m_antennaPath
engine is in error
Definition: deviceapi.h:57
uint32_t m_pgaGain
Manual PGA gain.
void on_pgaGain_valueChanged(int value)
void on_gain_valueChanged(int value)
virtual void setCenterFrequency(qint64 centerFrequency)
virtual bool handleMessage(const Message &message)
void on_lpf_changed(quint64 value)
uint32_t getFifoFilledCount() const
Definition: xtrxinput.h:116
XTRXInputGUI(DeviceUISet *deviceUISet, QWidget *parent=0)
void on_sampleRate_changed(quint64 value)
void setCenterFrequencyDisplay()
bool m_sampleRateMode
true: device, false: base band sample rate update mode
Definition: xtrxinputgui.h:61
unsigned __int64 uint64_t
Definition: rtptypes_win.h:48