VE7UWU/sdrangel
1
0
Fork 0
mirror of https://github.com/f4exb/sdrangel.git synced 2024-11-23 00:18:37 -05:00
Code Issues Projects Releases Wiki Activity

Merge branch 'dev'

Browse Source
This commit is contained in:
f4exb 2015-09-11 21:46:10 +02:00
commit d109c54d5c
16 changed files with 2263 additions and 6 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
Readme.md
View File

@ -43,6 +43,16 @@ Use `cmake ../ -DV4L-RTL=ON` to build the Linux kernel driver for RTL-SDR (Exper
<h1>Supported hardware</h1>
<h2>Airspy</h2>
Airspy is supported through the libairspy library that should be installed in your system for proper build of the software and operation support. Add `libairspy-dev` to the list of dependencies to install.
If you use your own location for libairspy install directory you need to specify library and include locations. Example with `/opt/install/libairspy` with the following defines on `cmake` command line:
`-DLIBAIRSPY_LIBRARIES=/opt/install/libairspy/lib/libairspy.so -DLIBAIRSPY_INCLUDE_DIR=/opt/install/libairspy/include`
Please note that if you are using a recent version of libairspy (>= 1.0.6) the dynamic retrieval of sample rates is supported. To benefit from it you should modify the `plugins/samplesource/airspy/CMakeLists.txt` and change line `add_definitions(${QT_DEFINITIONS})` by `add_definitions("${QT_DEFINITIONS} -DLIBAIRSPY_DYN_RATES")`. In fact both lines are present with the last one commented out.
<h2>BladeRF</h2>
BladeRF is supported through the libbladerf library that should be installed in your system for proper build of the software and operation support. Add `libbladerf-dev` to the list of dependencies to install.

28
cmake/Modules/FindLibAIRSPY.cmake Normal file
View File

@ -0,0 +1,28 @@
if(NOT LIBAIRSPY_FOUND)
pkg_check_modules (LIBAIRSPY_PKG libairspy)
find_path(LIBAIRSPY_INCLUDE_DIR NAMES libairspy/airspy.h
PATHS
${LIBAIRSPY_PKG_INCLUDE_DIRS}
/usr/include
/usr/local/include
)
find_library(LIBAIRSPY_LIBRARIES NAMES airspy
PATHS
${LIBAIRSPY_PKG_LIBRARY_DIRS}
/usr/lib
/usr/local/lib
)
if(LIBAIRSPY_INCLUDE_DIR AND LIBAIRSPY_LIBRARIES)
set(LIBAIRSPY_FOUND TRUE CACHE INTERNAL "libairspy found")
message(STATUS "Found libairspy: ${LIBAIRSPY_INCLUDE_DIR}, ${LIBAIRSPY_LIBRARIES}")
else(LIBAIRSPY_INCLUDE_DIR AND LIBAIRSPY_LIBRARIES)
set(LIBAIRSPY_FOUND FALSE CACHE INTERNAL "libairspy found")
message(STATUS "libairspy not found.")
endif(LIBAIRSPY_INCLUDE_DIR AND LIBAIRSPY_LIBRARIES)
mark_as_advanced(LIBAIRSPY_INCLUDE_DIR LIBAIRSPY_LIBRARIES)
endif(NOT LIBAIRSPY_FOUND)

155
include-gpl/dsp/decimators.h
View File

@ -34,6 +34,8 @@ struct decimation_shifts
static const uint post16 = 0;
static const uint pre32 = 0;
static const uint post32 = 0;
static const uint pre64 = 0;
static const uint post64 = 0;
};
template<>
@ -50,6 +52,8 @@ struct decimation_shifts<16, 16>
static const uint post16 = 4;
static const uint pre32 = 0;
static const uint post32 = 5;
static const uint pre64 = 0;
static const uint post64 = 6;
};
template<>
@ -66,22 +70,26 @@ struct decimation_shifts<16, 12>
static const uint post16 = 0;
static const uint pre32 = 0;
static const uint post32 = 1;
static const uint pre64 = 0;
static const uint post64 = 2;
};
template<>
struct decimation_shifts<16, 8>
{
static const uint pre1 = 5;
static const uint pre2 = 4;
static const uint pre1 = 6;
static const uint pre2 = 5;
static const uint post2 = 0;
static const uint pre4 = 3;
static const uint pre4 = 4;
static const uint post4 = 0;
static const uint pre8 = 2;
static const uint pre8 = 3;
static const uint post8 = 0;
static const uint pre16 = 1;
static const uint pre16 = 2;
static const uint post16 = 0;
static const uint pre32 = 0;
static const uint pre32 = 1;
static const uint post32 = 0;
static const uint pre64 = 0;
static const uint post64 = 0;
};
template<typename T, uint SdrBits, uint InputBits>
@ -105,6 +113,9 @@ public:
void decimate32_inf(SampleVector::iterator* it, const T* buf, qint32 len);
void decimate32_sup(SampleVector::iterator* it, const T* buf, qint32 len);
void decimate32_cen(SampleVector::iterator* it, const T* buf, qint32 len);
void decimate64_inf(SampleVector::iterator* it, const T* buf, qint32 len);
void decimate64_sup(SampleVector::iterator* it, const T* buf, qint32 len);
void decimate64_cen(SampleVector::iterator* it, const T* buf, qint32 len);
private:
IntHalfbandFilter m_decimator2; // 1st stages
@ -112,6 +123,7 @@ private:
IntHalfbandFilter m_decimator8; // 3rd stages
IntHalfbandFilter m_decimator16; // 4th stages
IntHalfbandFilter m_decimator32; // 5th stages
IntHalfbandFilter m_decimator64; // 6th stages
};
template<typename T, uint SdrBits, uint InputBits>
@ -352,6 +364,57 @@ void Decimators<T, SdrBits, InputBits>::decimate32_cen(SampleVector::iterator* i
}
}
template<typename T, uint SdrBits, uint InputBits>
void Decimators<T, SdrBits, InputBits>::decimate64_cen(SampleVector::iterator* it, const T* buf, qint32 len)
{
int pos = 0;
while (pos < len)
{
qint32 x0 = buf[pos+0] << decimation_shifts<SdrBits, InputBits>::pre64;
qint32 y0 = buf[pos+1] << decimation_shifts<SdrBits, InputBits>::pre64;
pos += 2;
if (m_decimator2.workDecimateCenter(&x0, &y0))
{
qint32 x1 = x0;
qint32 y1 = y0;
if (m_decimator4.workDecimateCenter(&x1, &y1))
{
qint32 x2 = x1;
qint32 y2 = y1;
if (m_decimator8.workDecimateCenter(&x2, &y2))
{
qint32 x3 = x2;
qint32 y3 = y2;
if (m_decimator16.workDecimateCenter(&x3, &y3))
{
qint32 x4 = x3;
qint32 y4 = y3;
if (m_decimator32.workDecimateCenter(&x4, &y4))
{
qint32 x5 = x4;
qint32 y5 = y4;
if (m_decimator64.workDecimateCenter(&x4, &y4))
{
(**it).setReal(x5 >> decimation_shifts<SdrBits, InputBits>::post64);
(**it).setImag(y5 >> decimation_shifts<SdrBits, InputBits>::post64);
++(*it);
}
}
}
}
}
}
}
}
template<typename T, uint SdrBits, uint InputBits>
void Decimators<T, SdrBits, InputBits>::decimate4_inf(SampleVector::iterator* it, const T* buf, qint32 len)
{
@ -556,4 +619,84 @@ void Decimators<T, SdrBits, InputBits>::decimate32_sup(SampleVector::iterator* i
}
}
template<typename T, uint SdrBits, uint InputBits>
void Decimators<T, SdrBits, InputBits>::decimate64_inf(SampleVector::iterator* it, const T* buf, qint32 len)
{
qint32 xreal[16], yimag[16];
for (int pos = 0; pos < len - 127; )
{
for (int i = 0; i < 16; i++)
{
xreal[i] = (buf[pos+0] - buf[pos+3] + buf[pos+7] - buf[pos+4]) << decimation_shifts<SdrBits, InputBits>::pre64;
yimag[i] = (buf[pos+1] - buf[pos+5] + buf[pos+2] - buf[pos+6]) << decimation_shifts<SdrBits, InputBits>::pre64;
pos += 16;
}
m_decimator2.myDecimate(xreal[0], yimag[0], &xreal[1], &yimag[1]);
m_decimator2.myDecimate(xreal[2], yimag[2], &xreal[3], &yimag[3]);
m_decimator2.myDecimate(xreal[4], yimag[4], &xreal[5], &yimag[3]);
m_decimator2.myDecimate(xreal[6], yimag[6], &xreal[7], &yimag[7]);
m_decimator2.myDecimate(xreal[8], yimag[8], &xreal[9], &yimag[9]);
m_decimator2.myDecimate(xreal[10], yimag[10], &xreal[11], &yimag[11]);
m_decimator2.myDecimate(xreal[12], yimag[12], &xreal[13], &yimag[13]);
m_decimator2.myDecimate(xreal[14], yimag[14], &xreal[15], &yimag[15]);
m_decimator4.myDecimate(xreal[1], yimag[1], &xreal[3], &yimag[3]);
m_decimator4.myDecimate(xreal[5], yimag[5], &xreal[7], &yimag[7]);
m_decimator4.myDecimate(xreal[9], yimag[9], &xreal[11], &yimag[11]);
m_decimator4.myDecimate(xreal[13], yimag[13], &xreal[15], &yimag[15]);
m_decimator8.myDecimate(xreal[3], yimag[3], &xreal[7], &yimag[7]);
m_decimator8.myDecimate(xreal[11], yimag[11], &xreal[15], &yimag[15]);
m_decimator16.myDecimate(xreal[7], yimag[7], &xreal[15], &yimag[15]);
(**it).setReal(xreal[15] >> decimation_shifts<SdrBits, InputBits>::post64);
(**it).setImag(yimag[15] >> decimation_shifts<SdrBits, InputBits>::post64);
++(*it);
}
}
template<typename T, uint SdrBits, uint InputBits>
void Decimators<T, SdrBits, InputBits>::decimate64_sup(SampleVector::iterator* it, const T* buf, qint32 len)
{
qint32 xreal[16], yimag[16];
for (int pos = 0; pos < len - 127; )
{
for (int i = 0; i < 16; i++)
{
xreal[i] = (buf[pos+1] - buf[pos+2] - buf[pos+5] + buf[pos+6]) << decimation_shifts<SdrBits, InputBits>::pre32;
yimag[i] = (buf[pos+4] + buf[pos+7] - buf[pos+0] - buf[pos+3]) << decimation_shifts<SdrBits, InputBits>::pre32;
pos += 16;
}
m_decimator2.myDecimate(xreal[0], yimag[0], &xreal[1], &yimag[1]);
m_decimator2.myDecimate(xreal[2], yimag[2], &xreal[3], &yimag[3]);
m_decimator2.myDecimate(xreal[4], yimag[4], &xreal[5], &yimag[3]);
m_decimator2.myDecimate(xreal[6], yimag[6], &xreal[7], &yimag[7]);
m_decimator2.myDecimate(xreal[8], yimag[8], &xreal[9], &yimag[9]);
m_decimator2.myDecimate(xreal[10], yimag[10], &xreal[11], &yimag[11]);
m_decimator2.myDecimate(xreal[12], yimag[12], &xreal[13], &yimag[13]);
m_decimator2.myDecimate(xreal[14], yimag[14], &xreal[15], &yimag[15]);
m_decimator4.myDecimate(xreal[1], yimag[1], &xreal[3], &yimag[3]);
m_decimator4.myDecimate(xreal[5], yimag[5], &xreal[7], &yimag[7]);
m_decimator4.myDecimate(xreal[9], yimag[9], &xreal[11], &yimag[11]);
m_decimator4.myDecimate(xreal[13], yimag[13], &xreal[15], &yimag[15]);
m_decimator8.myDecimate(xreal[3], yimag[3], &xreal[7], &yimag[7]);
m_decimator8.myDecimate(xreal[11], yimag[11], &xreal[15], &yimag[15]);
m_decimator16.myDecimate(xreal[7], yimag[7], &xreal[15], &yimag[15]);
(**it).setReal(xreal[15] >> decimation_shifts<SdrBits, InputBits>::post64);
(**it).setImag(yimag[15] >> decimation_shifts<SdrBits, InputBits>::post64);
++(*it);
}
}
#endif /* INCLUDE_GPL_DSP_DECIMATORS_H_ */

