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.
fcdprogui.cpp
Go to the documentation of this file.
1 // Copyright (C) 2015 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 <QMessageBox>
19 
20 #include "ui_fcdprogui.h"
21 #include "gui/colormapper.h"
22 #include "gui/glspectrum.h"
23 #include "gui/crightclickenabler.h"
25 #include "dsp/dspengine.h"
26 #include "dsp/dspcommands.h"
27 #include "fcdprogui.h"
28 
29 #include "device/deviceapi.h"
30 #include "device/deviceuiset.h"
31 #include "fcdproconst.h"
32 #include "fcdtraits.h"
33 
34 FCDProGui::FCDProGui(DeviceUISet *deviceUISet, QWidget* parent) :
35  QWidget(parent),
36  ui(new Ui::FCDProGui),
37  m_deviceUISet(deviceUISet),
38  m_forceSettings(true),
39  m_settings(),
40  m_sampleSource(NULL),
41  m_lastEngineState(DeviceAPI::StNotStarted)
42 {
44 
45  ui->setupUi(this);
46  ui->centerFrequency->setColorMapper(ColorMapper(ColorMapper::GrayGold));
48 
49  ui->lnaGain->clear();
50  for (int i = 0; i < FCDProConstants::fcdpro_lna_gain_nb_values(); i++)
51  {
52  ui->lnaGain->addItem(QString(FCDProConstants::lna_gains[i].label.c_str()), i);
53  }
54 
55  ui->rfFilter->clear();
56  for (int i = 0; i < FCDProConstants::fcdpro_rf_filter_nb_values(); i++)
57  {
58  ui->rfFilter->addItem(QString(FCDProConstants::rf_filters[i].label.c_str()), i);
59  }
60 
61  ui->lnaEnhance->clear();
63  {
64  ui->lnaEnhance->addItem(QString(FCDProConstants::lna_enhances[i].label.c_str()), i);
65  }
66 
67  ui->band->clear();
68  for (int i = 0; i < FCDProConstants::fcdpro_band_nb_values(); i++)
69  {
70  ui->band->addItem(QString(FCDProConstants::bands[i].label.c_str()), i);
71  }
72 
73  ui->mixGain->clear();
75  {
76  ui->mixGain->addItem(QString(FCDProConstants::mixer_gains[i].label.c_str()), i);
77  }
78 
79  ui->mixFilter->clear();
81  {
82  ui->mixFilter->addItem(QString(FCDProConstants::mixer_filters[i].label.c_str()), i);
83  }
84 
85  ui->bias->clear();
87  {
88  ui->bias->addItem(QString(FCDProConstants::bias_currents[i].label.c_str()), i);
89  }
90 
91  ui->mode->clear();
93  {
94  ui->mode->addItem(QString(FCDProConstants::if_gain_modes[i].label.c_str()), i);
95  }
96 
97  ui->gain1->clear();
98  for (int i = 0; i < FCDProConstants::fcdpro_if_gain1_nb_values(); i++)
99  {
100  ui->gain1->addItem(QString(FCDProConstants::if_gains1[i].label.c_str()), i);
101  }
102 
103  ui->rcFilter->clear();
105  {
106  ui->rcFilter->addItem(QString(FCDProConstants::if_rc_filters[i].label.c_str()), i);
107  }
108 
109  ui->gain2->clear();
110  for (int i = 0; i < FCDProConstants::fcdpro_if_gain2_nb_values(); i++)
111  {
112  ui->gain2->addItem(QString(FCDProConstants::if_gains2[i].label.c_str()), i);
113  }
114 
115  ui->gain3->clear();
116  for (int i = 0; i < FCDProConstants::fcdpro_if_gain3_nb_values(); i++)
117  {
118  ui->gain3->addItem(QString(FCDProConstants::if_gains3[i].label.c_str()), i);
119  }
120 
121  ui->gain4->clear();
122  for (int i = 0; i < FCDProConstants::fcdpro_if_gain4_nb_values(); i++)
123  {
124  ui->gain4->addItem(QString(FCDProConstants::if_gains4[i].label.c_str()), i);
125  }
126 
127  ui->ifFilter->clear();
128  for (int i = 0; i < FCDProConstants::fcdpro_if_filter_nb_values(); i++)
129  {
130  ui->ifFilter->addItem(QString(FCDProConstants::if_filters[i].label.c_str()), i);
131  }
132 
133  ui->gain5->clear();
134  for (int i = 0; i < FCDProConstants::fcdpro_if_gain5_nb_values(); i++)
135  {
136  ui->gain5->addItem(QString(FCDProConstants::if_gains5[i].label.c_str()), i);
137  }
138 
139  ui->gain6->clear();
140  for (int i = 0; i < FCDProConstants::fcdpro_if_gain6_nb_values(); i++)
141  {
142  ui->gain6->addItem(QString(FCDProConstants::if_gains6[i].label.c_str()), i);
143  }
144 
145  connect(&m_updateTimer, SIGNAL(timeout()), this, SLOT(updateHardware()));
146  connect(&m_statusTimer, SIGNAL(timeout()), this, SLOT(updateStatus()));
147  m_statusTimer.start(500);
148 
149  CRightClickEnabler *startStopRightClickEnabler = new CRightClickEnabler(ui->startStop);
150  connect(startStopRightClickEnabler, SIGNAL(rightClick(const QPoint &)), this, SLOT(openDeviceSettingsDialog(const QPoint &)));
151 
152  displaySettings();
153 
154  connect(&m_inputMessageQueue, SIGNAL(messageEnqueued()), this, SLOT(handleInputMessages()), Qt::QueuedConnection);
156 }
157 
159 {
160  delete ui;
161 }
162 
164 {
165  delete this;
166 }
167 
168 void FCDProGui::setName(const QString& name)
169 {
170  setObjectName(name);
171 }
172 
173 QString FCDProGui::getName() const
174 {
175  return objectName();
176 }
177 
179 {
181  displaySettings();
182  sendSettings();
183 }
184 
186 {
188 }
189 
190 void FCDProGui::setCenterFrequency(qint64 centerFrequency)
191 {
192  m_settings.m_centerFrequency = centerFrequency;
193  displaySettings();
194  sendSettings();
195 }
196 
197 QByteArray FCDProGui::serialize() const
198 {
199  return m_settings.serialize();
200 }
201 
202 bool FCDProGui::deserialize(const QByteArray& data)
203 {
204  if(m_settings.deserialize(data))
205  {
206  displaySettings();
207  m_forceSettings = true;
208  sendSettings();
209  return true;
210  }
211  else
212  {
213  resetToDefaults();
214  return false;
215  }
216 }
217 
218 bool FCDProGui::handleMessage(const Message& message)
219 {
221  {
223  m_settings = cfg.getSettings();
224  blockApplySettings(true);
225  displaySettings();
226  blockApplySettings(false);
227  return true;
228  }
229  else if (FCDProInput::MsgStartStop::match(message))
230  {
232  blockApplySettings(true);
233  ui->startStop->setChecked(notif.getStartStop());
234  blockApplySettings(false);
235 
236  return true;
237  }
238  else
239  {
240  return false;
241  }
242 }
243 
245 {
246  Message* message;
247 
248  while ((message = m_inputMessageQueue.pop()) != 0)
249  {
250  qDebug("FCDProGui::handleInputMessages: message: %s", message->getIdentifier());
251 
252  if (DSPSignalNotification::match(*message))
253  {
254  DSPSignalNotification* notif = (DSPSignalNotification*) message;
255  m_sampleRate = notif->getSampleRate();
257  qDebug("FCDProGui::handleInputMessages: DSPSignalNotification: SampleRate:%d, CenterFrequency:%llu", notif->getSampleRate(), notif->getCenterFrequency());
259 
260  delete message;
261  }
262  else
263  {
264  if (handleMessage(*message))
265  {
266  delete message;
267  }
268  }
269  }
270 }
271 
273 {
276  ui->deviceRateText->setText(tr("%1k").arg((float)m_sampleRate / 1000));
277 }
278 
280 {
281  // values in kHz
282  qint64 deltaFrequency = m_settings.m_transverterMode ? m_settings.m_transverterDeltaFrequency/1000 : 0;
283  qint64 minLimit = fcd_traits<Pro>::loLowLimitFreq/1000 + deltaFrequency;
284  qint64 maxLimit = fcd_traits<Pro>::loHighLimitFreq/1000 + deltaFrequency;
285 
286  minLimit = minLimit < 0 ? 0 : minLimit > 9999999 ? 9999999 : minLimit;
287  maxLimit = maxLimit < 0 ? 0 : maxLimit > 9999999 ? 9999999 : maxLimit;
288 
289  qDebug("FCDProGui::updateFrequencyLimits: delta: %lld min: %lld max: %lld", deltaFrequency, minLimit, maxLimit);
290 
291  ui->centerFrequency->setValueRange(7, minLimit, maxLimit);
292 }
293 
295 {
296  ui->transverter->setDeltaFrequency(m_settings.m_transverterDeltaFrequency);
297  ui->transverter->setDeltaFrequencyActive(m_settings.m_transverterMode);
299  ui->centerFrequency->setValue(m_settings.m_centerFrequency / 1000);
300  ui->ppm->setValue(m_settings.m_LOppmTenths);
301  ui->ppmText->setText(QString("%1").arg(QString::number(m_settings.m_LOppmTenths/10.0, 'f', 1)));
302  ui->dcOffset->setChecked(m_settings.m_dcBlock);
303  ui->iqImbalance->setChecked(m_settings.m_iqCorrection);
304 
305  ui->lnaGain->setCurrentIndex(m_settings.m_lnaGainIndex);
306  ui->rfFilter->setCurrentIndex(m_settings.m_rfFilterIndex);
307  ui->lnaEnhance->setCurrentIndex(m_settings.m_lnaEnhanceIndex);
308  ui->band->setCurrentIndex(m_settings.m_bandIndex);
309  ui->mixGain->setCurrentIndex(m_settings.m_mixerGainIndex);
310  ui->mixFilter->setCurrentIndex(m_settings.m_mixerFilterIndex);
311  ui->bias->setCurrentIndex(m_settings.m_biasCurrentIndex);
312  ui->mode->setCurrentIndex(m_settings.m_modeIndex);
313  ui->gain1->setCurrentIndex(m_settings.m_gain1Index);
314  ui->gain2->setCurrentIndex(m_settings.m_gain2Index);
315  ui->gain3->setCurrentIndex(m_settings.m_gain3Index);
316  ui->gain4->setCurrentIndex(m_settings.m_gain4Index);
317  ui->gain5->setCurrentIndex(m_settings.m_gain5Index);
318  ui->gain6->setCurrentIndex(m_settings.m_gain6Index);
319  ui->decim->setCurrentIndex(m_settings.m_log2Decim);
320  ui->fcPos->setCurrentIndex((int) m_settings.m_fcPos);
321  ui->rcFilter->setCurrentIndex(m_settings.m_rcFilterIndex);
322  ui->ifFilter->setCurrentIndex(m_settings.m_ifFilterIndex);
323 }
324 
326 {
327  if(!m_updateTimer.isActive())
328  m_updateTimer.start(100);
329 }
330 
332 {
333  m_settings.m_centerFrequency = value * 1000;
334  sendSettings();
335 }
336 
338 {
339  m_settings.m_LOppmTenths = value;
340  displaySettings();
341  sendSettings();
342 }
343 
345 {
346  m_settings.m_dcBlock = checked;
347  sendSettings();
348 }
349 
351 {
352  m_settings.m_iqCorrection = checked;
353  sendSettings();
354 }
355 
357 {
358  m_settings.m_lnaGainIndex = index;
359  sendSettings();
360 }
361 
363 {
364  m_settings.m_rfFilterIndex = index;
365  sendSettings();
366 }
367 
369 {
371  sendSettings();
372 }
373 
375 {
376  m_settings.m_bandIndex = index;
377  sendSettings();
378 }
379 
381 {
383  sendSettings();
384 }
385 
387 {
389  sendSettings();
390 }
391 
393 {
395  sendSettings();
396 }
397 
399 {
400  m_settings.m_modeIndex = index;
401  sendSettings();
402 }
403 
405 {
406  m_settings.m_gain1Index = index;
407  sendSettings();
408 }
409 
411 {
412  m_settings.m_rcFilterIndex = index;
413  sendSettings();
414 }
415 
417 {
418  m_settings.m_gain2Index = index;
419  sendSettings();
420 }
421 
423 {
424  m_settings.m_gain3Index = index;
425  sendSettings();
426 }
427 
429 {
430  m_settings.m_gain4Index = index;
431  sendSettings();
432 }
433 
435 {
436  m_settings.m_ifFilterIndex = index;
437  sendSettings();
438 }
439 
441 {
442  m_settings.m_gain5Index = index;
443  sendSettings();
444 }
445 
447 {
448  m_settings.m_gain6Index = index;
449  sendSettings();
450 }
451 
453 {
454  if ((index < 0) || (index > 6)) {
455  return;
456  }
457 
458  m_settings.m_log2Decim = index;
459  sendSettings();
460 }
461 
463 {
464  if (index == 0) {
466  sendSettings();
467  } else if (index == 1) {
469  sendSettings();
470  } else if (index == 2) {
472  sendSettings();
473  }
474 }
475 
477 {
478  (void) checked;
479  m_settings.m_lnaGainIndex = 8; // +15 dB
480  //m_settings.rfFilterIndex = 0;
481  m_settings.m_mixerGainIndex = 1; // +12 dB
482  m_settings.m_mixerFilterIndex = 8; // 1.9 MHz
483  m_settings.m_gain1Index = 1; // +6 dB
484  m_settings.m_rcFilterIndex = 15; // 1.0 MHz
485  m_settings.m_gain2Index = 1; // +3 dB
486  m_settings.m_gain3Index = 1; // +3 dB
487  m_settings.m_gain4Index = 0; // 0 dB
488  m_settings.m_ifFilterIndex = 31; // 2.15 MHz
489  m_settings.m_gain5Index = 0; // +3 dB
490  m_settings.m_gain6Index = 0; // +3 dB
491  m_settings.m_lnaEnhanceIndex = 0; // Off
492  m_settings.m_biasCurrentIndex = 3; // V/U band
493  m_settings.m_modeIndex = 0; // Linearity
494  displaySettings();
495  sendSettings();
496 }
497 
499 {
500  if (m_doApplySettings)
501  {
504  }
505 }
506 
508 {
509  if (checked) {
510  ui->record->setStyleSheet("QToolButton { background-color : red; }");
511  } else {
512  ui->record->setStyleSheet("QToolButton { background:rgb(79,79,79); }");
513  }
514 
517 }
518 
520 {
521  m_settings.m_transverterMode = ui->transverter->getDeltaFrequencyAcive();
522  m_settings.m_transverterDeltaFrequency = ui->transverter->getDeltaFrequency();
523  qDebug("FCDProGui::on_transverter_clicked: %lld Hz %s", m_settings.m_transverterDeltaFrequency, m_settings.m_transverterMode ? "on" : "off");
525  m_settings.m_centerFrequency = ui->centerFrequency->getValueNew()*1000;
526  sendSettings();
527 }
528 
530 {
531  int state = m_deviceUISet->m_deviceAPI->state();
532 
533  if(m_lastEngineState != state)
534  {
535  switch(state)
536  {
538  ui->startStop->setStyleSheet("QToolButton { background:rgb(79,79,79); }");
539  break;
540  case DeviceAPI::StIdle:
541  ui->startStop->setStyleSheet("QToolButton { background-color : blue; }");
542  break;
544  ui->startStop->setStyleSheet("QToolButton { background-color : green; }");
545  break;
546  case DeviceAPI::StError:
547  ui->startStop->setStyleSheet("QToolButton { background-color : red; }");
548  QMessageBox::information(this, tr("Message"), m_deviceUISet->m_deviceAPI->errorMessage());
549  break;
550  default:
551  break;
552  }
553 
554  m_lastEngineState = state;
555  }
556 }
557 
559 {
562  m_forceSettings = false;
563  m_updateTimer.stop();
564 }
565 
567 {
568  BasicDeviceSettingsDialog dialog(this);
573 
574  dialog.move(p);
575  dialog.exec();
576 
581 
582  sendSettings();
583 }
void blockApplySettings(bool block)
Definition: fcdprogui.h:71
uint16_t m_reverseAPIPort
void on_gain2_currentIndexChanged(int index)
Definition: fcdprogui.cpp:416
QTimer m_statusTimer
Definition: fcdprogui.h:63
void on_band_currentIndexChanged(int index)
Definition: fcdprogui.cpp:374
Message * pop()
Pop message from queue.
const QString & getReverseAPIAddress() const
qint32 m_lnaEnhanceIndex
void on_lnaGain_currentIndexChanged(int index)
Definition: fcdprogui.cpp:356
void on_fcPos_currentIndexChanged(int index)
Definition: fcdprogui.cpp:462
void on_centerFrequency_changed(quint64 value)
Definition: fcdprogui.cpp:331
virtual ~FCDProGui()
Definition: fcdprogui.cpp:158
void push(Message *message, bool emitSignal=true)
Push message onto queue.
void setSampleRate(qint32 sampleRate)
Definition: glspectrum.cpp:211
static int fcdpro_if_filter_nb_values()
void on_record_toggled(bool checked)
Definition: fcdprogui.cpp:507
static int fcdpro_rf_filter_nb_values()
Definition: fcdproconst.cpp:99
static const fcdpro_if_gain3 if_gains3[]
Definition: fcdproconst.h:338
static const fcdpro_bias_current bias_currents[]
Definition: fcdproconst.h:331
void on_gain4_currentIndexChanged(int index)
Definition: fcdprogui.cpp:428
MessageQueue m_inputMessageQueue
Definition: fcdprogui.h:69
DeviceSampleSource * getSampleSource()
Return pointer to the device sample source (single Rx) or nullptr.
Definition: deviceapi.cpp:213
void setUseReverseAPI(bool useReverseAPI)
static const fcdpro_if_gain1 if_gains1[]
Definition: fcdproconst.h:336
QString getName() const
Definition: fcdprogui.cpp:173
DeviceUISet * m_deviceUISet
Definition: fcdprogui.h:58
qint32 m_mixerGainIndex
static int fcdpro_mixer_gain_nb_values()
MessageQueue * getInputMessageQueue()
static const fcdpro_if_gain_mode if_gain_modes[]
Definition: fcdproconst.h:333
bool deserialize(const QByteArray &data)
Definition: fcdprogui.cpp:202
QTimer m_updateTimer
Definition: fcdprogui.h:62
bool m_forceSettings
Definition: fcdprogui.h:60
static int fcdpro_if_gain3_nb_values()
quint32 m_log2Decim
FCDProSettings m_settings
Definition: fcdprogui.h:61
static int fcdpro_bias_current_nb_values()
void on_gain1_currentIndexChanged(int index)
Definition: fcdprogui.cpp:404
Ui::FCDProGui * ui
Definition: fcdprogui.h:56
static const fcdpro_if_gain6 if_gains6[]
Definition: fcdproconst.h:341
void on_gain5_currentIndexChanged(int index)
Definition: fcdprogui.cpp:440
QString errorMessage()
Last error message from the device engine.
Definition: deviceapi.cpp:290
static const fcdpro_lna_gain lna_gains[]
Definition: fcdproconst.h:326
qint32 m_lnaGainIndex
void updateSampleRateAndFrequency()
Definition: fcdprogui.cpp:272
static const fcdpro_if_gain2 if_gains2[]
Definition: fcdproconst.h:337
qint32 m_ifFilterIndex
void on_gain6_currentIndexChanged(int index)
Definition: fcdprogui.cpp:446
Fixed< IntType, IntBits > arg(const std::complex< Fixed< IntType, IntBits > > &val)
Definition: fixed.h:2401
const FCDProSettings & getSettings() const
Definition: fcdproinput.h:52
GLSpectrum * getSpectrum()
Direct spectrum getter.
Definition: deviceuiset.h:57
engine is before initialization
Definition: deviceapi.h:53
QByteArray serialize() const
Definition: fcdprogui.cpp:197
FCDProGui(DeviceUISet *deviceUISet, QWidget *parent=0)
Definition: fcdprogui.cpp:34
static int fcdpro_if_gain2_nb_values()
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_ifFilter_currentIndexChanged(int index)
Definition: fcdprogui.cpp:434
qint64 m_transverterDeltaFrequency
DeviceAPI * m_deviceAPI
Definition: deviceuiset.h:48
engine is idle
Definition: deviceapi.h:54
void on_iqImbalance_toggled(bool checked)
Definition: fcdprogui.cpp:350
uint16_t m_reverseAPIDeviceIndex
void on_mixGain_currentIndexChanged(int index)
Definition: fcdprogui.cpp:380
static MsgFileRecord * create(bool startStop)
Definition: fcdproinput.h:77
void on_gain3_currentIndexChanged(int index)
Definition: fcdprogui.cpp:422
void on_mixFilter_currentIndexChanged(int index)
Definition: fcdprogui.cpp:386
static MsgConfigureFCDPro * create(const FCDProSettings &settings, bool force)
Definition: fcdproinput.h:55
QByteArray serialize() const
static int fcdpro_lna_enhance_nb_values()
Definition: fcdproconst.cpp:39
void resetToDefaults()
Definition: fcdprogui.cpp:178
void on_startStop_toggled(bool checked)
Definition: fcdprogui.cpp:498
static int fcdpro_lna_gain_nb_values()
Definition: fcdproconst.cpp:26
bool m_doApplySettings
Definition: fcdprogui.h:59
int32_t i
Definition: decimators.h:244
static int fcdpro_band_nb_values()
Definition: fcdproconst.cpp:51
void on_rfFilter_currentIndexChanged(int index)
Definition: fcdprogui.cpp:362
qint32 m_LOppmTenths
void setName(const QString &name)
Definition: fcdprogui.cpp:168
bool getStartStop() const
Definition: fcdproinput.h:94
static bool match(const Message *message)
Definition: message.cpp:45
static int fcdpro_if_rc_filter_nb_values()
static int fcdpro_if_gain1_nb_values()
void on_ppm_valueChanged(int value)
Definition: fcdprogui.cpp:337
void on_dcOffset_toggled(bool checked)
Definition: fcdprogui.cpp:344
static const fcdpro_rf_filter rf_filters[]
Definition: fcdproconst.h:329
qint32 m_rfFilterIndex
qint32 m_mixerFilterIndex
static int fcdpro_if_gain6_nb_values()
void updateFrequencyLimits()
Definition: fcdprogui.cpp:279
static const fcdpro_if_filter if_filters[]
Definition: fcdproconst.h:335
void on_setDefaults_clicked(bool checked)
Definition: fcdprogui.cpp:476
void on_decim_currentIndexChanged(int index)
Definition: fcdprogui.cpp:452
QString m_reverseAPIAddress
DeviceSampleSource * m_sampleSource
Definition: fcdprogui.h:65
int getSampleRate() const
Definition: dspcommands.h:328
quint64 m_deviceCenterFrequency
Center frequency in device.
Definition: fcdprogui.h:67
virtual void destroy()
Definition: fcdprogui.cpp:163
void updateHardware()
Definition: fcdprogui.cpp:558
void displaySettings()
Definition: fcdprogui.cpp:294
void on_transverter_clicked()
Definition: fcdprogui.cpp:519
static int fcdpro_if_gain_mode_nb_values()
void setCenterFrequency(qint64 frequency)
Definition: glspectrum.cpp:175
virtual const char * getIdentifier() const
Definition: message.cpp:35
virtual qint64 getCenterFrequency() const
Definition: fcdprogui.cpp:185
int m_sampleRate
Definition: fcdprogui.h:66
void setReverseAPIAddress(const QString &address)
static const fcdpro_if_gain4 if_gains4[]
Definition: fcdproconst.h:339
virtual void setCenterFrequency(qint64 centerFrequency)
Definition: fcdprogui.cpp:190
void openDeviceSettingsDialog(const QPoint &p)
Definition: fcdprogui.cpp:566
void on_lnaEnhance_currentIndexChanged(int index)
Definition: fcdprogui.cpp:368
void setReverseAPIDeviceIndex(uint16_t deviceIndex)
qint32 m_rcFilterIndex
void updateStatus()
Definition: fcdprogui.cpp:529
static const fcdpro_mixer_filter mixer_filters[]
Definition: fcdproconst.h:332
bool deserialize(const QByteArray &data)
virtual void setMessageQueueToGUI(MessageQueue *queue)=0
engine is running
Definition: deviceapi.h:56
void handleInputMessages()
Definition: fcdprogui.cpp:244
int m_lastEngineState
Definition: fcdprogui.h:68
static const fcdpro_band bands[]
Definition: fcdproconst.h:328
static int fcdpro_if_gain4_nb_values()
void on_bias_currentIndexChanged(int index)
Definition: fcdprogui.cpp:392
void on_rcFilter_currentIndexChanged(int index)
Definition: fcdprogui.cpp:410
void sendSettings()
Definition: fcdprogui.cpp:325
static const fcdpro_if_gain5 if_gains5[]
Definition: fcdproconst.h:340
quint64 m_centerFrequency
engine is in error
Definition: deviceapi.h:57
static const fcdpro_lna_enhance lna_enhances[]
Definition: fcdproconst.h:327
static MsgStartStop * create(bool startStop)
Definition: fcdproinput.h:96
static int fcdpro_if_gain5_nb_values()
void on_mode_currentIndexChanged(int index)
Definition: fcdprogui.cpp:398
static const fcdpro_mixer_gain mixer_gains[]
Definition: fcdproconst.h:330
qint32 m_biasCurrentIndex
virtual bool handleMessage(const Message &message)
Definition: fcdprogui.cpp:218
static const fcdpro_if_rc_filter if_rc_filters[]
Definition: fcdproconst.h:334
static int fcdpro_mixer_filter_nb_values()