mirror of
https://github.com/f4exb/sdrangel.git
synced 2025-03-22 12:18:32 -04:00
New preset design (single) applied to FCD Pro
This commit is contained in:
parent
ded446c43a
commit
f50e717c20
@ -10,8 +10,8 @@
|
||||
const char *fcd_traits<Pro>::alsaDeviceName = "hw:CARD=V10";
|
||||
const char *fcd_traits<ProPlus>::alsaDeviceName = "hw:CARD=V20";
|
||||
|
||||
const char *fcd_traits<Pro>::interfaceIID = "org.osmocom.sdr.samplesource.fcdpro";
|
||||
const char *fcd_traits<ProPlus>::interfaceIID = "org.osmocom.sdr.samplesource.fcdproplus";
|
||||
const char *fcd_traits<Pro>::interfaceIID = "sdrangel.samplesource.fcdpro";
|
||||
const char *fcd_traits<ProPlus>::interfaceIID = "sdrangel.samplesource.fcdproplus";
|
||||
|
||||
const char *fcd_traits<Pro>::displayedName = "FunCube Dongle Pro";
|
||||
const char *fcd_traits<ProPlus>::displayedName = "FunCube Dongle Pro+";
|
||||
|
@ -4,7 +4,7 @@ set(fcdpro_SOURCES
|
||||
fcdprogui.cpp
|
||||
fcdproinput.cpp
|
||||
fcdproplugin.cpp
|
||||
fcdproserializer.cpp
|
||||
fcdprosettings.cpp
|
||||
fcdprothread.cpp
|
||||
)
|
||||
|
||||
@ -12,7 +12,7 @@ set(fcdpro_HEADERS
|
||||
fcdprogui.h
|
||||
fcdproinput.h
|
||||
fcdproplugin.h
|
||||
fcdproserializer.h
|
||||
fcdprosettings.h
|
||||
fcdprothread.h
|
||||
)
|
||||
|
||||
|
@ -148,12 +148,12 @@ void FCDProGui::resetToDefaults()
|
||||
|
||||
qint64 FCDProGui::getCenterFrequency() const
|
||||
{
|
||||
return m_settings.centerFrequency;
|
||||
return m_settings.m_centerFrequency;
|
||||
}
|
||||
|
||||
void FCDProGui::setCenterFrequency(qint64 centerFrequency)
|
||||
{
|
||||
m_settings.centerFrequency = centerFrequency;
|
||||
m_settings.m_centerFrequency = centerFrequency;
|
||||
displaySettings();
|
||||
sendSettings();
|
||||
}
|
||||
@ -185,26 +185,28 @@ bool FCDProGui::handleMessage(const Message& message)
|
||||
|
||||
void FCDProGui::displaySettings()
|
||||
{
|
||||
ui->centerFrequency->setValue(m_settings.centerFrequency / 1000);
|
||||
ui->ppm->setValue(m_settings.LOppmTenths);
|
||||
ui->ppmText->setText(QString("%1").arg(QString::number(m_settings.LOppmTenths/10.0, 'f', 1)));
|
||||
ui->centerFrequency->setValue(m_settings.m_centerFrequency / 1000);
|
||||
ui->ppm->setValue(m_settings.m_LOppmTenths);
|
||||
ui->ppmText->setText(QString("%1").arg(QString::number(m_settings.m_LOppmTenths/10.0, 'f', 1)));
|
||||
ui->dcOffset->setChecked(m_settings.m_dcBlock);
|
||||
ui->iqImbalance->setChecked(m_settings.m_iqCorrection);
|
||||
|
||||
ui->lnaGain->setCurrentIndex(m_settings.lnaGainIndex);
|
||||
ui->rfFilter->setCurrentIndex(m_settings.rfFilterIndex);
|
||||
ui->lnaEnhance->setCurrentIndex(m_settings.lnaEnhanceIndex);
|
||||
ui->band->setCurrentIndex(m_settings.bandIndex);
|
||||
ui->mixGain->setCurrentIndex(m_settings.mixerGainIndex);
|
||||
ui->mixFilter->setCurrentIndex(m_settings.mixerFilterIndex);
|
||||
ui->bias->setCurrentIndex(m_settings.biasCurrentIndex);
|
||||
ui->mode->setCurrentIndex(m_settings.modeIndex);
|
||||
ui->gain1->setCurrentIndex(m_settings.gain1Index);
|
||||
ui->gain2->setCurrentIndex(m_settings.gain2Index);
|
||||
ui->gain3->setCurrentIndex(m_settings.gain3Index);
|
||||
ui->gain4->setCurrentIndex(m_settings.gain4Index);
|
||||
ui->gain5->setCurrentIndex(m_settings.gain5Index);
|
||||
ui->gain6->setCurrentIndex(m_settings.gain6Index);
|
||||
ui->rcFilter->setCurrentIndex(m_settings.rcFilterIndex);
|
||||
ui->ifFilter->setCurrentIndex(m_settings.ifFilterIndex);
|
||||
ui->lnaGain->setCurrentIndex(m_settings.m_lnaGainIndex);
|
||||
ui->rfFilter->setCurrentIndex(m_settings.m_rfFilterIndex);
|
||||
ui->lnaEnhance->setCurrentIndex(m_settings.m_lnaEnhanceIndex);
|
||||
ui->band->setCurrentIndex(m_settings.m_bandIndex);
|
||||
ui->mixGain->setCurrentIndex(m_settings.m_mixerGainIndex);
|
||||
ui->mixFilter->setCurrentIndex(m_settings.m_mixerFilterIndex);
|
||||
ui->bias->setCurrentIndex(m_settings.m_biasCurrentIndex);
|
||||
ui->mode->setCurrentIndex(m_settings.m_modeIndex);
|
||||
ui->gain1->setCurrentIndex(m_settings.m_gain1Index);
|
||||
ui->gain2->setCurrentIndex(m_settings.m_gain2Index);
|
||||
ui->gain3->setCurrentIndex(m_settings.m_gain3Index);
|
||||
ui->gain4->setCurrentIndex(m_settings.m_gain4Index);
|
||||
ui->gain5->setCurrentIndex(m_settings.m_gain5Index);
|
||||
ui->gain6->setCurrentIndex(m_settings.m_gain6Index);
|
||||
ui->rcFilter->setCurrentIndex(m_settings.m_rcFilterIndex);
|
||||
ui->ifFilter->setCurrentIndex(m_settings.m_ifFilterIndex);
|
||||
}
|
||||
|
||||
void FCDProGui::sendSettings()
|
||||
@ -215,130 +217,142 @@ void FCDProGui::sendSettings()
|
||||
|
||||
void FCDProGui::on_centerFrequency_changed(quint64 value)
|
||||
{
|
||||
m_settings.centerFrequency = value * 1000;
|
||||
m_settings.m_centerFrequency = value * 1000;
|
||||
sendSettings();
|
||||
}
|
||||
|
||||
void FCDProGui::on_ppm_valueChanged(int value)
|
||||
{
|
||||
m_settings.LOppmTenths = value;
|
||||
m_settings.m_LOppmTenths = value;
|
||||
displaySettings();
|
||||
sendSettings();
|
||||
}
|
||||
|
||||
void FCDProGui::on_dcOffset_toggled(bool checked)
|
||||
{
|
||||
m_settings.m_dcBlock = checked;
|
||||
sendSettings();
|
||||
}
|
||||
|
||||
void FCDProGui::on_iqImbalance_toggled(bool checked)
|
||||
{
|
||||
m_settings.m_iqCorrection = checked;
|
||||
sendSettings();
|
||||
}
|
||||
|
||||
void FCDProGui::on_lnaGain_currentIndexChanged(int index)
|
||||
{
|
||||
m_settings.lnaGainIndex = index;
|
||||
m_settings.m_lnaGainIndex = index;
|
||||
sendSettings();
|
||||
}
|
||||
|
||||
void FCDProGui::on_rfFilter_currentIndexChanged(int index)
|
||||
{
|
||||
m_settings.rfFilterIndex = index;
|
||||
m_settings.m_rfFilterIndex = index;
|
||||
sendSettings();
|
||||
}
|
||||
|
||||
void FCDProGui::on_lnaEnhance_currentIndexChanged(int index)
|
||||
{
|
||||
m_settings.lnaEnhanceIndex = index;
|
||||
m_settings.m_lnaEnhanceIndex = index;
|
||||
sendSettings();
|
||||
}
|
||||
|
||||
void FCDProGui::on_band_currentIndexChanged(int index)
|
||||
{
|
||||
m_settings.bandIndex = index;
|
||||
m_settings.m_bandIndex = index;
|
||||
sendSettings();
|
||||
}
|
||||
|
||||
void FCDProGui::on_mixGain_currentIndexChanged(int index)
|
||||
{
|
||||
m_settings.mixerGainIndex = index;
|
||||
m_settings.m_mixerGainIndex = index;
|
||||
sendSettings();
|
||||
}
|
||||
|
||||
void FCDProGui::on_mixFilter_currentIndexChanged(int index)
|
||||
{
|
||||
m_settings.mixerFilterIndex = index;
|
||||
m_settings.m_mixerFilterIndex = index;
|
||||
sendSettings();
|
||||
}
|
||||
|
||||
void FCDProGui::on_bias_currentIndexChanged(int index)
|
||||
{
|
||||
m_settings.biasCurrentIndex = index;
|
||||
m_settings.m_biasCurrentIndex = index;
|
||||
sendSettings();
|
||||
}
|
||||
|
||||
void FCDProGui::on_mode_currentIndexChanged(int index)
|
||||
{
|
||||
m_settings.modeIndex = index;
|
||||
m_settings.m_modeIndex = index;
|
||||
sendSettings();
|
||||
}
|
||||
|
||||
void FCDProGui::on_gain1_currentIndexChanged(int index)
|
||||
{
|
||||
m_settings.gain1Index = index;
|
||||
m_settings.m_gain1Index = index;
|
||||
sendSettings();
|
||||
}
|
||||
|
||||
void FCDProGui::on_rcFilter_currentIndexChanged(int index)
|
||||
{
|
||||
m_settings.rcFilterIndex = index;
|
||||
m_settings.m_rcFilterIndex = index;
|
||||
sendSettings();
|
||||
}
|
||||
|
||||
void FCDProGui::on_gain2_currentIndexChanged(int index)
|
||||
{
|
||||
m_settings.gain2Index = index;
|
||||
m_settings.m_gain2Index = index;
|
||||
sendSettings();
|
||||
}
|
||||
|
||||
void FCDProGui::on_gain3_currentIndexChanged(int index)
|
||||
{
|
||||
m_settings.gain3Index = index;
|
||||
m_settings.m_gain3Index = index;
|
||||
sendSettings();
|
||||
}
|
||||
|
||||
void FCDProGui::on_gain4_currentIndexChanged(int index)
|
||||
{
|
||||
m_settings.gain4Index = index;
|
||||
m_settings.m_gain4Index = index;
|
||||
sendSettings();
|
||||
}
|
||||
|
||||
void FCDProGui::on_ifFilter_currentIndexChanged(int index)
|
||||
{
|
||||
m_settings.ifFilterIndex = index;
|
||||
m_settings.m_ifFilterIndex = index;
|
||||
sendSettings();
|
||||
}
|
||||
|
||||
void FCDProGui::on_gain5_currentIndexChanged(int index)
|
||||
{
|
||||
m_settings.gain5Index = index;
|
||||
m_settings.m_gain5Index = index;
|
||||
sendSettings();
|
||||
}
|
||||
|
||||
void FCDProGui::on_gain6_currentIndexChanged(int index)
|
||||
{
|
||||
m_settings.gain6Index = index;
|
||||
m_settings.m_gain6Index = index;
|
||||
sendSettings();
|
||||
}
|
||||
|
||||
void FCDProGui::on_setDefaults_clicked(bool checked)
|
||||
{
|
||||
m_settings.lnaGainIndex = 8; // +15 dB
|
||||
m_settings.m_lnaGainIndex = 8; // +15 dB
|
||||
//m_settings.rfFilterIndex = 0;
|
||||
m_settings.mixerGainIndex = 1; // +12 dB
|
||||
m_settings.mixerFilterIndex = 8; // 1.9 MHz
|
||||
m_settings.gain1Index = 1; // +6 dB
|
||||
m_settings.rcFilterIndex = 15; // 1.0 MHz
|
||||
m_settings.gain2Index = 1; // +3 dB
|
||||
m_settings.gain3Index = 1; // +3 dB
|
||||
m_settings.gain4Index = 0; // 0 dB
|
||||
m_settings.ifFilterIndex = 31; // 2.15 MHz
|
||||
m_settings.gain5Index = 0; // +3 dB
|
||||
m_settings.gain6Index = 0; // +3 dB
|
||||
m_settings.lnaEnhanceIndex = 0; // Off
|
||||
m_settings.biasCurrentIndex = 3; // V/U band
|
||||
m_settings.modeIndex = 0; // Linearity
|
||||
m_settings.m_mixerGainIndex = 1; // +12 dB
|
||||
m_settings.m_mixerFilterIndex = 8; // 1.9 MHz
|
||||
m_settings.m_gain1Index = 1; // +6 dB
|
||||
m_settings.m_rcFilterIndex = 15; // 1.0 MHz
|
||||
m_settings.m_gain2Index = 1; // +3 dB
|
||||
m_settings.m_gain3Index = 1; // +3 dB
|
||||
m_settings.m_gain4Index = 0; // 0 dB
|
||||
m_settings.m_ifFilterIndex = 31; // 2.15 MHz
|
||||
m_settings.m_gain5Index = 0; // +3 dB
|
||||
m_settings.m_gain6Index = 0; // +3 dB
|
||||
m_settings.m_lnaEnhanceIndex = 0; // Off
|
||||
m_settings.m_biasCurrentIndex = 3; // V/U band
|
||||
m_settings.m_modeIndex = 0; // Linearity
|
||||
displaySettings();
|
||||
sendSettings();
|
||||
}
|
||||
|
@ -35,7 +35,7 @@ private:
|
||||
Ui::FCDProGui* ui;
|
||||
|
||||
PluginAPI* m_pluginAPI;
|
||||
FCDProInput::Settings m_settings;
|
||||
FCDProSettings m_settings;
|
||||
QTimer m_updateTimer;
|
||||
std::vector<int> m_gains;
|
||||
SampleSource* m_sampleSource;
|
||||
@ -46,6 +46,8 @@ private:
|
||||
private slots:
|
||||
void on_centerFrequency_changed(quint64 value);
|
||||
void on_ppm_valueChanged(int value);
|
||||
void on_dcOffset_toggled(bool checked);
|
||||
void on_iqImbalance_toggled(bool checked);
|
||||
// TOOD: defaults push button
|
||||
void on_lnaGain_currentIndexChanged(int index);
|
||||
void on_rfFilter_currentIndexChanged(int index);
|
||||
|
@ -6,8 +6,8 @@
|
||||
<rect>
|
||||
<x>0</x>
|
||||
<y>0</y>
|
||||
<width>259</width>
|
||||
<height>324</height>
|
||||
<width>267</width>
|
||||
<height>352</height>
|
||||
</rect>
|
||||
</property>
|
||||
<property name="sizePolicy">
|
||||
@ -93,13 +93,6 @@
|
||||
</item>
|
||||
</layout>
|
||||
</item>
|
||||
<item>
|
||||
<widget class="Line" name="line_4">
|
||||
<property name="orientation">
|
||||
<enum>Qt::Horizontal</enum>
|
||||
</property>
|
||||
</widget>
|
||||
</item>
|
||||
<item>
|
||||
<layout class="QHBoxLayout" name="layoutPPM">
|
||||
<item>
|
||||
@ -137,6 +130,44 @@
|
||||
</item>
|
||||
</layout>
|
||||
</item>
|
||||
<item>
|
||||
<layout class="QHBoxLayout" name="horizontalLayout">
|
||||
<item>
|
||||
<widget class="QLabel" name="corrLabel">
|
||||
<property name="text">
|
||||
<string>Auto corr</string>
|
||||
</property>
|
||||
</widget>
|
||||
</item>
|
||||
<item>
|
||||
<widget class="ButtonSwitch" name="dcOffset">
|
||||
<property name="toolTip">
|
||||
<string>DC offset auto correction</string>
|
||||
</property>
|
||||
<property name="text">
|
||||
<string>DC offset</string>
|
||||
</property>
|
||||
</widget>
|
||||
</item>
|
||||
<item>
|
||||
<widget class="ButtonSwitch" name="iqImbalance">
|
||||
<property name="toolTip">
|
||||
<string>IQ imbalance auto correction</string>
|
||||
</property>
|
||||
<property name="text">
|
||||
<string>IQ imbalance</string>
|
||||
</property>
|
||||
</widget>
|
||||
</item>
|
||||
</layout>
|
||||
</item>
|
||||
<item>
|
||||
<widget class="Line" name="line_4">
|
||||
<property name="orientation">
|
||||
<enum>Qt::Horizontal</enum>
|
||||
</property>
|
||||
</widget>
|
||||
</item>
|
||||
<item>
|
||||
<layout class="QHBoxLayout" name="layoutBiasT">
|
||||
<item>
|
||||
@ -349,6 +380,11 @@
|
||||
<header>gui/valuedial.h</header>
|
||||
<container>1</container>
|
||||
</customwidget>
|
||||
<customwidget>
|
||||
<class>ButtonSwitch</class>
|
||||
<extends>QToolButton</extends>
|
||||
<header>gui/buttonswitch.h</header>
|
||||
</customwidget>
|
||||
</customwidgets>
|
||||
<resources/>
|
||||
<connections/>
|
||||
|
@ -25,98 +25,12 @@
|
||||
#include "fcdproinput.h"
|
||||
|
||||
#include "fcdprogui.h"
|
||||
#include "fcdproserializer.h"
|
||||
#include "fcdprothread.h"
|
||||
#include "fcdtraits.h"
|
||||
#include "fcdproconst.h"
|
||||
|
||||
MESSAGE_CLASS_DEFINITION(FCDProInput::MsgConfigureFCD, Message)
|
||||
|
||||
FCDProInput::Settings::Settings()
|
||||
{
|
||||
resetToDefaults();
|
||||
}
|
||||
|
||||
void FCDProInput::Settings::resetToDefaults()
|
||||
{
|
||||
centerFrequency = 435000000;
|
||||
LOppmTenths = 0;
|
||||
lnaGainIndex = 0;
|
||||
rfFilterIndex = 0;
|
||||
lnaEnhanceIndex = 0;
|
||||
bandIndex = 0;
|
||||
mixerGainIndex = 0;
|
||||
mixerFilterIndex = 0;
|
||||
biasCurrentIndex = 0;
|
||||
modeIndex = 0;
|
||||
gain1Index = 0;
|
||||
rcFilterIndex = 0;
|
||||
gain2Index = 0;
|
||||
gain3Index = 0;
|
||||
gain4Index = 0;
|
||||
ifFilterIndex = 0;
|
||||
gain5Index = 0;
|
||||
gain6Index = 0;
|
||||
}
|
||||
|
||||
QByteArray FCDProInput::Settings::serialize() const
|
||||
{
|
||||
FCDProSerializer::FCDData data;
|
||||
|
||||
data.m_data.m_frequency = centerFrequency;
|
||||
data.m_LOppmTenths = LOppmTenths;
|
||||
data.m_lnaGainIndex = lnaGainIndex;
|
||||
data.m_rfFilterIndex = rfFilterIndex;
|
||||
data.m_lnaEnhanceIndex = lnaEnhanceIndex;
|
||||
data.m_bandIndex = bandIndex;
|
||||
data.m_mixerGainIndex = mixerGainIndex;
|
||||
data.m_mixerFilterIndex = mixerFilterIndex;
|
||||
data.m_biasCurrentIndex = biasCurrentIndex;
|
||||
data.m_modeIndex = modeIndex;
|
||||
data.m_gain1Index = gain1Index;
|
||||
data.m_rcFilterIndex = rcFilterIndex;
|
||||
data.m_gain2Index = gain2Index;
|
||||
data.m_gain3Index = gain3Index;
|
||||
data.m_gain4Index = gain4Index;
|
||||
data.m_ifFilterIndex = ifFilterIndex;
|
||||
data.m_gain5Index = gain5Index;
|
||||
data.m_gain6Index = gain6Index;
|
||||
|
||||
QByteArray byteArray;
|
||||
|
||||
FCDProSerializer::writeSerializedData(data, byteArray);
|
||||
|
||||
return byteArray;
|
||||
}
|
||||
|
||||
bool FCDProInput::Settings::deserialize(const QByteArray& serializedData)
|
||||
{
|
||||
FCDProSerializer::FCDData data;
|
||||
|
||||
bool valid = FCDProSerializer::readSerializedData(serializedData, data);
|
||||
|
||||
centerFrequency = data.m_data.m_frequency;
|
||||
LOppmTenths = data.m_LOppmTenths;
|
||||
lnaGainIndex = data.m_lnaGainIndex;
|
||||
rfFilterIndex = data.m_rfFilterIndex;
|
||||
lnaEnhanceIndex = data.m_lnaEnhanceIndex;
|
||||
bandIndex = data.m_bandIndex;
|
||||
mixerGainIndex = data.m_mixerGainIndex;
|
||||
mixerFilterIndex = data.m_mixerFilterIndex;
|
||||
biasCurrentIndex = data.m_biasCurrentIndex;
|
||||
modeIndex = data.m_modeIndex;
|
||||
gain1Index = data.m_gain1Index;
|
||||
rcFilterIndex = data.m_rcFilterIndex;
|
||||
gain2Index = data.m_gain2Index;
|
||||
gain3Index = data.m_gain3Index;
|
||||
gain4Index = data.m_gain4Index;
|
||||
ifFilterIndex = data.m_ifFilterIndex;
|
||||
gain5Index = data.m_gain5Index;
|
||||
gain6Index = data.m_gain6Index;
|
||||
|
||||
return valid;
|
||||
}
|
||||
|
||||
FCDProInput::FCDProInput() :
|
||||
m_dev(0),
|
||||
m_settings(),
|
||||
@ -210,7 +124,7 @@ int FCDProInput::getSampleRate() const
|
||||
|
||||
quint64 FCDProInput::getCenterFrequency() const
|
||||
{
|
||||
return m_settings.centerFrequency;
|
||||
return m_settings.m_centerFrequency;
|
||||
}
|
||||
|
||||
bool FCDProInput::handleMessage(const Message& message)
|
||||
@ -228,186 +142,186 @@ bool FCDProInput::handleMessage(const Message& message)
|
||||
}
|
||||
}
|
||||
|
||||
void FCDProInput::applySettings(const Settings& settings, bool force)
|
||||
void FCDProInput::applySettings(const FCDProSettings& settings, bool force)
|
||||
{
|
||||
bool signalChange = false;
|
||||
|
||||
if ((m_settings.centerFrequency != settings.centerFrequency) || force)
|
||||
if ((m_settings.m_centerFrequency != settings.m_centerFrequency) || force)
|
||||
{
|
||||
qDebug() << "FCDProInput::applySettings: fc: " << settings.centerFrequency;
|
||||
m_settings.centerFrequency = settings.centerFrequency;
|
||||
qDebug() << "FCDProInput::applySettings: fc: " << settings.m_centerFrequency;
|
||||
m_settings.m_centerFrequency = settings.m_centerFrequency;
|
||||
|
||||
if (m_dev != 0)
|
||||
{
|
||||
set_center_freq((double) m_settings.centerFrequency);
|
||||
set_center_freq((double) m_settings.m_centerFrequency);
|
||||
}
|
||||
|
||||
signalChange = true;
|
||||
}
|
||||
|
||||
if ((m_settings.lnaGainIndex != settings.lnaGainIndex) || force)
|
||||
if ((m_settings.m_lnaGainIndex != settings.m_lnaGainIndex) || force)
|
||||
{
|
||||
m_settings.lnaGainIndex = settings.lnaGainIndex;
|
||||
m_settings.m_lnaGainIndex = settings.m_lnaGainIndex;
|
||||
|
||||
if (m_dev != 0)
|
||||
{
|
||||
set_lnaGain(settings.lnaGainIndex);
|
||||
set_lnaGain(settings.m_lnaGainIndex);
|
||||
}
|
||||
}
|
||||
|
||||
if ((m_settings.rfFilterIndex != settings.rfFilterIndex) || force)
|
||||
if ((m_settings.m_rfFilterIndex != settings.m_rfFilterIndex) || force)
|
||||
{
|
||||
m_settings.rfFilterIndex = settings.rfFilterIndex;
|
||||
m_settings.m_rfFilterIndex = settings.m_rfFilterIndex;
|
||||
|
||||
if (m_dev != 0)
|
||||
{
|
||||
set_rfFilter(settings.rfFilterIndex);
|
||||
set_rfFilter(settings.m_rfFilterIndex);
|
||||
}
|
||||
}
|
||||
|
||||
if ((m_settings.lnaEnhanceIndex != settings.lnaEnhanceIndex) || force)
|
||||
if ((m_settings.m_lnaEnhanceIndex != settings.m_lnaEnhanceIndex) || force)
|
||||
{
|
||||
m_settings.lnaEnhanceIndex = settings.lnaEnhanceIndex;
|
||||
m_settings.m_lnaEnhanceIndex = settings.m_lnaEnhanceIndex;
|
||||
|
||||
if (m_dev != 0)
|
||||
{
|
||||
set_lnaEnhance(settings.lnaEnhanceIndex);
|
||||
set_lnaEnhance(settings.m_lnaEnhanceIndex);
|
||||
}
|
||||
}
|
||||
|
||||
if ((m_settings.bandIndex != settings.bandIndex) || force)
|
||||
if ((m_settings.m_bandIndex != settings.m_bandIndex) || force)
|
||||
{
|
||||
m_settings.bandIndex = settings.bandIndex;
|
||||
m_settings.m_bandIndex = settings.m_bandIndex;
|
||||
|
||||
if (m_dev != 0)
|
||||
{
|
||||
set_band(settings.bandIndex);
|
||||
set_band(settings.m_bandIndex);
|
||||
}
|
||||
}
|
||||
|
||||
if ((m_settings.mixerGainIndex != settings.mixerGainIndex) || force)
|
||||
if ((m_settings.m_mixerGainIndex != settings.m_mixerGainIndex) || force)
|
||||
{
|
||||
m_settings.mixerGainIndex = settings.mixerGainIndex;
|
||||
m_settings.m_mixerGainIndex = settings.m_mixerGainIndex;
|
||||
|
||||
if (m_dev != 0)
|
||||
{
|
||||
set_mixerGain(settings.mixerGainIndex);
|
||||
set_mixerGain(settings.m_mixerGainIndex);
|
||||
}
|
||||
}
|
||||
|
||||
if ((m_settings.mixerFilterIndex != settings.mixerFilterIndex) || force)
|
||||
if ((m_settings.m_mixerFilterIndex != settings.m_mixerFilterIndex) || force)
|
||||
{
|
||||
m_settings.mixerFilterIndex = settings.mixerFilterIndex;
|
||||
m_settings.m_mixerFilterIndex = settings.m_mixerFilterIndex;
|
||||
|
||||
if (m_dev != 0)
|
||||
{
|
||||
set_mixerFilter(settings.mixerFilterIndex);
|
||||
set_mixerFilter(settings.m_mixerFilterIndex);
|
||||
}
|
||||
}
|
||||
|
||||
if ((m_settings.biasCurrentIndex != settings.biasCurrentIndex) || force)
|
||||
if ((m_settings.m_biasCurrentIndex != settings.m_biasCurrentIndex) || force)
|
||||
{
|
||||
m_settings.biasCurrentIndex = settings.biasCurrentIndex;
|
||||
m_settings.m_biasCurrentIndex = settings.m_biasCurrentIndex;
|
||||
|
||||
if (m_dev != 0)
|
||||
{
|
||||
set_biasCurrent(settings.biasCurrentIndex);
|
||||
set_biasCurrent(settings.m_biasCurrentIndex);
|
||||
}
|
||||
}
|
||||
|
||||
if ((m_settings.modeIndex != settings.modeIndex) || force)
|
||||
if ((m_settings.m_modeIndex != settings.m_modeIndex) || force)
|
||||
{
|
||||
m_settings.modeIndex = settings.modeIndex;
|
||||
m_settings.m_modeIndex = settings.m_modeIndex;
|
||||
|
||||
if (m_dev != 0)
|
||||
{
|
||||
set_mode(settings.modeIndex);
|
||||
set_mode(settings.m_modeIndex);
|
||||
}
|
||||
}
|
||||
|
||||
if ((m_settings.gain1Index != settings.gain1Index) || force)
|
||||
if ((m_settings.m_gain1Index != settings.m_gain1Index) || force)
|
||||
{
|
||||
m_settings.gain1Index = settings.gain1Index;
|
||||
m_settings.m_gain1Index = settings.m_gain1Index;
|
||||
|
||||
if (m_dev != 0)
|
||||
{
|
||||
set_gain1(settings.gain1Index);
|
||||
set_gain1(settings.m_gain1Index);
|
||||
}
|
||||
}
|
||||
|
||||
if ((m_settings.rcFilterIndex != settings.rcFilterIndex) || force)
|
||||
if ((m_settings.m_rcFilterIndex != settings.m_rcFilterIndex) || force)
|
||||
{
|
||||
m_settings.rcFilterIndex = settings.rcFilterIndex;
|
||||
m_settings.m_rcFilterIndex = settings.m_rcFilterIndex;
|
||||
|
||||
if (m_dev != 0)
|
||||
{
|
||||
set_rcFilter(settings.rcFilterIndex);
|
||||
set_rcFilter(settings.m_rcFilterIndex);
|
||||
}
|
||||
}
|
||||
|
||||
if ((m_settings.gain2Index != settings.gain2Index) || force)
|
||||
if ((m_settings.m_gain2Index != settings.m_gain2Index) || force)
|
||||
{
|
||||
m_settings.gain2Index = settings.gain2Index;
|
||||
m_settings.m_gain2Index = settings.m_gain2Index;
|
||||
|
||||
if (m_dev != 0)
|
||||
{
|
||||
set_gain2(settings.gain2Index);
|
||||
set_gain2(settings.m_gain2Index);
|
||||
}
|
||||
}
|
||||
|
||||
if ((m_settings.gain3Index != settings.gain3Index) || force)
|
||||
if ((m_settings.m_gain3Index != settings.m_gain3Index) || force)
|
||||
{
|
||||
m_settings.gain3Index = settings.gain3Index;
|
||||
m_settings.m_gain3Index = settings.m_gain3Index;
|
||||
|
||||
if (m_dev != 0)
|
||||
{
|
||||
set_gain3(settings.gain3Index);
|
||||
set_gain3(settings.m_gain3Index);
|
||||
}
|
||||
}
|
||||
|
||||
if ((m_settings.gain4Index != settings.gain4Index) || force)
|
||||
if ((m_settings.m_gain4Index != settings.m_gain4Index) || force)
|
||||
{
|
||||
m_settings.gain4Index = settings.gain4Index;
|
||||
m_settings.m_gain4Index = settings.m_gain4Index;
|
||||
|
||||
if (m_dev != 0)
|
||||
{
|
||||
set_gain4(settings.gain4Index);
|
||||
set_gain4(settings.m_gain4Index);
|
||||
}
|
||||
}
|
||||
|
||||
if ((m_settings.ifFilterIndex != settings.ifFilterIndex) || force)
|
||||
if ((m_settings.m_ifFilterIndex != settings.m_ifFilterIndex) || force)
|
||||
{
|
||||
m_settings.ifFilterIndex = settings.ifFilterIndex;
|
||||
m_settings.m_ifFilterIndex = settings.m_ifFilterIndex;
|
||||
|
||||
if (m_dev != 0)
|
||||
{
|
||||
set_ifFilter(settings.ifFilterIndex);
|
||||
set_ifFilter(settings.m_ifFilterIndex);
|
||||
}
|
||||
}
|
||||
|
||||
if ((m_settings.gain5Index != settings.gain5Index) || force)
|
||||
if ((m_settings.m_gain5Index != settings.m_gain5Index) || force)
|
||||
{
|
||||
m_settings.gain5Index = settings.gain5Index;
|
||||
m_settings.m_gain5Index = settings.m_gain5Index;
|
||||
|
||||
if (m_dev != 0)
|
||||
{
|
||||
set_gain5(settings.gain5Index);
|
||||
set_gain5(settings.m_gain5Index);
|
||||
}
|
||||
}
|
||||
|
||||
if ((m_settings.gain6Index != settings.gain6Index) || force)
|
||||
if ((m_settings.m_gain6Index != settings.m_gain6Index) || force)
|
||||
{
|
||||
m_settings.gain6Index = settings.gain6Index;
|
||||
m_settings.m_gain6Index = settings.m_gain6Index;
|
||||
|
||||
if (m_dev != 0)
|
||||
{
|
||||
set_gain6(settings.gain6Index);
|
||||
set_gain6(settings.m_gain6Index);
|
||||
}
|
||||
}
|
||||
|
||||
if ((m_settings.LOppmTenths != settings.LOppmTenths) || force)
|
||||
if ((m_settings.m_LOppmTenths != settings.m_LOppmTenths) || force)
|
||||
{
|
||||
m_settings.LOppmTenths = settings.LOppmTenths;
|
||||
m_settings.m_LOppmTenths = settings.m_LOppmTenths;
|
||||
|
||||
if (m_dev != 0)
|
||||
{
|
||||
@ -415,16 +329,28 @@ void FCDProInput::applySettings(const Settings& settings, bool force)
|
||||
}
|
||||
}
|
||||
|
||||
if ((m_settings.m_dcBlock != settings.m_dcBlock) || force)
|
||||
{
|
||||
m_settings.m_dcBlock = settings.m_dcBlock;
|
||||
DSPEngine::instance()->configureCorrections(m_settings.m_dcBlock, m_settings.m_iqCorrection);
|
||||
}
|
||||
|
||||
if ((m_settings.m_iqCorrection != settings.m_iqCorrection) || force)
|
||||
{
|
||||
m_settings.m_iqCorrection = settings.m_iqCorrection;
|
||||
DSPEngine::instance()->configureCorrections(m_settings.m_dcBlock, m_settings.m_iqCorrection);
|
||||
}
|
||||
|
||||
if (signalChange)
|
||||
{
|
||||
DSPSignalNotification *notif = new DSPSignalNotification(fcd_traits<Pro>::sampleRate, m_settings.centerFrequency);
|
||||
DSPSignalNotification *notif = new DSPSignalNotification(fcd_traits<Pro>::sampleRate, m_settings.m_centerFrequency);
|
||||
DSPEngine::instance()->getInputMessageQueue()->push(notif);
|
||||
}
|
||||
}
|
||||
|
||||
void FCDProInput::set_center_freq(double freq)
|
||||
{
|
||||
freq += freq*(((double) m_settings.LOppmTenths)/10000000.0);
|
||||
freq += freq*(((double) m_settings.m_LOppmTenths)/10000000.0);
|
||||
|
||||
if (fcdAppSetFreq(m_dev, freq) == FCD_MODE_NONE)
|
||||
{
|
||||
@ -684,5 +610,5 @@ void FCDProInput::set_gain6(int index)
|
||||
|
||||
void FCDProInput::set_lo_ppm()
|
||||
{
|
||||
set_center_freq((double) m_settings.centerFrequency);
|
||||
set_center_freq((double) m_settings.m_centerFrequency);
|
||||
}
|
||||
|
@ -19,6 +19,7 @@
|
||||
#define INCLUDE_FCDPROINPUT_H
|
||||
|
||||
#include "dsp/samplesource.h"
|
||||
#include "fcdprosettings.h"
|
||||
#include "fcdhid.h"
|
||||
#include <QString>
|
||||
#include <inttypes.h>
|
||||
@ -32,46 +33,21 @@ class FCDProThread;
|
||||
|
||||
class FCDProInput : public SampleSource {
|
||||
public:
|
||||
struct Settings {
|
||||
Settings();
|
||||
quint64 centerFrequency;
|
||||
qint32 LOppmTenths;
|
||||
qint32 lnaGainIndex;
|
||||
qint32 rfFilterIndex;
|
||||
qint32 lnaEnhanceIndex;
|
||||
qint32 bandIndex;
|
||||
qint32 mixerGainIndex;
|
||||
qint32 mixerFilterIndex;
|
||||
qint32 biasCurrentIndex;
|
||||
qint32 modeIndex;
|
||||
qint32 gain1Index;
|
||||
qint32 rcFilterIndex;
|
||||
qint32 gain2Index;
|
||||
qint32 gain3Index;
|
||||
qint32 gain4Index;
|
||||
qint32 ifFilterIndex;
|
||||
qint32 gain5Index;
|
||||
qint32 gain6Index;
|
||||
void resetToDefaults();
|
||||
QByteArray serialize() const;
|
||||
bool deserialize(const QByteArray& data);
|
||||
};
|
||||
|
||||
class MsgConfigureFCD : public Message {
|
||||
MESSAGE_CLASS_DECLARATION
|
||||
|
||||
public:
|
||||
const Settings& getSettings() const { return m_settings; }
|
||||
const FCDProSettings& getSettings() const { return m_settings; }
|
||||
|
||||
static MsgConfigureFCD* create(const Settings& settings)
|
||||
static MsgConfigureFCD* create(const FCDProSettings& settings)
|
||||
{
|
||||
return new MsgConfigureFCD(settings);
|
||||
}
|
||||
|
||||
private:
|
||||
Settings m_settings;
|
||||
FCDProSettings m_settings;
|
||||
|
||||
MsgConfigureFCD(const Settings& settings) :
|
||||
MsgConfigureFCD(const FCDProSettings& settings) :
|
||||
Message(),
|
||||
m_settings(settings)
|
||||
{ }
|
||||
@ -110,12 +86,12 @@ public:
|
||||
void set_gain6(int index);
|
||||
|
||||
private:
|
||||
void applySettings(const Settings& settings, bool force);
|
||||
void applySettings(const FCDProSettings& settings, bool force);
|
||||
void set_lo_ppm();
|
||||
|
||||
hid_device *m_dev;
|
||||
QMutex m_mutex;
|
||||
Settings m_settings;
|
||||
FCDProSettings m_settings;
|
||||
FCDProThread* m_FCDThread;
|
||||
QString m_deviceDescription;
|
||||
};
|
||||
|
@ -31,6 +31,8 @@ const PluginDescriptor FCDProPlugin::m_pluginDescriptor = {
|
||||
QString("https://github.com/f4exb/sdrangel")
|
||||
};
|
||||
|
||||
const QString FCDProPlugin::m_deviceTypeID = FCDPRO_DEVICE_TYPE_ID;
|
||||
|
||||
FCDProPlugin::FCDProPlugin(QObject* parent) :
|
||||
QObject(parent)
|
||||
{
|
||||
|
@ -4,10 +4,12 @@
|
||||
#include <QObject>
|
||||
#include "plugin/plugininterface.h"
|
||||
|
||||
#define FCDPRO_DEVICE_TYPE_ID "sdrangel.samplesource.fcdpro"
|
||||
|
||||
class FCDProPlugin : public QObject, public PluginInterface {
|
||||
Q_OBJECT
|
||||
Q_INTERFACES(PluginInterface)
|
||||
Q_PLUGIN_METADATA(IID "org.osmocom.sdr.samplesource.fcdpro")
|
||||
Q_PLUGIN_METADATA(IID FCDPRO_DEVICE_TYPE_ID)
|
||||
|
||||
public:
|
||||
explicit FCDProPlugin(QObject* parent = NULL);
|
||||
@ -18,6 +20,8 @@ public:
|
||||
SampleSourceDevices enumSampleSources();
|
||||
PluginGUI* createSampleSourcePluginGUI(const QString& sourceName, const QByteArray& address);
|
||||
|
||||
static const QString m_deviceTypeID;
|
||||
|
||||
private:
|
||||
static const PluginDescriptor m_pluginDescriptor;
|
||||
|
||||
|
@ -1,113 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////////////
|
||||
// Copyright (C) 2015 Edouard Griffiths, F4EXB //
|
||||
// //
|
||||
// This program is free software; you can redistribute it and/or modify //
|
||||
// it under the terms of the GNU General Public License as published by //
|
||||
// the Free Software Foundation as version 3 of the License, or //
|
||||
// //
|
||||
// This program is distributed in the hope that it will be useful, //
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of //
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
|
||||
// GNU General Public License V3 for more details. //
|
||||
// //
|
||||
// You should have received a copy of the GNU General Public License //
|
||||
// along with this program. If not, see <http://www.gnu.org/licenses/>. //
|
||||
///////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include "fcdproserializer.h"
|
||||
|
||||
void FCDProSerializer::writeSerializedData(const FCDData& data, QByteArray& serializedData)
|
||||
{
|
||||
QByteArray sampleSourceSerialized;
|
||||
SampleSourceSerializer::writeSerializedData(data.m_data, sampleSourceSerialized);
|
||||
|
||||
SimpleSerializer s(1);
|
||||
|
||||
s.writeBlob(1, sampleSourceSerialized);
|
||||
s.writeS32(2, data.m_LOppmTenths);
|
||||
s.writeS32(3, data.m_lnaGainIndex);
|
||||
s.writeS32(4, data.m_rfFilterIndex);
|
||||
s.writeS32(5, data.m_lnaEnhanceIndex);
|
||||
s.writeS32(6, data.m_bandIndex);
|
||||
s.writeS32(7, data.m_mixerGainIndex);
|
||||
s.writeS32(8, data.m_mixerFilterIndex);
|
||||
s.writeS32(9, data.m_biasCurrentIndex);
|
||||
s.writeS32(10, data.m_modeIndex);
|
||||
s.writeS32(11, data.m_gain1Index);
|
||||
s.writeS32(12, data.m_rcFilterIndex);
|
||||
s.writeS32(13, data.m_gain2Index);
|
||||
s.writeS32(14, data.m_gain3Index);
|
||||
s.writeS32(15, data.m_gain4Index);
|
||||
s.writeS32(16, data.m_ifFilterIndex);
|
||||
s.writeS32(17, data.m_gain5Index);
|
||||
s.writeS32(18, data.m_gain6Index);
|
||||
|
||||
serializedData = s.final();
|
||||
}
|
||||
|
||||
bool FCDProSerializer::readSerializedData(const QByteArray& serializedData, FCDData& data)
|
||||
{
|
||||
bool valid = SampleSourceSerializer::readSerializedData(serializedData, data.m_data);
|
||||
|
||||
QByteArray sampleSourceSerialized;
|
||||
|
||||
SimpleDeserializer d(serializedData);
|
||||
|
||||
if (!d.isValid())
|
||||
{
|
||||
setDefaults(data);
|
||||
return false;
|
||||
}
|
||||
|
||||
if (d.getVersion() == SampleSourceSerializer::getSerializerVersion())
|
||||
{
|
||||
int intval;
|
||||
|
||||
d.readBlob(1, &sampleSourceSerialized);
|
||||
d.readS32(2, &data.m_LOppmTenths);
|
||||
d.readS32(3, &data.m_lnaGainIndex);
|
||||
d.readS32(4, &data.m_rfFilterIndex);
|
||||
d.readS32(5, &data.m_lnaEnhanceIndex);
|
||||
d.readS32(6, &data.m_bandIndex);
|
||||
d.readS32(7, &data.m_mixerGainIndex);
|
||||
d.readS32(8, &data.m_mixerFilterIndex);
|
||||
d.readS32(9, &data.m_biasCurrentIndex);
|
||||
d.readS32(10, &data.m_modeIndex);
|
||||
d.readS32(11, &data.m_gain1Index);
|
||||
d.readS32(12, &data.m_rcFilterIndex);
|
||||
d.readS32(13, &data.m_gain2Index);
|
||||
d.readS32(14, &data.m_gain3Index);
|
||||
d.readS32(15, &data.m_gain4Index);
|
||||
d.readS32(16, &data.m_ifFilterIndex);
|
||||
d.readS32(17, &data.m_gain5Index);
|
||||
d.readS32(18, &data.m_gain6Index);
|
||||
|
||||
return SampleSourceSerializer::readSerializedData(sampleSourceSerialized, data.m_data);
|
||||
}
|
||||
else
|
||||
{
|
||||
setDefaults(data);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
void FCDProSerializer::setDefaults(FCDData& data)
|
||||
{
|
||||
data.m_LOppmTenths = 0;
|
||||
data.m_lnaGainIndex = 0;
|
||||
data.m_rfFilterIndex = 0;
|
||||
data.m_lnaEnhanceIndex = 0;
|
||||
data.m_bandIndex = 0;
|
||||
data.m_mixerGainIndex = 0;
|
||||
data.m_mixerFilterIndex = 0;
|
||||
data.m_biasCurrentIndex = 0;
|
||||
data.m_modeIndex = 0;
|
||||
data.m_gain1Index = 0;
|
||||
data.m_rcFilterIndex = 0;
|
||||
data.m_gain2Index = 0;
|
||||
data.m_gain3Index = 0;
|
||||
data.m_gain4Index = 0;
|
||||
data.m_ifFilterIndex = 0;
|
||||
data.m_gain5Index = 0;
|
||||
data.m_gain6Index = 0;
|
||||
}
|
118
plugins/samplesource/fcdpro/fcdprosettings.cpp
Normal file
118
plugins/samplesource/fcdpro/fcdprosettings.cpp
Normal file
@ -0,0 +1,118 @@
|
||||
///////////////////////////////////////////////////////////////////////////////////
|
||||
// Copyright (C) 2015 Edouard Griffiths, F4EXB //
|
||||
// //
|
||||
// This program is free software; you can redistribute it and/or modify //
|
||||
// it under the terms of the GNU General Public License as published by //
|
||||
// the Free Software Foundation as version 3 of the License, or //
|
||||
// //
|
||||
// This program is distributed in the hope that it will be useful, //
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of //
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
|
||||
// GNU General Public License V3 for more details. //
|
||||
// //
|
||||
// You should have received a copy of the GNU General Public License //
|
||||
// along with this program. If not, see <http://www.gnu.org/licenses/>. //
|
||||
///////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <QtGlobal>
|
||||
#include "util/simpleserializer.h"
|
||||
#include "fcdprosettings.h"
|
||||
|
||||
FCDProSettings::FCDProSettings()
|
||||
{
|
||||
resetToDefaults();
|
||||
}
|
||||
|
||||
void FCDProSettings::resetToDefaults()
|
||||
{
|
||||
m_centerFrequency = 435000 * 1000;
|
||||
m_dcBlock = false;
|
||||
m_iqCorrection = false;
|
||||
m_LOppmTenths = 0;
|
||||
m_lnaGainIndex = 0;
|
||||
m_rfFilterIndex = 0;
|
||||
m_lnaEnhanceIndex = 0;
|
||||
m_bandIndex = 0;
|
||||
m_mixerGainIndex = 0;
|
||||
m_mixerFilterIndex = 0;
|
||||
m_biasCurrentIndex = 0;
|
||||
m_modeIndex = 0;
|
||||
m_gain1Index = 0;
|
||||
m_rcFilterIndex = 0;
|
||||
m_gain2Index = 0;
|
||||
m_gain3Index = 0;
|
||||
m_gain4Index = 0;
|
||||
m_ifFilterIndex = 0;
|
||||
m_gain5Index = 0;
|
||||
m_gain6Index = 0;
|
||||
}
|
||||
|
||||
QByteArray FCDProSettings::serialize() const
|
||||
{
|
||||
SimpleSerializer s(1);
|
||||
|
||||
s.writeBool(1, m_dcBlock);
|
||||
s.writeBool(2, m_iqCorrection);
|
||||
s.writeS32(3, m_LOppmTenths);
|
||||
s.writeS32(4, m_lnaGainIndex);
|
||||
s.writeS32(5, m_rfFilterIndex);
|
||||
s.writeS32(6, m_lnaEnhanceIndex);
|
||||
s.writeS32(7, m_bandIndex);
|
||||
s.writeS32(8, m_mixerGainIndex);
|
||||
s.writeS32(9, m_mixerFilterIndex);
|
||||
s.writeS32(10, m_biasCurrentIndex);
|
||||
s.writeS32(11, m_modeIndex);
|
||||
s.writeS32(12, m_gain1Index);
|
||||
s.writeS32(13, m_rcFilterIndex);
|
||||
s.writeS32(14, m_gain2Index);
|
||||
s.writeS32(15, m_gain3Index);
|
||||
s.writeS32(16, m_gain4Index);
|
||||
s.writeS32(17, m_ifFilterIndex);
|
||||
s.writeS32(18, m_gain5Index);
|
||||
s.writeS32(19, m_gain6Index);
|
||||
|
||||
return s.final();
|
||||
}
|
||||
|
||||
bool FCDProSettings::deserialize(const QByteArray& data)
|
||||
{
|
||||
SimpleDeserializer d(data);
|
||||
|
||||
if (!d.isValid())
|
||||
{
|
||||
resetToDefaults();
|
||||
return false;
|
||||
}
|
||||
|
||||
if (d.getVersion() == 1)
|
||||
{
|
||||
int intval;
|
||||
|
||||
d.readBool(1, &m_dcBlock, false);
|
||||
d.readBool(2, &m_iqCorrection, false);
|
||||
d.readS32(3, &m_LOppmTenths, 0);
|
||||
d.readS32(4, &m_lnaGainIndex, 0);
|
||||
d.readS32(5, &m_rfFilterIndex, 0);
|
||||
d.readS32(6, &m_lnaEnhanceIndex, 0);
|
||||
d.readS32(7, &m_bandIndex, 0);
|
||||
d.readS32(8, &m_mixerGainIndex, 0);
|
||||
d.readS32(9, &m_mixerFilterIndex, 0);
|
||||
d.readS32(10, &m_biasCurrentIndex, 0);
|
||||
d.readS32(11, &m_modeIndex, 0);
|
||||
d.readS32(12, &m_gain1Index, 0);
|
||||
d.readS32(13, &m_rcFilterIndex, 0);
|
||||
d.readS32(14, &m_gain2Index, 0);
|
||||
d.readS32(15, &m_gain3Index, 0);
|
||||
d.readS32(16, &m_gain4Index, 0);
|
||||
d.readS32(17, &m_ifFilterIndex, 0);
|
||||
d.readS32(18, &m_gain5Index, 0);
|
||||
d.readS32(19, &m_gain6Index, 0);
|
||||
|
||||
return true;
|
||||
}
|
||||
else
|
||||
{
|
||||
resetToDefaults();
|
||||
return false;
|
||||
}
|
||||
}
|
@ -14,41 +14,38 @@
|
||||
// along with this program. If not, see <http://www.gnu.org/licenses/>. //
|
||||
///////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef PLUGINS_SAMPLESOURCE_FCD_FCDPROSERIALIZER_H_
|
||||
#define PLUGINS_SAMPLESOURCE_FCD_FCDPROSERIALIZER_H_
|
||||
#ifndef _FCDPRO_FCDPROSETTINGS_H_
|
||||
#define _FCDPRO_FCDPROSETTINGS_H_
|
||||
|
||||
#include "util/samplesourceserializer.h"
|
||||
struct FCDProSettings {
|
||||
quint64 m_centerFrequency;
|
||||
qint32 m_LOppmTenths;
|
||||
qint32 m_lnaGainIndex;
|
||||
qint32 m_rfFilterIndex;
|
||||
qint32 m_lnaEnhanceIndex;
|
||||
qint32 m_bandIndex;
|
||||
qint32 m_mixerGainIndex;
|
||||
qint32 m_mixerFilterIndex;
|
||||
qint32 m_biasCurrentIndex;
|
||||
qint32 m_modeIndex;
|
||||
qint32 m_gain1Index;
|
||||
qint32 m_rcFilterIndex;
|
||||
qint32 m_gain2Index;
|
||||
qint32 m_gain3Index;
|
||||
qint32 m_gain4Index;
|
||||
qint32 m_ifFilterIndex;
|
||||
qint32 m_gain5Index;
|
||||
qint32 m_gain6Index;
|
||||
bool m_dcBlock;
|
||||
bool m_iqCorrection;
|
||||
|
||||
class FCDProSerializer
|
||||
{
|
||||
public:
|
||||
struct FCDData
|
||||
{
|
||||
SampleSourceSerializer::Data m_data;
|
||||
qint32 m_LOppmTenths;
|
||||
qint32 m_lnaGainIndex;
|
||||
qint32 m_rfFilterIndex;
|
||||
qint32 m_lnaEnhanceIndex;
|
||||
qint32 m_bandIndex;
|
||||
qint32 m_mixerGainIndex;
|
||||
qint32 m_mixerFilterIndex;
|
||||
qint32 m_biasCurrentIndex;
|
||||
qint32 m_modeIndex;
|
||||
qint32 m_gain1Index;
|
||||
qint32 m_rcFilterIndex;
|
||||
qint32 m_gain2Index;
|
||||
qint32 m_gain3Index;
|
||||
qint32 m_gain4Index;
|
||||
qint32 m_ifFilterIndex;
|
||||
qint32 m_gain5Index;
|
||||
qint32 m_gain6Index;
|
||||
};
|
||||
|
||||
static void writeSerializedData(const FCDData& data, QByteArray& serializedData);
|
||||
static bool readSerializedData(const QByteArray& serializedData, FCDData& data);
|
||||
static void setDefaults(FCDData& data);
|
||||
FCDProSettings();
|
||||
void resetToDefaults();
|
||||
QByteArray serialize() const;
|
||||
bool deserialize(const QByteArray& data);
|
||||
};
|
||||
|
||||
|
||||
|
||||
#endif /* PLUGINS_SAMPLESOURCE_FCD_FCDPROSERIALIZER_H_ */
|
||||
|
||||
#endif /* _FCDPRO_FCDPROSETTINGS_H_ */
|
Loading…
Reference in New Issue
Block a user