VE7UWU/sdrangel
1
0
Fork 0
mirror of https://github.com/f4exb/sdrangel.git synced 2025-08-04 23:12:25 -04:00
Code Issues Projects Releases Wiki Activity

ChannelAnalyzerNG: decouple demod and GUI

Browse Source
This commit is contained in:
f4exb 2017-09-29 18:36:33 +02:00
parent 54bd4b38f0
commit 4d07272503
4 changed files with 864 additions and 736 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -16,17 +16,23 @@
#include "chanalyzerng.h" #include "chanalyzerng.h"
#include <dsp/downchannelizer.h>
#include <QTime> #include <QTime>
#include <QDebug> #include <QDebug>
#include <stdio.h> #include <stdio.h>
#include "device/devicesourceapi.h"
#include "audio/audiooutput.h" #include "audio/audiooutput.h"
#include "dsp/threadedbasebandsamplesink.h"
#include "dsp/downchannelizer.h"
MESSAGE_CLASS_DEFINITION(ChannelAnalyzerNG::MsgConfigureChannelAnalyzer, Message) MESSAGE_CLASS_DEFINITION(ChannelAnalyzerNG::MsgConfigureChannelAnalyzer, Message)
MESSAGE_CLASS_DEFINITION(ChannelAnalyzerNG::MsgConfigureChannelizer, Message)
MESSAGE_CLASS_DEFINITION(ChannelAnalyzerNG::MsgReportChannelSampleRateChanged, Message)
ChannelAnalyzerNG::ChannelAnalyzerNG(BasebandSampleSink* sampleSink) : ChannelAnalyzerNG::ChannelAnalyzerNG(DeviceSourceAPI *deviceAPI) :
m_sampleSink(sampleSink), m_deviceAPI(deviceAPI),
m_sampleSink(0),
m_settingsMutex(QMutex::Recursive) m_settingsMutex(QMutex::Recursive)
{ {
m_undersampleCount = 0; m_undersampleCount = 0;
@ -38,6 +44,12 @@ ChannelAnalyzerNG::ChannelAnalyzerNG(BasebandSampleSink* sampleSink) :
m_interpolatorDistanceRemain = 0.0f; m_interpolatorDistanceRemain = 0.0f;
SSBFilter = new fftfilt(m_config.m_LowCutoff / m_config.m_inputSampleRate, m_config.m_Bandwidth / m_config.m_inputSampleRate, ssbFftLen); SSBFilter = new fftfilt(m_config.m_LowCutoff / m_config.m_inputSampleRate, m_config.m_Bandwidth / m_config.m_inputSampleRate, ssbFftLen);
DSBFilter = new fftfilt(m_config.m_Bandwidth / m_config.m_inputSampleRate, 2*ssbFftLen); DSBFilter = new fftfilt(m_config.m_Bandwidth / m_config.m_inputSampleRate, 2*ssbFftLen);
m_channelizer = new DownChannelizer(this);
m_threadedChannelizer = new ThreadedBasebandSampleSink(m_channelizer, this);
connect(m_channelizer, SIGNAL(inputSampleRateChanged()), this, SLOT(channelizerInputSampleRateChanged()));
m_deviceAPI->addThreadedSink(m_threadedChannelizer);
apply(true); apply(true);
} }
@ -45,6 +57,9 @@ ChannelAnalyzerNG::~ChannelAnalyzerNG()
{ {
if (SSBFilter) delete SSBFilter; if (SSBFilter) delete SSBFilter;
if (DSBFilter) delete DSBFilter; if (DSBFilter) delete DSBFilter;
m_deviceAPI->removeThreadedSink(m_threadedChannelizer);
delete m_threadedChannelizer;
delete m_channelizer;
} }
void ChannelAnalyzerNG::configure(MessageQueue* messageQueue, void ChannelAnalyzerNG::configure(MessageQueue* messageQueue,
@ -54,7 +69,7 @@ void ChannelAnalyzerNG::configure(MessageQueue* messageQueue,
int spanLog2, int spanLog2,
bool ssb) bool ssb)
{ {
Message* cmd = MsgConfigureChannelAnalyzer::create(channelSampleRate, Bandwidth, LowCutoff, spanLog2, ssb); Message* cmd = MsgConfigureChannelAnalyzer::create(channelSampleRate, Bandwidth, LowCutoff, spanLog2, ssb);
messageQueue->push(cmd); messageQueue->push(cmd);
} }
@ -102,6 +117,12 @@ void ChannelAnalyzerNG::stop()
{ {
} }
void ChannelAnalyzerNG::channelizerInputSampleRateChanged()
{
MsgReportChannelSampleRateChanged *msg = MsgReportChannelSampleRateChanged::create();
getMessageQueueToGUI()->push(msg);
}
bool ChannelAnalyzerNG::handleMessage(const Message& cmd) bool ChannelAnalyzerNG::handleMessage(const Message& cmd)
{ {
qDebug() << "ChannelAnalyzerNG::handleMessage: " << cmd.getIdentifier(); qDebug() << "ChannelAnalyzerNG::handleMessage: " << cmd.getIdentifier();
@ -120,11 +141,19 @@ bool ChannelAnalyzerNG::handleMessage(const Message& cmd)
apply(); apply();
return true; return true;
} }
else if (MsgConfigureChannelizer::match(cmd))
{
MsgConfigureChannelizer& cfg = (MsgConfigureChannelizer&) cmd;
m_channelizer->configure(m_channelizer->getInputMessageQueue(),
cfg.getSampleRate(),
cfg.getCenterFrequency());
return true;
}
else if (MsgConfigureChannelAnalyzer::match(cmd)) else if (MsgConfigureChannelAnalyzer::match(cmd))
{ {
MsgConfigureChannelAnalyzer& cfg = (MsgConfigureChannelAnalyzer&) cmd; MsgConfigureChannelAnalyzer& cfg = (MsgConfigureChannelAnalyzer&) cmd;
m_config.m_channelSampleRate = cfg.getChannelSampleRate(); m_config.m_channelSampleRate = cfg.getChannelSampleRate();
m_config.m_Bandwidth = cfg.getBandwidth(); m_config.m_Bandwidth = cfg.getBandwidth();
m_config.m_LowCutoff = cfg.getLoCutoff(); m_config.m_LowCutoff = cfg.getLoCutoff();
m_config.m_spanLog2 = cfg.getSpanLog2(); m_config.m_spanLog2 = cfg.getSpanLog2();
@ -153,6 +182,8 @@ bool ChannelAnalyzerNG::handleMessage(const Message& cmd)
} }
} }
void ChannelAnalyzerNG::apply(bool force) void ChannelAnalyzerNG::apply(bool force)
{ {
if ((m_running.m_frequency != m_config.m_frequency) || if ((m_running.m_frequency != m_config.m_frequency) ||

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

@ -1,183 +1,242 @@
/////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////
// Copyright (C) 2017 Edouard Griffiths, F4EXB // // Copyright (C) 2017 Edouard Griffiths, F4EXB //
// // // //
// This program is free software; you can redistribute it and/or modify // // 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 // // it under the terms of the GNU General Public License as published by //
// the Free Software Foundation as version 3 of the License, or // // the Free Software Foundation as version 3 of the License, or //
// // // //
// This program is distributed in the hope that it will be useful, // // This program is distributed in the hope that it will be useful, //
// but WITHOUT ANY WARRANTY; without even the implied warranty of // // but WITHOUT ANY WARRANTY; without even the implied warranty of //
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
// GNU General Public License V3 for more details. // // GNU General Public License V3 for more details. //
// // // //
// You should have received a copy of the GNU General Public License // // You should have received a copy of the GNU General Public License //
// along with this program. If not, see <http://www.gnu.org/licenses/>. // // along with this program. If not, see <http://www.gnu.org/licenses/>. //
/////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////
#ifndef INCLUDE_CHANALYZERNG_H #ifndef INCLUDE_CHANALYZERNG_H
#define INCLUDE_CHANALYZERNG_H #define INCLUDE_CHANALYZERNG_H
#include <dsp/basebandsamplesink.h> #include <dsp/basebandsamplesink.h>
#include <QMutex> #include <QMutex>
#include <vector> #include <vector>
#include "dsp/interpolator.h" #include "dsp/interpolator.h"
#include "dsp/ncof.h" #include "dsp/ncof.h"
#include "dsp/fftfilt.h" #include "dsp/fftfilt.h"
#include "audio/audiofifo.h" #include "audio/audiofifo.h"
#include "util/message.h" #include "util/message.h"
#define ssbFftLen 1024 #define ssbFftLen 1024
class ChannelAnalyzerNG : public BasebandSampleSink { class DeviceSourceAPI;
public: class ThreadedBasebandSampleSink;
ChannelAnalyzerNG(BasebandSampleSink* m_sampleSink); class DownChannelizer;
virtual ~ChannelAnalyzerNG();
class ChannelAnalyzerNG : public BasebandSampleSink {
void configure(MessageQueue* messageQueue, public:
int channelSampleRate, class MsgConfigureChannelAnalyzer : public Message {
Real Bandwidth, MESSAGE_CLASS_DECLARATION
Real LowCutoff,
int spanLog2, public:
bool ssb); int getChannelSampleRate() const { return m_channelSampleRate; }
Real getBandwidth() const { return m_Bandwidth; }
int getInputSampleRate() const { return m_running.m_inputSampleRate; } Real getLoCutoff() const { return m_LowCutoff; }
int getChannelSampleRate() const { return m_running.m_channelSampleRate; } int getSpanLog2() const { return m_spanLog2; }
double getMagSq() const { return m_magsq; } bool getSSB() const { return m_ssb; }
virtual void feed(const SampleVector::const_iterator& begin, const SampleVector::const_iterator& end, bool positiveOnly); static MsgConfigureChannelAnalyzer* create(
virtual void start(); int channelSampleRate,
virtual void stop(); Real Bandwidth,
virtual bool handleMessage(const Message& cmd); Real LowCutoff,
int spanLog2,
private: bool ssb)
class MsgConfigureChannelAnalyzer : public Message { {
MESSAGE_CLASS_DECLARATION return new MsgConfigureChannelAnalyzer(
channelSampleRate,
public: Bandwidth,
int getChannelSampleRate() const { return m_channelSampleRate; } LowCutoff,
Real getBandwidth() const { return m_Bandwidth; } spanLog2,
Real getLoCutoff() const { return m_LowCutoff; } ssb);
int getSpanLog2() const { return m_spanLog2; } }
bool getSSB() const { return m_ssb; }
private:
static MsgConfigureChannelAnalyzer* create( int m_channelSampleRate;
int channelSampleRate, Real m_Bandwidth;
Real Bandwidth, Real m_LowCutoff;
Real LowCutoff, int m_spanLog2;
int spanLog2, bool m_ssb;
bool ssb)
{ MsgConfigureChannelAnalyzer(
return new MsgConfigureChannelAnalyzer(channelSampleRate, Bandwidth, LowCutoff, spanLog2, ssb); int channelSampleRate,
} Real Bandwidth,
Real LowCutoff,
private: int spanLog2,
int m_channelSampleRate; bool ssb) :
Real m_Bandwidth; Message(),
Real m_LowCutoff; m_channelSampleRate(channelSampleRate),
int m_spanLog2; m_Bandwidth(Bandwidth),
bool m_ssb; m_LowCutoff(LowCutoff),
m_spanLog2(spanLog2),
MsgConfigureChannelAnalyzer( m_ssb(ssb)
int channelSampleRate, { }
Real Bandwidth, };
Real LowCutoff,
int spanLog2, class MsgConfigureChannelizer : public Message {
bool ssb) : MESSAGE_CLASS_DECLARATION
Message(),
m_channelSampleRate(channelSampleRate), public:
m_Bandwidth(Bandwidth), int getSampleRate() const { return m_sampleRate; }
m_LowCutoff(LowCutoff), int getCenterFrequency() const { return m_centerFrequency; }
m_spanLog2(spanLog2),
m_ssb(ssb) static MsgConfigureChannelizer* create(int sampleRate, int centerFrequency)
{ } {
}; return new MsgConfigureChannelizer(sampleRate, centerFrequency);
}
struct Config
{ private:
int m_frequency; int m_sampleRate;
int m_inputSampleRate; int m_centerFrequency;
int m_channelSampleRate;
Real m_Bandwidth; MsgConfigureChannelizer(int sampleRate, int centerFrequency) :
Real m_LowCutoff; Message(),
int m_spanLog2; m_sampleRate(sampleRate),
bool m_ssb; m_centerFrequency(centerFrequency)
{ }
Config() : };
m_frequency(0),
m_inputSampleRate(96000), class MsgReportChannelSampleRateChanged : public Message {
m_channelSampleRate(96000), MESSAGE_CLASS_DECLARATION
m_Bandwidth(5000),
m_LowCutoff(300), public:
m_spanLog2(3),
m_ssb(false) static MsgReportChannelSampleRateChanged* create()
{} {
}; return new MsgReportChannelSampleRateChanged();
}
Config m_config;
Config m_running; private:
int m_undersampleCount; MsgReportChannelSampleRateChanged() :
fftfilt::cmplx m_sum; Message()
bool m_usb; { }
double m_magsq; };
bool m_useInterpolator;
ChannelAnalyzerNG(DeviceSourceAPI *deviceAPI);
NCOF m_nco; virtual ~ChannelAnalyzerNG();
Interpolator m_interpolator; void setSampleSink(BasebandSampleSink* sampleSink) { m_sampleSink = sampleSink; }
Real m_interpolatorDistance;
Real m_interpolatorDistanceRemain; void configure(MessageQueue* messageQueue,
int channelSampleRate,
fftfilt* SSBFilter; Real Bandwidth,
fftfilt* DSBFilter; Real LowCutoff,
int spanLog2,
BasebandSampleSink* m_sampleSink; bool ssb);
SampleVector m_sampleBuffer;
QMutex m_settingsMutex; DownChannelizer *getChannelizer() { return m_channelizer; }
int getInputSampleRate() const { return m_running.m_inputSampleRate; }
void apply(bool force = false); int getChannelSampleRate() const { return m_running.m_channelSampleRate; }
double getMagSq() const { return m_magsq; }
void processOneSample(Complex& c, fftfilt::cmplx *sideband)
{ virtual void feed(const SampleVector::const_iterator& begin, const SampleVector::const_iterator& end, bool positiveOnly);
int n_out; virtual void start();
int decim = 1<<m_running.m_spanLog2; virtual void stop();
virtual bool handleMessage(const Message& cmd);
if (m_running.m_ssb)
{ private slots:
n_out = SSBFilter->runSSB(c, &sideband, m_usb); void channelizerInputSampleRateChanged();
}
else private:
{
n_out = DSBFilter->runDSB(c, &sideband); struct Config
} {
int m_frequency;
for (int i = 0; i < n_out; i++) int m_inputSampleRate;
{ int m_channelSampleRate;
// Downsample by 2^(m_scaleLog2 - 1) for SSB band spectrum display Real m_Bandwidth;
// smart decimation with bit gain using float arithmetic (23 bits significand) Real m_LowCutoff;
int m_spanLog2;
m_sum += sideband[i]; bool m_ssb;
if (!(m_undersampleCount++ & (decim - 1))) // counter LSB bit mask for decimation by 2^(m_scaleLog2 - 1) Config() :
{ m_frequency(0),
m_sum /= decim; m_inputSampleRate(96000),
m_magsq = (m_sum.real() * m_sum.real() + m_sum.imag() * m_sum.imag())/ (1<<30); m_channelSampleRate(96000),
m_Bandwidth(5000),
if (m_running.m_ssb & !m_usb) m_LowCutoff(300),
{ // invert spectrum for LSB m_spanLog2(3),
//m_sampleBuffer.push_back(Sample(m_sum.imag() * 32768.0, m_sum.real() * 32768.0)); m_ssb(false)
m_sampleBuffer.push_back(Sample(m_sum.imag(), m_sum.real())); {}
} };
else
{ Config m_config;
//m_sampleBuffer.push_back(Sample(m_sum.real() * 32768.0, m_sum.imag() * 32768.0)); Config m_running;
m_sampleBuffer.push_back(Sample(m_sum.real(), m_sum.imag()));
} DeviceSourceAPI *m_deviceAPI;
ThreadedBasebandSampleSink* m_threadedChannelizer;
m_sum = 0; DownChannelizer* m_channelizer;
}
} int m_undersampleCount;
} fftfilt::cmplx m_sum;
}; bool m_usb;
double m_magsq;
#endif // INCLUDE_CHANALYZERNG_H bool m_useInterpolator;
NCOF m_nco;
Interpolator m_interpolator;
Real m_interpolatorDistance;
Real m_interpolatorDistanceRemain;
fftfilt* SSBFilter;
fftfilt* DSBFilter;
BasebandSampleSink* m_sampleSink;
SampleVector m_sampleBuffer;
QMutex m_settingsMutex;
void apply(bool force = false);
void processOneSample(Complex& c, fftfilt::cmplx *sideband)
{
int n_out;
int decim = 1<<m_running.m_spanLog2;
if (m_running.m_ssb)
{
n_out = SSBFilter->runSSB(c, &sideband, m_usb);
}
else
{
n_out = DSBFilter->runDSB(c, &sideband);
}
for (int i = 0; i < n_out; i++)
{
// Downsample by 2^(m_scaleLog2 - 1) for SSB band spectrum display
// smart decimation with bit gain using float arithmetic (23 bits significand)
m_sum += sideband[i];
if (!(m_undersampleCount++ & (decim - 1))) // counter LSB bit mask for decimation by 2^(m_scaleLog2 - 1)
{
m_sum /= decim;
m_magsq = (m_sum.real() * m_sum.real() + m_sum.imag() * m_sum.imag())/ (1<<30);
if (m_running.m_ssb & !m_usb)
{ // invert spectrum for LSB
//m_sampleBuffer.push_back(Sample(m_sum.imag() * 32768.0, m_sum.real() * 32768.0));
m_sampleBuffer.push_back(Sample(m_sum.imag(), m_sum.real()));
}
else
{
//m_sampleBuffer.push_back(Sample(m_sum.real() * 32768.0, m_sum.imag() * 32768.0));
m_sampleBuffer.push_back(Sample(m_sum.real(), m_sum.imag()));
}
m_sum = 0;
}
}
}
};
#endif // INCLUDE_CHANALYZERNG_H

1127
plugins/channelrx/chanalyzerng/chanalyzernggui.cpp
View File

File diff suppressed because it is too large Load Diff

7
plugins/channelrx/chanalyzerng/chanalyzernggui.h
View File

@ -59,7 +59,7 @@ public:
private slots: private slots:
void viewChanged(); void viewChanged();
void channelizerInputSampleRateChanged(); // void channelizerInputSampleRateChanged();
void on_deltaFrequency_changed(qint64 value); void on_deltaFrequency_changed(qint64 value);
void on_channelSampleRate_changed(quint64 value); void on_channelSampleRate_changed(quint64 value);
void on_useRationalDownsampler_toggled(bool checked); void on_useRationalDownsampler_toggled(bool checked);
@ -69,6 +69,7 @@ private slots:
void on_ssb_toggled(bool checked); void on_ssb_toggled(bool checked);
void onWidgetRolled(QWidget* widget, bool rollDown); void onWidgetRolled(QWidget* widget, bool rollDown);
void onMenuDoubleClicked(); void onMenuDoubleClicked();
void handleInputMessages();
void tick(); void tick();
private: private:
@ -82,8 +83,8 @@ private:
int m_spanLog2; int m_spanLog2;
MovingAverage<double> m_channelPowerDbAvg; MovingAverage<double> m_channelPowerDbAvg;
ThreadedBasebandSampleSink* m_threadedChannelizer; // ThreadedBasebandSampleSink* m_threadedChannelizer;
DownChannelizer* m_channelizer; // DownChannelizer* m_channelizer;
ChannelAnalyzerNG* m_channelAnalyzer; ChannelAnalyzerNG* m_channelAnalyzer;
SpectrumScopeNGComboVis* m_spectrumScopeComboVis; SpectrumScopeNGComboVis* m_spectrumScopeComboVis;
SpectrumVis* m_spectrumVis; SpectrumVis* m_spectrumVis;