VE7UWU
/
sdrangel
mirror of https://github.com/f4exb/sdrangel.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Channel analyzer NG: created settings

This commit is contained in:
f4exb 2018-05-19 05:03:56 +02:00
parent 9f48378677
commit 3e5bcf7e00
5 changed files with 325 additions and 6 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
plugins/channelrx/chanalyzerng/CMakeLists.txt
View File

@ -4,12 +4,14 @@ set(chanalyzerng_SOURCES
chanalyzerng.cpp
chanalyzernggui.cpp
chanalyzerngplugin.cpp
chanalyzerngsettings.cpp
)
set(chanalyzerng_HEADERS
chanalyzerng.h
chanalyzernggui.h
chanalyzerngplugin.h
chanalyzerngsettings.h
)
set(chanalyzerng_FORMS

131
plugins/channelrx/chanalyzerng/chanalyzerng.cpp
View File

@ -26,6 +26,7 @@
#include "dsp/downchannelizer.h"
MESSAGE_CLASS_DEFINITION(ChannelAnalyzerNG::MsgConfigureChannelAnalyzer, Message)
MESSAGE_CLASS_DEFINITION(ChannelAnalyzerNG::MsgConfigureChannelAnalyzerOld, Message)
MESSAGE_CLASS_DEFINITION(ChannelAnalyzerNG::MsgConfigureChannelizer, Message)
MESSAGE_CLASS_DEFINITION(ChannelAnalyzerNG::MsgReportChannelSampleRateChanged, Message)
@ -81,7 +82,7 @@ void ChannelAnalyzerNG::configure(MessageQueue* messageQueue,
bool fll,
unsigned int pllPskOrder)
{
Message* cmd = MsgConfigureChannelAnalyzer::create(channelSampleRate, Bandwidth, LowCutoff, spanLog2, ssb, pll, fll, pllPskOrder);
Message* cmd = MsgConfigureChannelAnalyzerOld::create(channelSampleRate, Bandwidth, LowCutoff, spanLog2, ssb, pll, fll, pllPskOrder);
messageQueue->push(cmd);
}
@ -162,9 +163,9 @@ bool ChannelAnalyzerNG::handleMessage(const Message& cmd)
cfg.getCenterFrequency());
return true;
}
else if (MsgConfigureChannelAnalyzer::match(cmd))
else if (MsgConfigureChannelAnalyzerOld::match(cmd))
{
MsgConfigureChannelAnalyzer& cfg = (MsgConfigureChannelAnalyzer&) cmd;
MsgConfigureChannelAnalyzerOld& cfg = (MsgConfigureChannelAnalyzerOld&) cmd;
m_config.m_channelSampleRate = cfg.getChannelSampleRate();
m_config.m_Bandwidth = cfg.getBandwidth();
@ -300,3 +301,127 @@ void ChannelAnalyzerNG::apply(bool force)
m_running.m_pllPskOrder = m_config.m_pllPskOrder;
//m_settingsMutex.unlock();
}
void ChannelAnalyzerNG::applyChannelSettings(int inputSampleRate, int inputFrequencyOffset, bool force)
{
qDebug() << "ChannelAnalyzerNG::applyChannelSettings:"
<< " inputSampleRate: " << inputSampleRate
<< " inputFrequencyOffset: " << inputFrequencyOffset;
if ((m_inputFrequencyOffset != inputFrequencyOffset) ||
(m_inputSampleRate != inputSampleRate) || force)
{
m_nco.setFreq(-inputFrequencyOffset, inputSampleRate);
}
if ((m_inputSampleRate != inputSampleRate) || force)
{
m_settingsMutex.lock();
m_interpolator.create(16, inputSampleRate, inputSampleRate / 2.2f);
m_interpolatorDistanceRemain = 0;
m_interpolatorDistance = (Real) inputSampleRate / (Real) m_settings.m_downSampleRate;
if (!m_settings.m_downSample)
{
setFilters(inputSampleRate, m_settings.m_bandwidth, m_settings.m_lowCutoff);
m_pll.setSampleRate(inputSampleRate / (1<<m_settings.m_spanLog2));
m_fll.setSampleRate(inputSampleRate / (1<<m_settings.m_spanLog2));
}
m_settingsMutex.unlock();
}
m_inputSampleRate = inputSampleRate;
m_inputFrequencyOffset = inputFrequencyOffset;
}
void ChannelAnalyzerNG::setFilters(int sampleRate, float bandwidth, float lowCutoff)
{
if (bandwidth < 0)
{
bandwidth = -bandwidth;
lowCutoff = -lowCutoff;
m_usb = false;
}
else
{
m_usb = true;
}
if (bandwidth < 100.0f)
{
bandwidth = 100.0f;
lowCutoff = 0;
}
SSBFilter->create_filter(lowCutoff / sampleRate, bandwidth / sampleRate);
DSBFilter->create_dsb_filter(bandwidth / sampleRate);
}
void ChannelAnalyzerNG::applySettings(const ChannelAnalyzerNGSettings& settings, bool force)
{
if ((settings.m_downSampleRate != m_settings.m_downSampleRate) || force)
{
m_settingsMutex.lock();
m_interpolator.create(16, m_inputSampleRate, m_inputSampleRate / 2.2);
m_interpolatorDistanceRemain = 0.0f;
m_interpolatorDistance = (Real) m_inputSampleRate / (Real) settings.m_downSampleRate;
m_settingsMutex.unlock();
}
if ((settings.m_downSample != m_settings.m_downSample) || force)
{
m_settingsMutex.lock();
m_useInterpolator = settings.m_downSample;
if (settings.m_downSample)
{
setFilters(settings.m_downSampleRate, settings.m_bandwidth, settings.m_lowCutoff);
m_pll.setSampleRate(settings.m_downSampleRate / (1<<settings.m_spanLog2));
m_fll.setSampleRate(settings.m_downSampleRate / (1<<settings.m_spanLog2));
}
m_settingsMutex.unlock();
}
if ((settings.m_bandwidth != m_settings.m_bandwidth) ||
(settings.m_lowCutoff != m_settings.m_lowCutoff)|| force)
{
m_settingsMutex.lock();
setFilters(settings.m_downSample ? settings.m_downSampleRate : m_inputSampleRate, settings.m_bandwidth, settings.m_lowCutoff);
m_settingsMutex.unlock();
}
if ((settings.m_spanLog2 != m_settings.m_spanLog2) || force)
{
int sampleRate = (settings.m_downSample ? settings.m_downSampleRate : m_inputSampleRate) / (1<<m_running.m_spanLog2);
m_pll.setSampleRate(sampleRate);
m_fll.setSampleRate(sampleRate);
}
if (settings.m_pll != m_settings.m_pll || force)
{
if (settings.m_pll)
{
m_pll.reset();
m_fll.reset();
}
}
if (settings.m_fll != m_settings.m_fll || force)
{
if (settings.m_fll) {
m_fll.reset();
}
}
if (settings.m_pllPskOrder != m_settings.m_pllPskOrder || force)
{
if (settings.m_pllPskOrder < 32) {
m_pll.setPskOrder(settings.m_pllPskOrder);
}
}
m_settings = settings;
}