5
plugins/samplesource/CMakeLists.txt
View File

@ -32,4 +32,9 @@ if(LIBUSB_FOUND AND LIBBLADERF_FOUND)
add_subdirectory(bladerf)
endif(LIBUSB_FOUND AND LIBBLADERF_FOUND)
find_package(LibAIRSPY)
if(LIBUSB_FOUND AND LIBAIRSPY_FOUND)
add_subdirectory(airspy)
endif(LIBUSB_FOUND AND LIBAIRSPY_FOUND)
add_subdirectory(filesource)

53
plugins/samplesource/airspy/CMakeLists.txt Normal file
View File

@ -0,0 +1,53 @@
project(airspy)
set(airspy_SOURCES
airspygui.cpp
airspyinput.cpp
airspyplugin.cpp
airspyserializer.cpp
airspythread.cpp
)
set(airspy_HEADERS
airspygui.h
airspyinput.h
airspyplugin.h
airspyserializer.h
airspythread.h
)
set(airspy_FORMS
airspygui.ui
)
include_directories(
.
${CMAKE_CURRENT_BINARY_DIR}
${CMAKE_SOURCE_DIR}/include
${CMAKE_SOURCE_DIR}/include-gpl
${LIBAIRSPY_INCLUDE_DIR}
)
#include(${QT_USE_FILE})
#add_definitions(${QT_DEFINITIONS})
add_definitions("${QT_DEFINITIONS} -DLIBAIRSPY_DYN_RATES")
add_definitions(-DQT_PLUGIN)
add_definitions(-DQT_SHARED)
#qt4_wrap_cpp(airspy_HEADERS_MOC ${airspy_HEADERS})
qt5_wrap_ui(airspy_FORMS_HEADERS ${airspy_FORMS})
add_library(inputairspy SHARED
${airspy_SOURCES}
${airspy_HEADERS_MOC}
${airspy_FORMS_HEADERS}
)
target_link_libraries(inputairspy
${QT_LIBRARIES}
${LIBAIRSPY_LIBRARIES}
${LIBUSB_LIBRARIES}
sdrbase
)
qt5_use_modules(inputairspy Core Widgets OpenGL Multimedia)

294
plugins/samplesource/airspy/airspygui.cpp Normal file
View File

