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.
testmigui.cpp
Go to the documentation of this file.
1 // Copyright (C) 2019 Edouard Griffiths, F4EXB //
3 // //
4 // This program is free software; you can redistribute it and/or modify //
5 // it under the terms of the GNU General Public License as published by //
6 // the Free Software Foundation as version 3 of the License, or //
7 // (at your option) any later version. //
8 // //
9 // This program is distributed in the hope that it will be useful, //
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of //
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
12 // GNU General Public License V3 for more details. //
13 // //
14 // You should have received a copy of the GNU General Public License //
15 // along with this program. If not, see <http://www.gnu.org/licenses/>. //
17 
18 #include <QDebug>
19 
20 #include <QTime>
21 #include <QDateTime>
22 #include <QString>
23 #include <QMessageBox>
24 
25 #include "plugin/pluginapi.h"
26 #include "device/deviceapi.h"
27 #include "device/deviceuiset.h"
28 #include "gui/colormapper.h"
29 #include "gui/glspectrum.h"
30 #include "gui/crightclickenabler.h"
32 #include "dsp/dspengine.h"
34 #include "dsp/dspcommands.h"
35 #include "util/db.h"
36 
37 #include "mainwindow.h"
38 
39 #include "ui_testmigui.h"
40 #include "testmigui.h"
41 
42 TestMIGui::TestMIGui(DeviceUISet *deviceUISet, QWidget* parent) :
43  QWidget(parent),
44  ui(new Ui::TestMIGui),
45  m_deviceUISet(deviceUISet),
46  m_settings(),
47  m_doApplySettings(true),
48  m_forceSettings(true),
49  m_sampleMIMO(nullptr),
50  m_tickCount(0),
51  m_lastEngineState(DeviceAPI::StNotStarted)
52 {
53  qDebug("TestMIGui::TestMIGui");
55  m_streamIndex = 0;
56  m_deviceCenterFrequencies.push_back(m_settings.m_streams[0].m_centerFrequency);
57  m_deviceCenterFrequencies.push_back(m_settings.m_streams[1].m_centerFrequency);
58  m_deviceSampleRates.push_back(m_settings.m_streams[0].m_sampleRate / (1<<m_settings.m_streams[0].m_log2Decim));
59  m_deviceSampleRates.push_back(m_settings.m_streams[1].m_sampleRate / (1<<m_settings.m_streams[1].m_log2Decim));
60 
61  ui->setupUi(this);
62  ui->spectrumSource->addItem("0");
63  ui->spectrumSource->addItem("1");
64  ui->centerFrequency->setColorMapper(ColorMapper(ColorMapper::GrayGold));
65  ui->centerFrequency->setValueRange(7, 0, 9999999);
66  ui->sampleRate->setColorMapper(ColorMapper(ColorMapper::GrayGreenYellow));
67  ui->sampleRate->setValueRange(7, 48000, 9999999);
68  ui->frequencyShift->setColorMapper(ColorMapper(ColorMapper::GrayGold));
69  ui->frequencyShift->setValueRange(false, 7, -9999999, 9999999);
70  ui->frequencyShiftLabel->setText(QString("%1").arg(QChar(0x94, 0x03)));
71 
73 
74  connect(&m_updateTimer, SIGNAL(timeout()), this, SLOT(updateHardware()));
75  connect(&m_statusTimer, SIGNAL(timeout()), this, SLOT(updateStatus()));
76  m_statusTimer.start(500);
77 
78  connect(&m_inputMessageQueue, SIGNAL(messageEnqueued()), this, SLOT(handleInputMessages()), Qt::QueuedConnection);
80 
81  CRightClickEnabler *startStopRightClickEnabler = new CRightClickEnabler(ui->startStop);
82  connect(startStopRightClickEnabler, SIGNAL(rightClick(const QPoint &)), this, SLOT(openDeviceSettingsDialog(const QPoint &)));
83 }
84 
86 {
87  delete ui;
88 }
89 
91 {
92  delete this;
93 }
94 
95 void TestMIGui::setName(const QString& name)
96 {
97  setObjectName(name);
98 }
99 
100 QString TestMIGui::getName() const
101 {
102  return objectName();
103 }
104 
106 {
108  displaySettings();
109  sendSettings();
110 }
111 
113 {
114  return m_settings.m_streams[m_streamIndex].m_centerFrequency;
115 }
116 
117 void TestMIGui::setCenterFrequency(qint64 centerFrequency)
118 {
119  m_settings.m_streams[m_streamIndex].m_centerFrequency = centerFrequency;
120  displaySettings();
121  sendSettings();
122 }
123 
124 QByteArray TestMIGui::serialize() const
125 {
126  return m_settings.serialize();
127 }
128 
129 bool TestMIGui::deserialize(const QByteArray& data)
130 {
131  if(m_settings.deserialize(data)) {
132  displaySettings();
133  m_forceSettings = true;
134  sendSettings();
135  return true;
136  } else {
137  resetToDefaults();
138  return false;
139  }
140 }
141 
143 {
144  if (m_doApplySettings)
145  {
148  }
149 }
150 
152 {
153  if (ui->streamLock->isChecked())
154  {
155  m_spectrumStreamIndex = index;
158  ui->spectrumSource->blockSignals(true);
159  ui->spectrumSource->setCurrentIndex(index);
160  ui->spectrumSource->blockSignals(false);
161  }
162 
163  m_streamIndex = index;
166  displaySettings();
167 }
168 
170 {
171  m_spectrumStreamIndex = index;
175 
176  if (ui->streamLock->isChecked())
177  {
178  ui->streamIndex->blockSignals(true);
179  ui->streamIndex->setCurrentIndex(index);
180  ui->streamIndex->blockSignals(false);
181  m_streamIndex = index;
183  displaySettings();
184  }
185 }
186 
188 {
189  if (checked && (ui->streamIndex->currentIndex() != ui->spectrumSource->currentIndex())) {
190  ui->spectrumSource->setCurrentIndex(ui->streamIndex->currentIndex());
191  }
192 }
193 
195 {
196  m_settings.m_streams[m_streamIndex].m_centerFrequency = value * 1000;
197  sendSettings();
198 }
199 
201 {
202  if ((index < 0) || (index > TestMIStreamSettings::AutoCorrLast)) {
203  return;
204  }
205 
207  sendSettings();
208 }
209 
211 {
212  m_settings.m_streams[m_streamIndex].m_frequencyShift = value;
213  sendSettings();
214 }
215 
217 {
218  if ((index < 0) || (index > 6)) {
219  return;
220  }
221 
222  m_settings.m_streams[m_streamIndex].m_log2Decim = index;
223  sendSettings();
224 }
225 
227 {
228  if ((index < 0) || (index > 2)) {
229  return;
230  }
231 
233  sendSettings();
234 }
235 
237 {
239  m_settings.m_streams[m_streamIndex].m_frequencyShift = ui->frequencyShift->getValueNew();
240  m_settings.m_streams[m_streamIndex].m_sampleRate = value;
241  sendSettings();
242 }
243 
245 {
246  if ((index < 0) || (index > 2)) {
247  return;
248  }
249 
253  m_settings.m_streams[m_streamIndex].m_amplitudeBits = ui->amplitudeCoarse->value() * 100 + ui->amplitudeFine->value();
254  m_settings.m_streams[m_streamIndex].m_sampleSizeIndex = index;
255  sendSettings();
256 }
257 
259 {
260  (void) value;
263  m_settings.m_streams[m_streamIndex].m_amplitudeBits = ui->amplitudeCoarse->value() * 100 + ui->amplitudeFine->value();
264  sendSettings();
265 }
266 
268 {
269  (void) value;
271  m_settings.m_streams[m_streamIndex].m_amplitudeBits = ui->amplitudeCoarse->value() * 100 + ui->amplitudeFine->value();
272  sendSettings();
273 }
274 
276 {
277  if ((index < 0) || (index > TestMIStreamSettings::ModulationLast)) {
278  return;
279  }
280 
282  sendSettings();
283 }
284 
286 {
287  m_settings.m_streams[m_streamIndex].m_modulationTone = value;
288  ui->modulationFrequencyText->setText(QString("%1").arg(m_settings.m_streams[m_streamIndex].m_modulationTone / 100.0, 0, 'f', 2));
289  sendSettings();
290 }
291 
293 {
294  m_settings.m_streams[m_streamIndex].m_amModulation = value;
295  ui->amModulationText->setText(QString("%1").arg(m_settings.m_streams[m_streamIndex].m_amModulation));
296  sendSettings();
297 }
298 
300 {
301  m_settings.m_streams[m_streamIndex].m_fmDeviation = value;
302  ui->fmDeviationText->setText(QString("%1").arg(m_settings.m_streams[m_streamIndex].m_fmDeviation / 10.0, 0, 'f', 1));
303  sendSettings();
304 }
305 
307 {
308  ui->dcBiasText->setText(QString(tr("%1 %").arg(value)));
309  m_settings.m_streams[m_streamIndex].m_dcFactor = value / 100.0f;
310  sendSettings();
311 }
312 
314 {
315  ui->iBiasText->setText(QString(tr("%1 %").arg(value)));
316  m_settings.m_streams[m_streamIndex].m_iFactor = value / 100.0f;
317  sendSettings();
318 }
319 
321 {
322  ui->qBiasText->setText(QString(tr("%1 %").arg(value)));
323  m_settings.m_streams[m_streamIndex].m_qFactor = value / 100.0f;
324  sendSettings();
325 }
326 
328 {
329  ui->phaseImbalanceText->setText(QString(tr("%1 %").arg(value)));
330  m_settings.m_streams[m_streamIndex].m_phaseImbalance = value / 100.0f;
331  sendSettings();
332 }
333 
335 {
336  if (checked) {
337  ui->record->setStyleSheet("QToolButton { background-color : red; }");
338  } else {
339  ui->record->setStyleSheet("QToolButton { background:rgb(79,79,79); }");
340  }
341 
344 }
345 
347 {
348  int amplitudeInt = ui->amplitudeCoarse->value() * 100 + ui->amplitudeFine->value();
349  double power;
350 
351  switch (ui->sampleSize->currentIndex())
352  {
353  case 0: // 8 bits: 128
354  power = (double) amplitudeInt*amplitudeInt / (double) (1<<14);
355  break;
356  case 1: // 12 bits 2048
357  power = (double) amplitudeInt*amplitudeInt / (double) (1<<22);
358  break;
359  case 2: // 16 bits 32768
360  default:
361  power = (double) amplitudeInt*amplitudeInt / (double) (1<<30);
362  break;
363  }
364 
365  ui->amplitudeBits->setText(QString(tr("%1 b").arg(amplitudeInt)));
366  double powerDb = CalcDb::dbPower(power);
367  ui->power->setText(QString(tr("%1 dB").arg(QString::number(powerDb, 'f', 1))));
368 }
369 
371 {
372  switch (ui->sampleSize->currentIndex())
373  {
374  case 0: // 8 bits: 128
375  ui->amplitudeCoarse->setMaximum(1);
376  break;
377  case 1: // 12 bits 2048
378  ui->amplitudeCoarse->setMaximum(20);
379  break;
380  case 2: // 16 bits 32768
381  default:
382  ui->amplitudeCoarse->setMaximum(327);
383  break;
384  }
385 }
386 
388 {
389  switch (ui->sampleSize->currentIndex())
390  {
391  case 0: // 8 bits: 128
392  if (ui->amplitudeCoarse->value() == 1) {
393  ui->amplitudeFine->setMaximum(27);
394  } else {
395  ui->amplitudeFine->setMaximum(99);
396  }
397  break;
398  case 1: // 12 bits 2048
399  if (ui->amplitudeCoarse->value() == 20) {
400  ui->amplitudeFine->setMaximum(47);
401  } else {
402  ui->amplitudeFine->setMaximum(99);
403  }
404  break;
405  case 2: // 16 bits 32768
406  default:
407  if (ui->amplitudeCoarse->value() == 327) {
408  ui->amplitudeFine->setMaximum(67);
409  } else {
410  ui->amplitudeFine->setMaximum(99);
411  }
412  break;
413  }
414 }
415 
417 {
418  qint64 sampleRate = ui->sampleRate->getValueNew();
419  ui->frequencyShift->setValueRange(false, 7, -sampleRate, sampleRate);
420  ui->frequencyShift->setValue(m_settings.m_streams[m_streamIndex].m_frequencyShift);
421 }
422 
424 {
425  if (((TestMI*) m_sampleMIMO)->isRecording(m_streamIndex)) {
426  ui->record->setStyleSheet("QToolButton { background-color : red; }");
427  } else {
428  ui->record->setStyleSheet("QToolButton { background:rgb(79,79,79); }");
429  }
430 }
431 
433 {
434  blockApplySettings(true);
435  ui->sampleSize->blockSignals(true);
436 
437  ui->streamIndex->setCurrentIndex(m_streamIndex);
438  ui->centerFrequency->setValue(m_settings.m_streams[m_streamIndex].m_centerFrequency / 1000);
439  ui->decimation->setCurrentIndex(m_settings.m_streams[m_streamIndex].m_log2Decim);
440  ui->fcPos->setCurrentIndex((int) m_settings.m_streams[m_streamIndex].m_fcPos);
441  ui->sampleRate->setValue(m_settings.m_streams[m_streamIndex].m_sampleRate);
443  ui->frequencyShift->setValue(m_settings.m_streams[m_streamIndex].m_frequencyShift);
444  ui->sampleSize->setCurrentIndex(m_settings.m_streams[m_streamIndex].m_sampleSizeIndex);
446  int amplitudeBits = m_settings.m_streams[m_streamIndex].m_amplitudeBits;
447  ui->amplitudeCoarse->setValue(amplitudeBits/100);
449  ui->amplitudeFine->setValue(amplitudeBits%100);
451  int dcBiasPercent = roundf(m_settings.m_streams[m_streamIndex].m_dcFactor * 100.0f);
452  ui->dcBias->setValue((int) dcBiasPercent);
453  ui->dcBiasText->setText(QString(tr("%1 %").arg(dcBiasPercent)));
454  int iBiasPercent = roundf(m_settings.m_streams[m_streamIndex].m_iFactor * 100.0f);
455  ui->iBias->setValue((int) iBiasPercent);
456  ui->iBiasText->setText(QString(tr("%1 %").arg(iBiasPercent)));
457  int qBiasPercent = roundf(m_settings.m_streams[m_streamIndex].m_qFactor * 100.0f);
458  ui->qBias->setValue((int) qBiasPercent);
459  ui->qBiasText->setText(QString(tr("%1 %").arg(qBiasPercent)));
460  int phaseImbalancePercent = roundf(m_settings.m_streams[m_streamIndex].m_phaseImbalance * 100.0f);
461  ui->phaseImbalance->setValue((int) phaseImbalancePercent);
462  ui->phaseImbalanceText->setText(QString(tr("%1 %").arg(phaseImbalancePercent)));
463  ui->autoCorr->setCurrentIndex(m_settings.m_streams[m_streamIndex].m_autoCorrOptions);
464  ui->sampleSize->blockSignals(false);
465  ui->modulation->setCurrentIndex((int) m_settings.m_streams[m_streamIndex].m_modulation);
466  ui->modulationFrequency->setValue(m_settings.m_streams[m_streamIndex].m_modulationTone);
467  ui->modulationFrequencyText->setText(QString("%1").arg(m_settings.m_streams[m_streamIndex].m_modulationTone / 100.0, 0, 'f', 2));
468  ui->amModulation->setValue(m_settings.m_streams[m_streamIndex].m_amModulation);
469  ui->amModulationText->setText(QString("%1").arg(m_settings.m_streams[m_streamIndex].m_amModulation));
470  ui->fmDeviation->setValue(m_settings.m_streams[m_streamIndex].m_fmDeviation);
471  ui->fmDeviationText->setText(QString("%1").arg(m_settings.m_streams[m_streamIndex].m_fmDeviation / 10.0, 0, 'f', 1));
472  blockApplySettings(false);
473 }
474 
476 {
477  if(!m_updateTimer.isActive()) {
478  m_updateTimer.start(100);
479  }
480 }
481 
483 {
484  if (m_doApplySettings)
485  {
488  m_forceSettings = false;
489  m_updateTimer.stop();
490  }
491 }
492 
494 {
495  int state = m_deviceUISet->m_deviceAPI->state();
496 
497  if(m_lastEngineState != state)
498  {
499  switch(state)
500  {
502  ui->startStop->setStyleSheet("QToolButton { background:rgb(79,79,79); }");
503  break;
504  case DeviceAPI::StIdle:
505  ui->startStop->setStyleSheet("QToolButton { background-color : blue; }");
506  break;
508  ui->startStop->setStyleSheet("QToolButton { background-color : green; }");
509  break;
510  case DeviceAPI::StError:
511  ui->startStop->setStyleSheet("QToolButton { background-color : red; }");
512  QMessageBox::information(this, tr("Message"), m_deviceUISet->m_deviceAPI->errorMessage());
513  break;
514  default:
515  break;
516  }
517 
518  m_lastEngineState = state;
519  }
520 }
521 
522 bool TestMIGui::handleMessage(const Message& message)
523 {
525  {
526  qDebug("TestMIGui::handleMessage: MsgConfigureTestSource");
528  m_settings = cfg.getSettings();
529  displaySettings();
530  return true;
531  }
532  else if (TestMI::MsgStartStop::match(message))
533  {
534  qDebug("TestMIGui::handleMessage: MsgStartStop");
535  TestMI::MsgStartStop& notif = (TestMI::MsgStartStop&) message;
536  blockApplySettings(true);
537  ui->startStop->setChecked(notif.getStartStop());
538  blockApplySettings(false);
539 
540  return true;
541  }
542  else
543  {
544  return false;
545  }
546 }
547 
549 {
550  Message* message;
551 
552  while ((message = m_inputMessageQueue.pop()) != 0)
553  {
554  if (DSPMIMOSignalNotification::match(*message))
555  {
557  int istream = notif->getIndex();
558  bool sourceOrSink = notif->getSourceOrSink();
559  m_deviceSampleRates[istream] = notif->getSampleRate();
560  m_deviceCenterFrequencies[istream] = notif->getCenterFrequency();
561  // Do not consider multiple sources at this time
562  qDebug("TestMIGui::handleInputMessages: DSPMIMOSignalNotification: %s stream: %d SampleRate:%d, CenterFrequency:%llu",
563  sourceOrSink ? "source" : "sink",
564  istream,
565  notif->getSampleRate(),
566  notif->getCenterFrequency());
568 
569  delete message;
570  }
571  else
572  {
573  if (handleMessage(*message))
574  {
575  delete message;
576  }
577  }
578  }
579 }
580 
582 {
585  ui->deviceRateText->setText(tr("%1k").arg((float) m_deviceSampleRates[m_streamIndex] / 1000));
586 }
587 
589 {
590  BasicDeviceSettingsDialog dialog(this);
595 
596  dialog.move(p);
597  dialog.exec();
598 
603 
604  sendSettings();
605 }
void on_fmDeviation_valueChanged(int value)
Definition: testmigui.cpp:299
void on_phaseImbalance_valueChanged(int value)
Definition: testmigui.cpp:327
void updateStatus()
Definition: testmigui.cpp:493
int m_spectrumStreamIndex
Index of the stream displayed on main spectrum.
Definition: testmigui.h:61
void resetToDefaults()
Definition: testmigui.cpp:105
QString m_reverseAPIAddress
Message * pop()
Pop message from queue.
const QString & getReverseAPIAddress() const
void openDeviceSettingsDialog(const QPoint &p)
Definition: testmigui.cpp:588
qint64 getCenterFrequency() const
Definition: dspcommands.h:347
void updateAmpFineLimit()
Definition: testmigui.cpp:387
QByteArray serialize() const
void push(Message *message, bool emitSignal=true)
Push message onto queue.
void setSampleRate(qint32 sampleRate)
Definition: glspectrum.cpp:211
GLSpectrum * m_spectrum
Definition: deviceuiset.h:44
uint16_t m_reverseAPIPort
Ui::TestMIGui * ui
Definition: testmigui.h:56
static double dbPower(double magsq, double floor=1e-12)
Definition: db.cpp:22
void on_centerFrequency_changed(quint64 value)
Definition: testmigui.cpp:194
MessageQueue * getInputMessageQueue()
void on_amModulation_valueChanged(int value)
Definition: testmigui.cpp:292
void on_streamLock_toggled(bool checked)
Definition: testmigui.cpp:187
void setUseReverseAPI(bool useReverseAPI)
void updateAmpCoarseLimit()
Definition: testmigui.cpp:370
void on_qBias_valueChanged(int value)
Definition: testmigui.cpp:320
void handleInputMessages()
Definition: testmigui.cpp:548
int m_streamIndex
Current stream index being dealt with.
Definition: testmigui.h:60
void on_spectrumSource_currentIndexChanged(int index)
Definition: testmigui.cpp:169
void on_modulationFrequency_valueChanged(int value)
Definition: testmigui.cpp:285
static MsgFileRecord * create(bool startStop, int streamIndex)
Definition: testmi.h:68
void setName(const QString &name)
Definition: testmigui.cpp:95
Definition: testmi.h:35
void setSpectrumSinkInput(bool sourceElseSink=true, unsigned int index=0)
Used in the MIMO case to select which stream is used as input to main spectrum.
Definition: deviceapi.cpp:111
void setDisplayedStream(bool sourceOrSink, int streamIndex)
Definition: glspectrum.h:99
void on_frequencyShift_changed(qint64 value)
Definition: testmigui.cpp:210
void on_sampleRate_changed(quint64 value)
Definition: testmigui.cpp:236
void sendSettings()
Definition: testmigui.cpp:475
QString errorMessage()
Last error message from the device engine.
Definition: deviceapi.cpp:290
void updateHardware()
Definition: testmigui.cpp:482
static MsgConfigureTestSource * create(const TestMISettings &settings, bool force)
Definition: testmi.h:45
Fixed< IntType, IntBits > arg(const std::complex< Fixed< IntType, IntBits > > &val)
Definition: fixed.h:2401
void on_amplitudeFine_valueChanged(int value)
Definition: testmigui.cpp:267
GLSpectrum * getSpectrum()
Direct spectrum getter.
Definition: deviceuiset.h:57
bool getSourceOrSink() const
Definition: dspcommands.h:348
void on_decimation_currentIndexChanged(int index)
Definition: testmigui.cpp:216
engine is before initialization
Definition: deviceapi.h:53
EngineState state() const
Return the state of the device engine corresponding to the stream type.
Definition: deviceapi.cpp:277
virtual ~TestMIGui()
Definition: testmigui.cpp:85
bool m_forceSettings
Definition: testmigui.h:65
DeviceAPI * m_deviceAPI
Definition: deviceuiset.h:48
engine is idle
Definition: deviceapi.h:54
std::vector< int > m_deviceSampleRates
Definition: testmigui.h:68
void displaySettings()
Definition: testmigui.cpp:432
TestMIGui(DeviceUISet *deviceUISet, QWidget *parent=0)
Definition: testmigui.cpp:42
void updateSampleRateAndFrequency()
Definition: testmigui.cpp:581
DeviceSampleMIMO * m_sampleMIMO
Definition: testmigui.h:66
bool m_doApplySettings
Definition: testmigui.h:64
static MsgStartStop * create(bool startStop)
Definition: testmi.h:89
virtual qint64 getCenterFrequency() const
Definition: testmigui.cpp:112
QTimer m_updateTimer
Definition: testmigui.h:62
void blockApplySettings(bool block)
Definition: testmigui.h:73
void on_iBias_valueChanged(int value)
Definition: testmigui.cpp:313
uint16_t m_reverseAPIDeviceIndex
static bool match(const Message *message)
Definition: message.cpp:45
std::vector< TestMIStreamSettings > m_streams
void updateFrequencyShiftLimit()
Definition: testmigui.cpp:416
bool deserialize(const QByteArray &data)
bool getStartStop() const
Definition: testmi.h:87
virtual void setCenterFrequency(qint64 centerFrequency)
Definition: testmigui.cpp:117
DeviceUISet * m_deviceUISet
Definition: testmigui.h:58
int m_lastEngineState
Definition: testmigui.h:70
TestMISettings m_settings
Definition: testmigui.h:59
void on_sampleSize_currentIndexChanged(int index)
Definition: testmigui.cpp:244
void on_fcPos_currentIndexChanged(int index)
Definition: testmigui.cpp:226
MessageQueue m_inputMessageQueue
Definition: testmigui.h:71
void on_modulation_currentIndexChanged(int index)
Definition: testmigui.cpp:275
void on_dcBias_valueChanged(int value)
Definition: testmigui.cpp:306
virtual void setMessageQueueToGUI(MessageQueue *queue)=0
QString getName() const
Definition: testmigui.cpp:100
void setCenterFrequency(qint64 frequency)
Definition: glspectrum.cpp:175
const TestMISettings & getSettings() const
Definition: testmi.h:42
void setReverseAPIAddress(const QString &address)
void updateFileRecordStatus()
Definition: testmigui.cpp:423
virtual bool handleMessage(const Message &message)
Definition: testmigui.cpp:522
void setReverseAPIDeviceIndex(uint16_t deviceIndex)
bool deserialize(const QByteArray &data)
Definition: testmigui.cpp:129
void on_startStop_toggled(bool checked)
Definition: testmigui.cpp:142
QByteArray serialize() const
Definition: testmigui.cpp:124
void on_streamIndex_currentIndexChanged(int index)
Definition: testmigui.cpp:151
void on_autoCorr_currentIndexChanged(int index)
Definition: testmigui.cpp:200
std::vector< quint64 > m_deviceCenterFrequencies
Center frequency in device.
Definition: testmigui.h:69
engine is running
Definition: deviceapi.h:56
virtual void destroy()
Definition: testmigui.cpp:90
QTimer m_statusTimer
Definition: testmigui.h:63
unsigned int getIndex() const
Definition: dspcommands.h:349
DeviceSampleMIMO * getSampleMIMO()
Return pointer to the device sample MIMO or nullptr.
Definition: deviceapi.cpp:231
void on_record_toggled(bool checked)
Definition: testmigui.cpp:334
void on_amplitudeCoarse_valueChanged(int value)
Definition: testmigui.cpp:258
engine is in error
Definition: deviceapi.h:57
void displayAmplitude()
Definition: testmigui.cpp:346