37
plugins/channelrx/chanalyzerng/chanalyzerng.h
View File

@ -30,6 +30,8 @@
#include "audio/audiofifo.h"
#include "util/message.h"
#include "chanalyzerngsettings.h"
#define ssbFftLen 1024
class DeviceSourceAPI;
@ -41,6 +43,29 @@ public:
class MsgConfigureChannelAnalyzer : public Message {
MESSAGE_CLASS_DECLARATION
public:
const ChannelAnalyzerNGSettings& getSettings() const { return m_settings; }
bool getForce() const { return m_force; }
static MsgConfigureChannelAnalyzer* create(const ChannelAnalyzerNGSettings& settings, bool force)
{
return new MsgConfigureChannelAnalyzer(settings, force);
}
private:
ChannelAnalyzerNGSettings m_settings;
bool m_force;
MsgConfigureChannelAnalyzer(const ChannelAnalyzerNGSettings& settings, bool force) :
Message(),
m_settings(settings),
m_force(force)
{ }
};
class MsgConfigureChannelAnalyzerOld : public Message {
MESSAGE_CLASS_DECLARATION
public:
int getChannelSampleRate() const { return m_channelSampleRate; }
Real getBandwidth() const { return m_Bandwidth; }
@ -51,7 +76,7 @@ public:
bool getFLL() const { return m_fll; }
unsigned int getPLLPSKOrder() const { return m_pllPskOrder; }
static MsgConfigureChannelAnalyzer* create(
static MsgConfigureChannelAnalyzerOld* create(
int channelSampleRate,
Real Bandwidth,
Real LowCutoff,
@ -61,7 +86,7 @@ public:
bool fll,
unsigned int pllPskOrder)
{
return new MsgConfigureChannelAnalyzer(
return new MsgConfigureChannelAnalyzerOld(
channelSampleRate,
Bandwidth,
LowCutoff,
@ -82,7 +107,7 @@ public:
bool m_fll;
unsigned int m_pllPskOrder;
MsgConfigureChannelAnalyzer(
MsgConfigureChannelAnalyzerOld(
int channelSampleRate,
Real Bandwidth,
Real LowCutoff,
@ -217,7 +242,10 @@ private:
DeviceSourceAPI *m_deviceAPI;
ThreadedBasebandSampleSink* m_threadedChannelizer;
DownChannelizer* m_channelizer;
ChannelAnalyzerNGSettings m_settings;
int m_inputSampleRate;
int m_inputFrequencyOffset;
int m_undersampleCount;
fftfilt::cmplx m_sum;
bool m_usb;
@ -239,6 +267,9 @@ private:
QMutex m_settingsMutex;
void apply(bool force = false);
void applyChannelSettings(int inputSampleRate, int inputFrequencyOffset, bool force);
void applySettings(const ChannelAnalyzerNGSettings& settings, bool force = false);
void setFilters(int sampleRate, float bandwidth, float lowCutoff);
void processOneSample(Complex& c, fftfilt::cmplx *sideband)
{

110
plugins/channelrx/chanalyzerng/chanalyzerngsettings.cpp Normal file
View File

@ -0,0 +1,110 @@
///////////////////////////////////////////////////////////////////////////////////
// Copyright (C) 2018 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 <QColor>
#include "dsp/dspengine.h"
#include "util/simpleserializer.h"
#include "settings/serializable.h"
#include "chanalyzerngsettings.h"
ChannelAnalyzerNGSettings::ChannelAnalyzerNGSettings() :
m_channelMarker(0)
{
resetToDefaults();
}
void ChannelAnalyzerNGSettings::resetToDefaults()
{
m_frequency = 0;
m_downSample = false;
m_downSampleRate = 0;
m_bandwidth = 5000;
m_lowCutoff = 300;
m_spanLog2 = 3;
m_ssb = false;
m_pll = false;
m_fll = false;
m_pllPskOrder = 1;
}
QByteArray ChannelAnalyzerNGSettings::serialize() const
{
SimpleSerializer s(1);
s.writeS32(1, m_frequency);
s.writeS32(2, m_bandwidth);
s.writeBlob(3, m_spectrumGUI->serialize());
s.writeU32(4, m_rgbColor);
s.writeS32(5, m_lowCutoff);
s.writeS32(6, m_spanLog2);
s.writeBool(7, m_ssb);
s.writeBlob(8, m_scopeGUI->serialize());
s.writeBool(9, m_downSample);
s.writeU32(10, m_downSampleRate);
s.writeBool(11, m_pll);
s.writeBool(12, m_fll);
s.writeU32(13, m_pllPskOrder);
return s.final();
}
bool ChannelAnalyzerNGSettings::deserialize(const QByteArray& data)
{
SimpleDeserializer d(data);
if(!d.isValid())
{
resetToDefaults();
return false;
}
if(d.getVersion() == 1)
{
QByteArray bytetmp;
d.readS32(1, &m_frequency, 0);
d.readS32(2, &m_bandwidth, 5000);
if (m_spectrumGUI) {
d.readBlob(3, &bytetmp);
m_spectrumGUI->deserialize(bytetmp);
}
d.readU32(4, &m_rgbColor);
d.readS32(5, &m_lowCutoff, 3);
d.readS32(6, &m_spanLog2, 3);
d.readBool(7, &m_ssb, false);
if (m_scopeGUI) {
d.readBlob(8, &bytetmp);
m_scopeGUI->deserialize(bytetmp);
}
d.readBool(9, &m_downSample, false);
d.readU32(10, &m_downSampleRate, 2000U);
d.readBool(11, &m_pll, false);
d.readBool(12, &m_fll, false);
d.readU32(13, &m_pllPskOrder, 1);
return true;
}
else
{
resetToDefaults();
return false;
}
}

51
plugins/channelrx/chanalyzerng/chanalyzerngsettings.h Normal file
View File

@ -0,0 +1,51 @@
///////////////////////////////////////////////////////////////////////////////////
// Copyright (C) 2018 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_CHANNELRX_CHANALYZERNG_CHANALYZERNGSETTINGS_H_
#define PLUGINS_CHANNELRX_CHANALYZERNG_CHANALYZERNGSETTINGS_H_
#include <QByteArray>
class Serializable;
struct ChannelAnalyzerNGSettings
{
int m_frequency;
bool m_downSample;
quint32 m_downSampleRate;
int m_bandwidth;
int m_lowCutoff;
int m_spanLog2;
bool m_ssb;
bool m_pll;
bool m_fll;
unsigned int m_pllPskOrder;
quint32 m_rgbColor;
QString m_title;
Serializable *m_channelMarker;
Serializable *m_spectrumGUI;
Serializable *m_scopeGUI;
ChannelAnalyzerNGSettings();
void resetToDefaults();
void setChannelMarker(Serializable *channelMarker) { m_channelMarker = channelMarker; }
QByteArray serialize() const;
bool deserialize(const QByteArray& data);
};
#endif /* PLUGINS_CHANNELRX_CHANALYZERNG_CHANALYZERNGSETTINGS_H_ */