@ -0,0 +1,294 @@
///////////////////////////////////////////////////////////////////////////////////
// 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 <QDebug>
#include <libairspy/airspy.h>
#include "airspygui.h"
#include "ui_airspygui.h"
#include "plugin/pluginapi.h"
#include "gui/colormapper.h"
#include "dsp/dspengine.h"
AirspyGui::AirspyGui(PluginAPI* pluginAPI, QWidget* parent) :
QWidget(parent),
ui(new Ui::AirspyGui),
m_pluginAPI(pluginAPI),
m_settings(),
m_sampleSource(NULL)
{
ui->setupUi(this);
ui->centerFrequency->setColorMapper(ColorMapper(ColorMapper::ReverseGold));
ui->centerFrequency->setValueRange(7, 24000U, 1900000U);
connect(&m_updateTimer, SIGNAL(timeout()), this, SLOT(updateHardware()));
displaySettings();
m_sampleSource = new AirspyInput();
m_rates = ((AirspyInput*) m_sampleSource)->getSampleRates();
displaySampleRates();
connect(m_sampleSource->getOutputMessageQueueToGUI(), SIGNAL(messageEnqueued()), this, SLOT(handleSourceMessages()));
DSPEngine::instance()->setSource(m_sampleSource);
}
AirspyGui::~AirspyGui()
{
delete m_sampleSource; // Valgrind memcheck
delete ui;
}
void AirspyGui::destroy()
{
delete this;
}
void AirspyGui::setName(const QString& name)
{
setObjectName(name);
}
QString AirspyGui::getName() const
{
return objectName();
}
void AirspyGui::resetToDefaults()
{
m_settings.resetToDefaults();
displaySettings();
sendSettings();
}
qint64 AirspyGui::getCenterFrequency() const
{
return m_settings.m_centerFrequency;
}
QByteArray AirspyGui::serialize() const
{
return m_settings.serialize();
}
bool AirspyGui::deserialize(const QByteArray& data)
{
if(m_settings.deserialize(data)) {
displaySettings();
sendSettings();
return true;
} else {
resetToDefaults();
return false;
}
}
bool AirspyGui::handleMessage(const Message& message)
{
if (AirspyInput::MsgReportAirspy::match(message))
{
qDebug() << "AirspyGui::handleMessage: MsgReportAirspy";
m_rates = ((AirspyInput::MsgReportAirspy&) message).getSampleRates();
displaySampleRates();
return true;
}
else
{
return false;
}
}
void AirspyGui::handleSourceMessages()
{
Message* message;
while ((message = m_sampleSource->getOutputMessageQueueToGUI()->pop()) != 0)
{
qDebug("AirspyGui::HandleSourceMessages: message: %s", message->getIdentifier());
if (handleMessage(*message))
{
delete message;
}
}
}
void AirspyGui::displaySettings()
{
ui->centerFrequency->setValue(m_settings.m_centerFrequency / 1000);
ui->LOppm->setValue(m_settings.m_LOppmTenths);
ui->LOppmText->setText(QString("%1").arg(QString::number(m_settings.m_LOppmTenths/10.0, 'f', 1)));
ui->sampleRate->setCurrentIndex(m_settings.m_devSampleRateIndex);
ui->biasT->setChecked(m_settings.m_biasT);
ui->decimText->setText(tr("%1").arg(1<<m_settings.m_log2Decim));
ui->decim->setValue(m_settings.m_log2Decim);
ui->fcPos->setCurrentIndex((int) m_settings.m_fcPos);
ui->lnaGainText->setText(tr("%1dB").arg(m_settings.m_lnaGain));
ui->lna->setValue(m_settings.m_lnaGain);
ui->mixText->setText(tr("%1dB").arg(m_settings.m_mixerGain));
ui->mix->setValue(m_settings.m_mixerGain);
ui->vgaText->setText(tr("%1dB").arg(m_settings.m_vgaGain));
ui->vga->setValue(m_settings.m_vgaGain);
}
void AirspyGui::displaySampleRates()
{
int savedIndex = m_settings.m_devSampleRateIndex;
ui->sampleRate->blockSignals(true);
if (m_rates.size() > 0)
{
ui->sampleRate->clear();
for (int i = 0; i < m_rates.size(); i++)
{
ui->sampleRate->addItem(QString("%1M").arg(QString::number(m_rates[i]/1000000.0, 'f', 3)));
}
}
ui->sampleRate->blockSignals(false);
if (savedIndex < m_rates.size())
{
ui->sampleRate->setCurrentIndex(savedIndex);
}
else
{
ui->sampleRate->setCurrentIndex((int) m_rates.size()-1);
}
}
void AirspyGui::sendSettings()
{
if(!m_updateTimer.isActive())
m_updateTimer.start(100);
}
void AirspyGui::on_centerFrequency_changed(quint64 value)
{
m_settings.m_centerFrequency = value * 1000;
sendSettings();
}
void AirspyGui::on_LOppm_valueChanged(int value)
{
m_settings.m_LOppmTenths = value;
ui->LOppmText->setText(QString("%1").arg(QString::number(m_settings.m_LOppmTenths/10.0, 'f', 1)));
sendSettings();
}
void AirspyGui::on_sampleRate_currentIndexChanged(int index)
{
m_settings.m_devSampleRateIndex = index;
sendSettings();
}
void AirspyGui::on_biasT_stateChanged(int state)
{
m_settings.m_biasT = (state == Qt::Checked);
sendSettings();
}
void AirspyGui::on_decim_valueChanged(int value)
{
if ((value <0) || (value > 6))
return;
ui->decimText->setText(tr("%1").arg(1<<value));
m_settings.m_log2Decim = value;
sendSettings();
}
void AirspyGui::on_fcPos_currentIndexChanged(int index)
{
if (index == 0) {
m_settings.m_fcPos = AirspyInput::FC_POS_INFRA;
sendSettings();
} else if (index == 1) {
m_settings.m_fcPos = AirspyInput::FC_POS_SUPRA;
sendSettings();
} else if (index == 2) {
m_settings.m_fcPos = AirspyInput::FC_POS_CENTER;
sendSettings();
}
}
void AirspyGui::on_lna_valueChanged(int value)
{
if ((value < 0) || (value > 14))
return;
ui->lnaGainText->setText(tr("%1dB").arg(value));
m_settings.m_lnaGain = value;
sendSettings();
}
void AirspyGui::on_mix_valueChanged(int value)
{
if ((value < 0) || (value > 15))
return;
ui->mixText->setText(tr("%1dB").arg(value));
m_settings.m_lnaGain = value;
sendSettings();
}
void AirspyGui::on_vga_valueChanged(int value)
{
if ((value < 0) || (value > 15))
return;
ui->vgaText->setText(tr("%1dB").arg(value));
m_settings.m_lnaGain = value;
sendSettings();
}
void AirspyGui::updateHardware()
{
qDebug() << "AirspyGui::updateHardware";
AirspyInput::MsgConfigureAirspy* message = AirspyInput::MsgConfigureAirspy::create( m_settings);
m_sampleSource->getInputMessageQueue()->push(message);
m_updateTimer.stop();
}
uint32_t AirspyGui::getDevSampleRate(unsigned int rate_index)
{
if (rate_index < m_rates.size())
{
return m_rates[rate_index];
}
else
{
return m_rates[0];
}
}
int AirspyGui::getDevSampleRateIndex(uint32_t sampeRate)
{
for (unsigned int i=0; i < m_rates.size(); i++)
{
if (sampeRate == m_rates[i])
{
return i;
}
}
return -1;
}

80
plugins/samplesource/airspy/airspygui.h Normal file
View File

@ -0,0 +1,80 @@
///////////////////////////////////////////////////////////////////////////////////
// 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/>. //
///////////////////////////////////////////////////////////////////////////////////
#ifndef INCLUDE_AIRSPYGUI_H
#define INCLUDE_AIRSPYGUI_H
#include <QTimer>
#include "airspyinput.h"
#include "plugin/plugingui.h"
#define AIRSPY_MAX_DEVICE (32)
class PluginAPI;
namespace Ui {
class AirspyGui;
class AirspySampleRates;
}
class AirspyGui : public QWidget, public PluginGUI {
Q_OBJECT
public:
explicit AirspyGui(PluginAPI* pluginAPI, QWidget* parent = NULL);
virtual ~AirspyGui();
void destroy();
void setName(const QString& name);
QString getName() const;
void resetToDefaults();
qint64 getCenterFrequency() const;
QByteArray serialize() const;
bool deserialize(const QByteArray& data);
virtual bool handleMessage(const Message& message);
uint32_t getDevSampleRate(unsigned int index);
int getDevSampleRateIndex(uint32_t sampleRate);
private:
Ui::AirspyGui* ui;
PluginAPI* m_pluginAPI;
AirspyInput::Settings m_settings;
QTimer m_updateTimer;
std::vector<uint32_t> m_rates;
SampleSource* m_sampleSource;
void displaySettings();
void displaySampleRates();
void sendSettings();
private slots:
void on_centerFrequency_changed(quint64 value);
void on_LOppm_valueChanged(int value);
void on_sampleRate_currentIndexChanged(int index);
void on_biasT_stateChanged(int state);
void on_decim_valueChanged(int value);
void on_fcPos_currentIndexChanged(int index);
void on_lna_valueChanged(int value);
void on_mix_valueChanged(int value);
void on_vga_valueChanged(int value);
void updateHardware();
void handleSourceMessages();
};
#endif // INCLUDE_AIRSPYGUI_H

