mirror
/
sdrangel
kopia lustrzana https://github.com/f4exb/sdrangel
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność

New preset design (single) applied to FCD Pro

pull/6/head
f4exb 2015-09-30 05:38:58 +02:00
rodzic ded446c43a
commit f50e717c20
12 zmienionych plików z 351 dodań i 389 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

4
fcdlib/fcdtraits.cpp
Wyświetl plik

@ -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
plugins/samplesource/fcdpro/CMakeLists.txt
Wyświetl plik

@ -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
)

120
plugins/samplesource/fcdpro/fcdprogui.cpp
Wyświetl plik

@ -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();
}

4
plugins/samplesource/fcdpro/fcdprogui.h
Wyświetl plik

@ -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);

54
plugins/samplesource/fcdpro/fcdprogui.ui
Wyświetl plik

@ -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/>

216
plugins/samplesource/fcdpro/fcdproinput.cpp
Wyświetl plik

@ -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);
}

38
plugins/samplesource/fcdpro/fcdproinput.h
Wyświetl plik

@ -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;
};

2
plugins/samplesource/fcdpro/fcdproplugin.cpp
Wyświetl plik

@ -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)
{

6
plugins/samplesource/fcdpro/fcdproplugin.h
Wyświetl plik

@ -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;

113
plugins/samplesource/fcdpro/fcdproserializer.cpp
Wyświetl plik

@ -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 100644
Wyświetl plik

@ -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;
}
}

61
plugins/samplesource/fcdpro/fcdproserializer.h → plugins/samplesource/fcdpro/fcdprosettings.h
Wyświetl plik

@ -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_ */