Signal detection block using energy detection. More...

#include <signal_detector_cvf.h>

Inheritance diagram for gr::inspector::signal_detector_cvf:

Public Types
typedef boost::shared_ptr< signal_detector_cvf >	sptr

Public Member Functions
virtual void	set_samp_rate (double d_samp_rate)=0

virtual void	set_fft_len (int fft_len)=0

virtual void	set_window_type (int d_window)=0

virtual void	set_threshold (float d_threshold)=0

virtual void	set_sensitivity (float d_sensitivity)=0

virtual void	set_auto_threshold (bool d_auto_threshold)=0

virtual void	set_average (float d_average)=0

Static Public Member Functions
static sptr	make (double samp_rate, int fft_len=1024, int window_type=0, float threshold=0.7, float sensitivity=0.2, bool auto_threshold=true, float average=0.8, float quantization=0.01, float min_bw=0.0, const char *filename="")
	Return a signal detector block instance. More...

Detailed Description

Signal detection block using energy detection.

Takes input spectrum as complex float and performs an energy detection to find potential continuous signals and build a RF map (tuple of center frequency and bandwidth). The RF map gets passed as a message with center frequency and bandwidth information for each detected signal.

Threshold for energy detection can either be set in dB or an automatic threshold calculation can be performed by setting a sensitivity between 0 and 1. The PSD is then sorted and searched for relative power jumps with height (1-sensitivity) and the threshold is set to the sample before that jump (which should be the strongest noise sample).

To surpress false detection in noisy scenarios, the minimum signal bandwidth can be set. All detected signals smaller than this value will not be written in the RF map.

To average the PSD (and provide a better detection) an single pole IIR filter is implemented in this block. The parameter alpha can be set as block parameter. The IIR equation yields y[n] = alpha*x[n]+(1-alpha)*y[n-1].

The bandwidth of the detected signals can be quantized relative to the sampling rate. This leads to less recalculations in the Signal Separator block. There, a filter must be recalculated, when the bandwidth of a signal changed.

Member Typedef Documentation

◆ sptr

typedef boost::shared_ptr<signal_detector_cvf> gr::inspector::signal_detector_cvf::sptr

Member Function Documentation

◆ make()

static sptr gr::inspector::signal_detector_cvf::make	(	double	samp_rate,
		int	fft_len = `1024`,
		int	window_type = `0`,
		float	threshold = `0.7`,
		float	sensitivity = `0.2`,
		bool	auto_threshold = `true`,
		float	average = `0.8`,
		float	quantization = `0.01`,
		float	min_bw = `0.0`,
		const char *	filename = `""`
	)

static

Return a signal detector block instance.

Parameters

samp_rate	Sample rate of the input signal
fft_len	Desired number of FFT points for the PSD. Also sets the input items consumed in evry work cycle.
window_type	Firdes window type to scale the input samples with
threshold	Threshold in dB for energy detection when automatic signal detection is disabled
sensitivity	Sensitivity value between 0 and 1 if automatic signal detection is enabled
auto_threshold	Bool to set automatic threshold calculation
average	Averaging factor in (0,1] (equal to alpha in IIR equation)
quantization	Bandwidth quantization yields quantization*samp_rate [Hz]
min_bw	Minimum signal bandwidth. Don't pass any narrower signals.
filename	Path to a file where the detections are logged. Leave empty for no log.