450
plugins/samplesource/airspy/airspygui.ui Normal file
View File

@ -0,0 +1,450 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>AirspyGui</class>
<widget class="QWidget" name="AirspyGui">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>198</width>
<height>214</height>
</rect>
</property>
<property name="sizePolicy">
<sizepolicy hsizetype="Preferred" vsizetype="Maximum">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="windowTitle">
<string>BladeRF</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout">
<property name="spacing">
<number>3</number>
</property>
<property name="leftMargin">
<number>2</number>
</property>
<property name="topMargin">
<number>2</number>
</property>
<property name="rightMargin">
<number>2</number>
</property>
<property name="bottomMargin">
<number>2</number>
</property>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_freq">
<item>
<spacer name="freqLeftSpacer">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>0</width>
<height>0</height>
</size>
</property>
</spacer>
</item>
<item>
<widget class="ValueDial" name="centerFrequency" native="true">
<property name="sizePolicy">
<sizepolicy hsizetype="Maximum" vsizetype="Maximum">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="minimumSize">
<size>
<width>32</width>
<height>16</height>
</size>
</property>
<property name="font">
<font>
<family>Monospace</family>
<pointsize>20</pointsize>
</font>
</property>
<property name="cursor">
<cursorShape>SizeVerCursor</cursorShape>
</property>
<property name="focusPolicy">
<enum>Qt::StrongFocus</enum>
</property>
<property name="toolTip">
<string>Tuner center frequency in kHz</string>
</property>
</widget>
</item>
<item>
<spacer name="freqRightlSpacer">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>0</width>
<height>0</height>
</size>
</property>
</spacer>
</item>
</layout>
</item>
<item>
<layout class="QGridLayout" name="gridLayout_LOppm">
<property name="spacing">
<number>3</number>
</property>
<item row="0" column="0">
<widget class="QLabel" name="LOppmLabel">
<property name="toolTip">
<string>LO correction ppm</string>
</property>
<property name="text">
<string>LO ppm</string>
</property>
</widget>
</item>
<item row="0" column="1">
<widget class="QSlider" name="LOppm">
<property name="minimum">
<number>-100</number>
</property>
<property name="maximum">
<number>100</number>
</property>
<property name="pageStep">
<number>1</number>
</property>
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
</widget>
</item>
<item row="0" column="2">
<widget class="QLabel" name="LOppmText">
<property name="text">
<string>0.0</string>
</property>
</widget>
</item>
</layout>
</item>
<item>
<widget class="Line" name="line_freq">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
</widget>
</item>
<item>
<layout class="QGridLayout" name="gridLayout_samplerate">
<property name="spacing">
<number>3</number>
</property>
<item row="0" column="2">
<widget class="QCheckBox" name="biasT">
<property name="text">
<string>Bias T</string>
</property>
</widget>
</item>
<item row="0" column="0">
<widget class="QLabel" name="sampleRateLabel">
<property name="sizePolicy">
<sizepolicy hsizetype="Maximum" vsizetype="Preferred">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="text">
<string>Rate</string>
</property>
</widget>
</item>
<item row="0" column="1">
<widget class="QComboBox" name="sampleRate">
<property name="toolTip">
<string>Device sample rate</string>
</property>
</widget>
</item>
</layout>
</item>
<item>
<layout class="QGridLayout" name="gridLayout_decim" columnstretch="0,0,0">
<property name="spacing">
<number>3</number>
</property>
<item row="0" column="0">
<widget class="QLabel" name="label_decim">
<property name="text">
<string>Dec.</string>
</property>
</widget>
</item>
<item row="0" column="1">
<widget class="QSlider" name="decim">
<property name="maximum">
<number>6</number>
</property>
<property name="pageStep">
<number>1</number>
</property>
<property name="value">
<number>0</number>
</property>
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
</widget>
</item>
<item row="0" column="2">
<widget class="QLabel" name="decimText">
<property name="minimumSize">
<size>
<width>40</width>
<height>0</height>
</size>
</property>
<property name="text">
<string>1</string>
</property>
<property name="alignment">
<set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
</property>
</widget>
</item>
</layout>
</item>
<item>
<layout class="QGridLayout" name="gridLayout_fcPos" columnstretch="0,0,0">
<property name="spacing">
<number>3</number>
</property>
<item row="0" column="0">
<widget class="QLabel" name="label_fcPos">
<property name="text">
<string>Fc pos</string>
</property>
</widget>
</item>
<item row="0" column="2">
<spacer name="fcPosRightSpacer">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
<item row="0" column="1">
<widget class="QComboBox" name="fcPos">
<item>
<property name="text">
<string>Inf</string>
</property>
</item>
<item>
<property name="text">
<string>Sup</string>
</property>
</item>
<item>
<property name="text">
<string>Cent</string>
</property>
</item>
</widget>
</item>
</layout>
</item>
<item>
<widget class="Line" name="line_fcPos">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
</widget>
</item>
<item>
<layout class="QGridLayout" name="gridLayout_lna">
<property name="spacing">
<number>3</number>
</property>
<item row="0" column="0">
<widget class="QLabel" name="lnaGainLabel">
<property name="sizePolicy">
<sizepolicy hsizetype="Maximum" vsizetype="Preferred">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="text">
<string>LNA </string>
</property>
</widget>
</item>
<item row="0" column="1">
<widget class="QSlider" name="lna">
<property name="enabled">
<bool>true</bool>
</property>
<property name="toolTip">
<string>LNA gain dB</string>
</property>
<property name="maximum">
<number>14</number>
</property>
<property name="pageStep">
<number>1</number>
</property>
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
</widget>
</item>
<item row="0" column="2">
<widget class="QLabel" name="lnaGainText">
<property name="minimumSize">
<size>
<width>40</width>
<height>0</height>
</size>
</property>
<property name="text">
<string>0dB</string>
</property>
<property name="alignment">
<set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
</property>
</widget>
</item>
</layout>
</item>
<item>
<layout class="QGridLayout" name="gridLayout_mix">
<property name="spacing">
<number>3</number>
</property>
<item row="0" column="1">
<widget class="QSlider" name="mix">
<property name="toolTip">
<string>Mixer gain dB</string>
</property>
<property name="minimum">
<number>0</number>
</property>
<property name="maximum">
<number>15</number>
</property>
<property name="pageStep">
<number>1</number>
</property>
<property name="value">
<number>5</number>
</property>
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
</widget>
</item>
<item row="0" column="2">
<widget class="QLabel" name="mixText">
<property name="minimumSize">
<size>
<width>40</width>
<height>0</height>
</size>
</property>
<property name="text">
<string>0dB</string>
</property>
<property name="alignment">
<set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
</property>
</widget>
</item>
<item row="0" column="0">
<widget class="QLabel" name="mixLabel">
<property name="text">
<string>Mixer</string>
</property>
</widget>
</item>
</layout>
</item>
<item>
<layout class="QGridLayout" name="gridLayout_vga" columnstretch="0,0,0">
<property name="spacing">
<number>3</number>
</property>
<item row="0" column="0">
<widget class="QLabel" name="vgaLabel">
<property name="text">
<string>VGA</string>
</property>
</widget>
</item>
<item row="0" column="1">
<widget class="QSlider" name="vga">
<property name="toolTip">
<string>VGA gain dB</string>
</property>
<property name="maximum">
<number>15</number>
</property>
<property name="singleStep">
<number>1</number>
</property>
<property name="pageStep">
<number>1</number>
</property>
<property name="value">
<number>5</number>
</property>
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
</widget>
</item>
<item row="0" column="2">
<widget class="QLabel" name="vgaText">
<property name="minimumSize">
<size>
<width>40</width>
<height>0</height>
</size>
</property>
<property name="text">
<string>0dB</string>
</property>
<property name="alignment">
<set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
</property>
</widget>
</item>
</layout>
</item>
</layout>
</widget>
<customwidgets>
<customwidget>
<class>ValueDial</class>
<extends>QWidget</extends>
<header>gui/valuedial.h</header>
<container>1</container>
</customwidget>
</customwidgets>
<resources/>
<connections/>
</ui>

495
plugins/samplesource/airspy/airspyinput.cpp Normal file
View File

@ -0,0 +1,495 @@
///////////////////////////////////////////////////////////////////////////////////
// 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 <string.h>
#include <errno.h>
#include <QDebug>
#include "airspygui.h"
#include "airspyinput.h"
#include "util/simpleserializer.h"
#include "dsp/dspcommands.h"
#include "airspyserializer.h"
#include "airspythread.h"
MESSAGE_CLASS_DEFINITION(AirspyInput::MsgConfigureAirspy, Message)
MESSAGE_CLASS_DEFINITION(AirspyInput::MsgReportAirspy, Message)
AirspyInput::Settings::Settings() :
m_centerFrequency(435000*1000),
m_devSampleRateIndex(0),
m_LOppmTenths(0),
m_lnaGain(1),
m_mixerGain(5),
m_vgaGain(5),
m_log2Decim(0),
m_fcPos(FC_POS_INFRA),
m_biasT(false)
{
}
void AirspyInput::Settings::resetToDefaults()
{
m_centerFrequency = 435000*1000;
m_devSampleRateIndex = 0;
m_LOppmTenths = 0;
m_lnaGain = 1;
m_mixerGain = 5;
m_vgaGain = 5;
m_log2Decim = 0;
m_fcPos = FC_POS_INFRA;
m_biasT = false;
}
QByteArray AirspyInput::Settings::serialize() const
{
AirspySerializer::AirspyData data;
data.m_data.m_frequency = m_centerFrequency;
data.m_LOppmTenths = m_LOppmTenths;
data.m_sampleRateIndex = m_devSampleRateIndex;
data.m_log2Decim = m_log2Decim;
data.m_fcPos = (qint32) m_fcPos;
data.m_lnaGain = m_lnaGain;
data.m_mixerGain = m_mixerGain;
data.m_vgaGain = m_vgaGain;
data.m_biasT = m_biasT;
QByteArray byteArray;
AirspySerializer::writeSerializedData(data, byteArray);
return byteArray;
}
bool AirspyInput::Settings::deserialize(const QByteArray& serializedData)
{
AirspySerializer::AirspyData data;
bool valid = AirspySerializer::readSerializedData(serializedData, data);
m_centerFrequency = data.m_data.m_frequency;
m_LOppmTenths = data.m_LOppmTenths;
m_devSampleRateIndex = data.m_sampleRateIndex;
m_log2Decim = data.m_log2Decim;
m_fcPos = (fcPos_t) data.m_fcPos;
m_lnaGain = data.m_lnaGain;
m_mixerGain = data.m_mixerGain;
m_vgaGain = data.m_vgaGain;
m_biasT = data.m_biasT;
return valid;
}
AirspyInput::AirspyInput() :
m_settings(),
m_dev(0),
m_airspyThread(0),
m_deviceDescription("Airspy")
{
m_sampleRates.push_back(10000000);
m_sampleRates.push_back(2500000);
}
AirspyInput::~AirspyInput()
{
stop();
}
bool AirspyInput::init(const Message& cmd)
{
return false;
}
bool AirspyInput::start(int device)
{
QMutexLocker mutexLocker(&m_mutex);
airspy_error rc;
rc = (airspy_error) airspy_init();
if (rc != AIRSPY_SUCCESS)
{
qCritical("AirspyInput::start: failed to initiate Airspy library %s", airspy_error_name(rc));
}
if (m_dev != 0)
{
stop();
}
if (!m_sampleFifo.setSize(96000 * 4))
{
qCritical("AirspyInput::start: could not allocate SampleFifo");
return false;
}
if ((m_dev = open_airspy_from_sequence(device)) == 0)
{
qCritical("AirspyInput::start: could not open Airspy #%d", device);
return false;
}
#ifdef LIBAIRSPY_DYN_RATES
uint32_t nbSampleRates;
uint32_t *sampleRates;
airspy_get_samplerates(m_dev, &nbSampleRates, 0);
sampleRates = new uint32_t[nbSampleRates];
airspy_get_samplerates(m_dev, sampleRates, nbSampleRates);
if (nbSampleRates == 0)
{
qCritical("AirspyInput::start: could not obtain Airspy sample rates");
return false;
}
m_sampleRates.clear();
for (int i=0; i<nbSampleRates; i++)
{
m_sampleRates.push_back(sampleRates[i]);
qDebug("AirspyInput::start: sampleRates[%d] = %u Hz", i, sampleRates[i]);
}
delete[] sampleRates;
#endif
MsgReportAirspy *message = MsgReportAirspy::create(m_sampleRates);
getOutputMessageQueueToGUI()->push(message);
rc = (airspy_error) airspy_set_sample_type(m_dev, AIRSPY_SAMPLE_INT16_IQ);
if (rc != AIRSPY_SUCCESS)
{
qCritical("AirspyInput::start: could not set sample type to INT16_IQ");
return false;
}
if((m_airspyThread = new AirspyThread(m_dev, &m_sampleFifo)) == 0)
{
qFatal("AirspyInput::start: out of memory");
stop();
return false;
}
m_airspyThread->startWork();
mutexLocker.unlock();
applySettings(m_settings, true);
qDebug("AirspyInput::startInput: started");
return true;
}
void AirspyInput::stop()
{
qDebug("AirspyInput::stop");
QMutexLocker mutexLocker(&m_mutex);
if(m_airspyThread != 0)
{
m_airspyThread->stopWork();
delete m_airspyThread;
m_airspyThread = 0;
}
if(m_dev != 0)
{
airspy_stop_rx(m_dev);
airspy_close(m_dev);
m_dev = 0;
}
airspy_exit();
}
const QString& AirspyInput::getDeviceDescription() const
{
return m_deviceDescription;
}
int AirspyInput::getSampleRate() const
{
int rate = m_sampleRates[m_settings.m_devSampleRateIndex];
return (rate / (1<<m_settings.m_log2Decim));
}
quint64 AirspyInput::getCenterFrequency() const
{
return m_settings.m_centerFrequency;
}
bool AirspyInput::handleMessage(const Message& message)
{
if (MsgConfigureAirspy::match(message))
{
MsgConfigureAirspy& conf = (MsgConfigureAirspy&) message;
qDebug() << "AirspyInput::handleMessage: MsgConfigureAirspy";
bool success = applySettings(conf.getSettings(), false);
if (!success)
{
qDebug("Airspy config error");
}
return true;
}
else
{
return false;
}
}
void AirspyInput::setCenterFrequency(quint64 freq_hz)
{
freq_hz += (freq_hz * m_settings.m_LOppmTenths) / 10000000ULL;
airspy_error rc = (airspy_error) airspy_set_freq(m_dev, static_cast<uint32_t>(freq_hz));
if (rc != AIRSPY_SUCCESS)
{
qWarning("AirspyInput::setCenterFrequency: could not frequency to %llu Hz", freq_hz);
}
else
{
qWarning("AirspyInput::setCenterFrequency: frequency set to %llu Hz", freq_hz);
}
}
bool AirspyInput::applySettings(const Settings& settings, bool force)
{
QMutexLocker mutexLocker(&m_mutex);
bool forwardChange = false;
airspy_error rc;
qDebug() << "AirspyInput::applySettings";
if ((m_settings.m_devSampleRateIndex != settings.m_devSampleRateIndex) || force)
{
forwardChange = true;
if (settings.m_devSampleRateIndex < m_sampleRates.size())
{
m_settings.m_devSampleRateIndex = settings.m_devSampleRateIndex;
}
else
{
m_settings.m_devSampleRateIndex = m_sampleRates.size() - 1;
}
if (m_dev != 0)
{
rc = (airspy_error) airspy_set_samplerate(m_dev, static_cast<airspy_samplerate_t>(m_settings.m_devSampleRateIndex));
if (rc != AIRSPY_SUCCESS)
{
qCritical("AirspyInput::applySettings: could not set sample rate index %u (%d S/s): %s", m_settings.m_devSampleRateIndex, m_sampleRates[m_settings.m_devSampleRateIndex], airspy_error_name(rc));
}
else
{
qDebug("AirspyInput::applySettings: sample rate set to index: %u (%d S/s)", m_settings.m_devSampleRateIndex, m_sampleRates[m_settings.m_devSampleRateIndex]);
m_airspyThread->setSamplerate(m_sampleRates[m_settings.m_devSampleRateIndex]);
}
}
}
if ((m_settings.m_log2Decim != settings.m_log2Decim) || force)
{
m_settings.m_log2Decim = settings.m_log2Decim;
forwardChange = true;
if(m_dev != 0)
{
m_airspyThread->setLog2Decimation(m_settings.m_log2Decim);
qDebug() << "AirspyInput: set decimation to " << (1<<m_settings.m_log2Decim);
}
}
if ((m_settings.m_fcPos != settings.m_fcPos) || force)
{
m_settings.m_fcPos = settings.m_fcPos;
if(m_dev != 0)
{
m_airspyThread->setFcPos((int) m_settings.m_fcPos);
qDebug() << "AirspyInput: set fc pos (enum) to " << (int) m_settings.m_fcPos;
}
}
qint64 deviceCenterFrequency = m_settings.m_centerFrequency;
qint64 f_img = deviceCenterFrequency;
quint32 devSampleRate = m_sampleRates[m_settings.m_devSampleRateIndex];
if (force || (m_settings.m_centerFrequency != settings.m_centerFrequency) ||
(m_settings.m_LOppmTenths != settings.m_LOppmTenths))
{
m_settings.m_centerFrequency = settings.m_centerFrequency;
m_settings.m_LOppmTenths = settings.m_LOppmTenths;
if ((m_settings.m_log2Decim == 0) || (m_settings.m_fcPos == FC_POS_CENTER))
{
deviceCenterFrequency = m_settings.m_centerFrequency;
f_img = deviceCenterFrequency;
}
else
{
if (m_settings.m_fcPos == FC_POS_INFRA)
{
deviceCenterFrequency = m_settings.m_centerFrequency + (devSampleRate / 4);
f_img = deviceCenterFrequency + devSampleRate/2;
}
else if (m_settings.m_fcPos == FC_POS_SUPRA)
{
deviceCenterFrequency = m_settings.m_centerFrequency - (devSampleRate / 4);
f_img = deviceCenterFrequency - devSampleRate/2;
}
}
if (m_dev != 0)
{
setCenterFrequency(deviceCenterFrequency);
qDebug() << "AirspyInput::applySettings: center freq: " << m_settings.m_centerFrequency << " Hz"
<< " device center freq: " << deviceCenterFrequency << " Hz"
<< " device sample rate: " << devSampleRate << "Hz"
<< " Actual sample rate: " << devSampleRate/(1<<m_settings.m_log2Decim) << "Hz"
<< " img: " << f_img << "Hz";
}
forwardChange = true;
}
if ((m_settings.m_lnaGain != settings.m_lnaGain) || force)
{
m_settings.m_lnaGain = settings.m_lnaGain;
if (m_dev != 0)
{
rc = (airspy_error) airspy_set_lna_gain(m_dev, m_settings.m_lnaGain);
if(rc != AIRSPY_SUCCESS)
{
qDebug("AirspyInput::applySettings: airspy_set_lna_gain failed: %s", airspy_error_name(rc));
}
else
{
qDebug() << "AirspyInput:applySettings: LNA gain set to " << m_settings.m_lnaGain;
}
}
}
if ((m_settings.m_mixerGain != settings.m_mixerGain) || force)
{
m_settings.m_mixerGain = settings.m_mixerGain;
if (m_dev != 0)
{
rc = (airspy_error) airspy_set_mixer_gain(m_dev, m_settings.m_mixerGain);
if(rc != AIRSPY_SUCCESS)
{
qDebug("AirspyInput::applySettings: airspy_set_mixer_gain failed: %s", airspy_error_name(rc));
}
else
{
qDebug() << "AirspyInput:applySettings: mixer gain set to " << m_settings.m_mixerGain;
}
}
}
if ((m_settings.m_vgaGain != settings.m_vgaGain) || force)
{
m_settings.m_vgaGain = settings.m_vgaGain;
if (m_dev != 0)
{
rc = (airspy_error) airspy_set_vga_gain(m_dev, m_settings.m_vgaGain);
if(rc != AIRSPY_SUCCESS)
{
qDebug("AirspyInput::applySettings: airspy_set_vga_gain failed: %s", airspy_error_name(rc));
}
else
{
qDebug() << "AirspyInput:applySettings: VGA gain set to " << m_settings.m_vgaGain;
}
}
}
if ((m_settings.m_biasT != settings.m_biasT) || force)
{
m_settings.m_biasT = settings.m_biasT;
if (m_dev != 0)
{
rc = (airspy_error) airspy_set_rf_bias(m_dev, (m_settings.m_biasT ? 1 : 0));
if(rc != AIRSPY_SUCCESS)
{
qDebug("AirspyInput::applySettings: airspy_set_rf_bias failed: %s", airspy_error_name(rc));
}
else
{
qDebug() << "AirspyInput:applySettings: bias tee set to " << m_settings.m_biasT;
}
}
}
if (forwardChange)
{
int sampleRate = devSampleRate/(1<<m_settings.m_log2Decim);
DSPSignalNotification *notif = new DSPSignalNotification(sampleRate, m_settings.m_centerFrequency);
getOutputMessageQueue()->push(notif);
}
return true;
}
struct airspy_device *AirspyInput::open_airspy_from_sequence(int sequence)
{
airspy_read_partid_serialno_t read_partid_serialno;
struct airspy_device *devinfo, *retdev = 0;
uint32_t serial_msb = 0;
uint32_t serial_lsb = 0;
airspy_error rc;
int i;
for (int i = 0; i < AIRSPY_MAX_DEVICE; i++)
{
rc = (airspy_error) airspy_open(&devinfo);
if (rc == AIRSPY_SUCCESS)
{
if (i == sequence)
{
return devinfo;
}
}
else
{
break;
}
}
return 0;
}

118
plugins/samplesource/airspy/airspyinput.h Normal file
View 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/>. //
///////////////////////////////////////////////////////////////////////////////////
#ifndef INCLUDE_AIRSPYINPUT_H
#define INCLUDE_AIRSPYINPUT_H
#include "dsp/samplesource.h"
#include <libairspy/airspy.h>
#include <QString>
class AirspyThread;
class AirspyInput : public SampleSource {
public:
typedef enum {
FC_POS_INFRA = 0,
FC_POS_SUPRA,
FC_POS_CENTER
} fcPos_t;
struct Settings {
quint64 m_centerFrequency;
qint32 m_LOppmTenths;
quint32 m_devSampleRateIndex;
quint32 m_lnaGain;
quint32 m_mixerGain;
quint32 m_vgaGain;
quint32 m_log2Decim;
fcPos_t m_fcPos;
bool m_biasT;
Settings();
void resetToDefaults();
QByteArray serialize() const;
bool deserialize(const QByteArray& data);
};
class MsgConfigureAirspy : public Message {
MESSAGE_CLASS_DECLARATION
public:
const Settings& getSettings() const { return m_settings; }
static MsgConfigureAirspy* create(const Settings& settings)
{
return new MsgConfigureAirspy(settings);
}
private:
Settings m_settings;
MsgConfigureAirspy(const Settings& settings) :
Message(),
m_settings(settings)
{ }
};
class MsgReportAirspy : public Message {
MESSAGE_CLASS_DECLARATION
public:
const std::vector<uint32_t>& getSampleRates() const { return m_sampleRates; }
static MsgReportAirspy* create(const std::vector<uint32_t>& sampleRates)
{
return new MsgReportAirspy(sampleRates);
}
protected:
std::vector<uint32_t> m_sampleRates;
MsgReportAirspy(const std::vector<uint32_t>& sampleRates) :
Message(),
m_sampleRates(sampleRates)
{ }
};
AirspyInput();
virtual ~AirspyInput();
virtual bool init(const Message& message);
virtual bool start(int device);
virtual void stop();
virtual const QString& getDeviceDescription() const;
virtual int getSampleRate() const;
virtual quint64 getCenterFrequency() const;
const std::vector<uint32_t>& getSampleRates() const { return m_sampleRates; }
virtual bool handleMessage(const Message& message);
private:
bool applySettings(const Settings& settings, bool force);
struct airspy_device *open_airspy_from_sequence(int sequence);
void setCenterFrequency(quint64 freq);
QMutex m_mutex;
Settings m_settings;
struct airspy_device* m_dev;
AirspyThread* m_airspyThread;
QString m_deviceDescription;
std::vector<uint32_t> m_sampleRates;
};
#endif // INCLUDE_AIRSPYINPUT_H

134
plugins/samplesource/airspy/airspyplugin.cpp Normal file
View File

@ -0,0 +1,134 @@
///////////////////////////////////////////////////////////////////////////////////
// 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 <QtPlugin>
#include <QAction>
#include <libairspy/airspy.h>
#include "airspygui.h"
#include "airspyplugin.h"
#include "plugin/pluginapi.h"
#include "util/simpleserializer.h"
const PluginDescriptor AirspyPlugin::m_pluginDescriptor = {
QString("Airspy Input"),
QString("---"),
QString("(c) Edouard Griffiths, F4EXB"),
QString("https://github.com/f4exb/sdrangel"),
true,
QString("https://github.com/f4exb/sdrangel")
};
AirspyPlugin::AirspyPlugin(QObject* parent) :
QObject(parent),
m_pluginAPI(0)
{
}
const PluginDescriptor& AirspyPlugin::getPluginDescriptor() const
{
return m_pluginDescriptor;
}
void AirspyPlugin::initPlugin(PluginAPI* pluginAPI)
{
m_pluginAPI = pluginAPI;
m_pluginAPI->registerSampleSource("org.osmocom.sdr.samplesource.airspy", this);
}
PluginInterface::SampleSourceDevices AirspyPlugin::enumSampleSources()
{
SampleSourceDevices result;
airspy_read_partid_serialno_t read_partid_serialno;
struct airspy_device *devinfo;
uint32_t serial_msb = 0;
uint32_t serial_lsb = 0;
airspy_error rc;
int i;
rc = (airspy_error) airspy_init();
if (rc != AIRSPY_SUCCESS)
{
qCritical("AirspyPlugin::enumSampleSources: failed to initiate Airspy library: %s", airspy_error_name(rc));
}
for (i=0; i < AIRSPY_MAX_DEVICE; i++)
{
rc = (airspy_error) airspy_open(&devinfo);
if (rc == AIRSPY_SUCCESS)
{
qDebug("AirspyPlugin::enumSampleSources: try to enumerate Airspy device #%d", i);
rc = (airspy_error) airspy_board_partid_serialno_read(devinfo, &read_partid_serialno);
if (rc != AIRSPY_SUCCESS)
{
qDebug("AirspyPlugin::enumSampleSources: failed to read serial no: %s", airspy_error_name(rc));
airspy_close(devinfo);
continue; // next
}
if ((read_partid_serialno.serial_no[2] != serial_msb) && (read_partid_serialno.serial_no[3] != serial_lsb))
{
serial_msb = read_partid_serialno.serial_no[2];
serial_lsb = read_partid_serialno.serial_no[3];
QString serial_str = QString::number(serial_msb, 16) + QString::number(serial_lsb, 16);
uint64_t serial_num = (((uint64_t) serial_msb)<<32) + serial_lsb;
QString displayedName(QString("Airspy #%1 0x%2").arg(i).arg(serial_str));
SimpleSerializer s(1);
s.writeS32(1, i);
s.writeString(2, serial_str);
s.writeU64(3, serial_num);
result.append(SampleSourceDevice(displayedName, "org.osmocom.sdr.samplesource.airspy", s.final()));
qDebug("AirspyPlugin::enumSampleSources: enumerated Airspy device #%d", i);
}
airspy_close(devinfo);
}
else
{
qDebug("AirspyPlugin::enumSampleSources: enumerated %d Airspy devices %s", i, airspy_error_name(rc));
break; // finished
}
}
rc = (airspy_error) airspy_exit();
qDebug("AirspyPlugin::enumSampleSources: airspy_exit: %s", airspy_error_name(rc));
return result;
}
PluginGUI* AirspyPlugin::createSampleSourcePluginGUI(const QString& sourceName, const QByteArray& address)
{
if (!m_pluginAPI)
{
return 0;
}
if(sourceName == "org.osmocom.sdr.samplesource.airspy")
{
AirspyGui* gui = new AirspyGui(m_pluginAPI);
m_pluginAPI->setInputGUI(gui);
return gui;
}
else
{
return 0;
}
}

43
plugins/samplesource/airspy/airspyplugin.h Normal file
View File

@ -0,0 +1,43 @@
///////////////////////////////////////////////////////////////////////////////////
// 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/>. //
///////////////////////////////////////////////////////////////////////////////////
#ifndef INCLUDE_AIRSPYPLUGIN_H
#define INCLUDE_AIRSPYPLUGIN_H
#include <QObject>
#include "plugin/plugininterface.h"
class AirspyPlugin : public QObject, public PluginInterface {
Q_OBJECT
Q_INTERFACES(PluginInterface)
Q_PLUGIN_METADATA(IID "org.osmocom.sdr.samplesource.airspy")
public:
explicit AirspyPlugin(QObject* parent = NULL);
const PluginDescriptor& getPluginDescriptor() const;
void initPlugin(PluginAPI* pluginAPI);
SampleSourceDevices enumSampleSources();
PluginGUI* createSampleSourcePluginGUI(const QString& sourceName, const QByteArray& address);
private:
static const PluginDescriptor m_pluginDescriptor;
PluginAPI* m_pluginAPI;
};
#endif // INCLUDE_AIRSPYPLUGIN_H

86
plugins/samplesource/airspy/airspyserializer.cpp Normal file
View File

@ -0,0 +1,86 @@
///////////////////////////////////////////////////////////////////////////////////
// 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 "airspyserializer.h"
void AirspySerializer::writeSerializedData(const AirspyData& 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.writeU32(3, data.m_sampleRateIndex);
s.writeU32(4, data.m_log2Decim);
s.writeS32(5, data.m_fcPos);
s.writeU32(6, data.m_lnaGain);
s.writeU32(7, data.m_mixerGain);
s.writeU32(8, data.m_vgaGain);
s.writeBool(9, data.m_biasT);
serializedData = s.final();
}
bool AirspySerializer::readSerializedData(const QByteArray& serializedData, AirspyData& 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, 0);
d.readU32(3, &data.m_sampleRateIndex, 0);
d.readU32(4, &data.m_log2Decim, 0);
d.readS32(5, &data.m_fcPos, 0);
d.readU32(6, &data.m_lnaGain, 1);
d.readU32(7, &data.m_mixerGain, 5);
d.readU32(8, &data.m_vgaGain, 5);
d.readBool(9, &data.m_biasT, false);
return SampleSourceSerializer::readSerializedData(sampleSourceSerialized, data.m_data);
}
else
{
setDefaults(data);
return false;
}
}
void AirspySerializer::setDefaults(AirspyData& data)
{
data.m_LOppmTenths = 0;
data.m_sampleRateIndex = 0;
data.m_log2Decim = 0;
data.m_fcPos = 0;
data.m_lnaGain = 1;
data.m_mixerGain = 5;
data.m_vgaGain = 5;
data.m_biasT = false;
}

44
plugins/samplesource/airspy/airspyserializer.h Normal file
View File

@ -0,0 +1,44 @@
///////////////////////////////////////////////////////////////////////////////////
// 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/>. //
///////////////////////////////////////////////////////////////////////////////////
#ifndef PLUGINS_SAMPLESOURCE_AIRSPY_AIRSPYSERIALIZER_H_
#define PLUGINS_SAMPLESOURCE_AIRSPY_AIRSPYSERIALIZER_H_
#include "util/samplesourceserializer.h"
class AirspySerializer
{
public:
struct AirspyData
{
SampleSourceSerializer::Data m_data;
qint32 m_LOppmTenths;
quint32 m_sampleRateIndex;
quint32 m_log2Decim;
qint32 m_fcPos;
quint32 m_lnaGain;
quint32 m_mixerGain;
quint32 m_vgaGain;
bool m_biasT;
};
static void writeSerializedData(const AirspyData& data, QByteArray& serializedData);
static bool readSerializedData(const QByteArray& serializedData, AirspyData& data);
static void setDefaults(AirspyData& data);
};
#endif /* PLUGINS_SAMPLESOURCE_AIRSPY_AIRSPYSERIALIZER_H_ */

210
plugins/samplesource/airspy/airspythread.cpp Normal file
View File

@ -0,0 +1,210 @@
///////////////////////////////////////////////////////////////////////////////////
// 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 <stdio.h>
#include <errno.h>
#include "airspythread.h"
#include "dsp/samplefifo.h"
AirspyThread *AirspyThread::m_this = 0;
AirspyThread::AirspyThread(struct airspy_device* dev, SampleFifo* sampleFifo, QObject* parent) :
QThread(parent),
m_running(false),
m_dev(dev),
m_convertBuffer(AIRSPY_BLOCKSIZE),
m_sampleFifo(sampleFifo),
m_samplerate(10),
m_log2Decim(0),
m_fcPos(0)
{
m_this = this;
}
AirspyThread::~AirspyThread()
{
stopWork();
m_this = 0;
}
void AirspyThread::startWork()
{
m_startWaitMutex.lock();
start();
while(!m_running)
m_startWaiter.wait(&m_startWaitMutex, 100);
m_startWaitMutex.unlock();
}
void AirspyThread::stopWork()
{
qDebug("AirspyThread::stopWork");
m_running = false;
wait();
}
void AirspyThread::setSamplerate(uint32_t samplerate)
{
m_samplerate = samplerate;
}
void AirspyThread::setLog2Decimation(unsigned int log2_decim)
{
m_log2Decim = log2_decim;
}
void AirspyThread::setFcPos(int fcPos)
{
m_fcPos = fcPos;
}
void AirspyThread::run()
{
airspy_error rc;
m_running = true;
m_startWaiter.wakeAll();
rc = (airspy_error) airspy_start_rx(m_dev, rx_callback, NULL);
if (rc != AIRSPY_SUCCESS)
{
qCritical("AirspyInput::run: failed to start Airspy Rx: %s", airspy_error_name(rc));
}
else
{
while ((m_running) && (airspy_is_streaming(m_dev) == AIRSPY_TRUE))
{
sleep(1);
}
}
rc = (airspy_error) airspy_stop_rx(m_dev);
if (rc == AIRSPY_SUCCESS)
{
qDebug("AirspyInput::run: stopped Airspy Rx");
}
else
{
qDebug("AirspyInput::run: failed to stop Airspy Rx: %s", airspy_error_name(rc));
}
m_running = false;
}
// Decimate according to specified log2 (ex: log2=4 => decim=16)
void AirspyThread::callback(const qint16* buf, qint32 len)
{
SampleVector::iterator it = m_convertBuffer.begin();
if (m_log2Decim == 0)
{
m_decimators.decimate1(&it, buf, len);
}
else
{
if (m_fcPos == 0) // Infra
{
switch (m_log2Decim)
{
case 1:
m_decimators.decimate2_inf(&it, buf, len);
break;
case 2:
m_decimators.decimate4_inf(&it, buf, len);
break;
case 3:
m_decimators.decimate8_inf(&it, buf, len);
break;
case 4:
m_decimators.decimate16_inf(&it, buf, len);
break;
case 5:
m_decimators.decimate32_inf(&it, buf, len);
break;
case 6:
m_decimators.decimate64_inf(&it, buf, len);
break;
default:
break;
}
}
else if (m_fcPos == 1) // Supra
{
switch (m_log2Decim)
{
case 1:
m_decimators.decimate2_sup(&it, buf, len);
break;
case 2:
m_decimators.decimate4_sup(&it, buf, len);
break;
case 3:
m_decimators.decimate8_sup(&it, buf, len);
break;
case 4:
m_decimators.decimate16_sup(&it, buf, len);
break;
case 5:
m_decimators.decimate32_sup(&it, buf, len);
break;
case 6:
m_decimators.decimate64_sup(&it, buf, len);
break;
default:
break;
}
}
else if (m_fcPos == 2) // Center
{
switch (m_log2Decim)
{
case 1:
m_decimators.decimate2_cen(&it, buf, len);
break;
case 2:
m_decimators.decimate4_cen(&it, buf, len);
break;
case 3:
m_decimators.decimate8_cen(&it, buf, len);
break;
case 4:
m_decimators.decimate16_cen(&it, buf, len);
break;
case 5:
m_decimators.decimate32_cen(&it, buf, len);
break;
case 6:
m_decimators.decimate64_cen(&it, buf, len);
break;
default:
break;
}
}
}
m_sampleFifo->write(m_convertBuffer.begin(), it);
}
int AirspyThread::rx_callback(airspy_transfer_t* transfer)
{
qint32 bytes_to_write = transfer->sample_count * sizeof(qint16);
m_this->callback((qint16 *) transfer->samples, bytes_to_write);
return 0;
}

64
plugins/samplesource/airspy/airspythread.h Normal file
View File

@ -0,0 +1,64 @@
///////////////////////////////////////////////////////////////////////////////////
// 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/>. //
///////////////////////////////////////////////////////////////////////////////////
#ifndef INCLUDE_AIRSPYTHREAD_H
#define INCLUDE_AIRSPYTHREAD_H
#include <QThread>
#include <QMutex>
#include <QWaitCondition>
#include <libairspy/airspy.h>
#include "dsp/samplefifo.h"
#include "dsp/decimators.h"
#define AIRSPY_BLOCKSIZE (1<<17)
class AirspyThread : public QThread {
Q_OBJECT
public:
AirspyThread(struct airspy_device* dev, SampleFifo* sampleFifo, QObject* parent = NULL);
~AirspyThread();
void startWork();
void stopWork();
void setSamplerate(uint32_t samplerate);
void setLog2Decimation(unsigned int log2_decim);
void setFcPos(int fcPos);
private:
QMutex m_startWaitMutex;
QWaitCondition m_startWaiter;
bool m_running;
struct airspy_device* m_dev;
qint16 m_buf[2*AIRSPY_BLOCKSIZE];
SampleVector m_convertBuffer;
SampleFifo* m_sampleFifo;
int m_samplerate;
unsigned int m_log2Decim;
int m_fcPos;
static AirspyThread *m_this;
Decimators<qint16, SDR_SAMP_SZ, 12> m_decimators;
void run();
void callback(const qint16* buf, qint32 len);
static int rx_callback(airspy_transfer_t* transfer);
};
#endif // INCLUDE_AIRSPYTHREAD_H