gr::filter::kernel::pfb_arb_resampler_ccf Class Reference

Polyphase filterbank arbitrary resampler with gr_complex input, gr_complex output and float taps. More...

#include <gnuradio/filter/pfb_arb_resampler.h>

Public Member Functions
	pfb_arb_resampler_ccf (float rate, const std::vector< float > &taps, unsigned int filter_size)
	pfb_arb_resampler_ccf (const pfb_arb_resampler_ccf &)=delete
pfb_arb_resampler_ccf &	operator= (const pfb_arb_resampler_ccf &)=delete
void	set_taps (const std::vector< float > &taps)
std::vector< std::vector< float > >	taps () const
void	print_taps ()
void	set_rate (float rate)
void	set_phase (float ph)
float	phase () const
unsigned int	taps_per_filter () const
unsigned int	interpolation_rate () const
unsigned int	decimation_rate () const
float	fractional_rate () const
int	group_delay () const
float	phase_offset (float freq, float fs)
int	filter (gr_complex *output, gr_complex *input, int n_to_read, int &n_read)

Detailed Description

Polyphase filterbank arbitrary resampler with gr_complex input, gr_complex output and float taps.

This takes in a signal stream and performs arbitrary resampling. The resampling rate can be any real number r. The resampling is done by constructing N filters where N is the interpolation rate. We then calculate D where D = floor(N/r).

Using N and D, we can perform rational resampling where N/D is a rational number close to the input rate r where we have N filters and we cycle through them as a polyphase filterbank with a stride of D so that i+1 = (i + D) % N.

To get the arbitrary rate, we want to interpolate between two points. For each value out, we take an output from the current filter, i, and the next filter i+1 and then linearly interpolate between the two based on the real resampling rate we want.

The linear interpolation only provides us with an approximation to the real sampling rate specified. The error is a quantization error between the two filters we used as our interpolation points. To this end, the number of filters, N, used determines the quantization error; the larger N, the smaller the noise. You can design for a specified noise floor by setting the filter size (parameters filter_size). The size defaults to 32 filters, which is about as good as most implementations need.

The trick with designing this filter is in how to specify the taps of the prototype filter. Like the PFB interpolator, the taps are specified using the interpolated filter rate. In this case, that rate is the input sample rate multiplied by the number of filters in the filterbank, which is also the interpolation rate. All other values should be relative to this rate.

For example, for a 32-filter arbitrary resampler and using the GNU Radio's firdes utility to build the filter, we build a low-pass filter with a sampling rate of fs, a 3-dB bandwidth of BW and a transition bandwidth of TB. We can also specify the out-of-band attenuation to use, ATT, and the filter window function (a Blackman-harris window in this case). The first input is the gain of the filter, which we specify here as the interpolation rate (32).

self._taps = filter.firdes.low_pass_2(32, 32*fs, BW, TB, attenuation_dB=ATT, window=fft.window.WIN_BLACKMAN_hARRIS)

The theory behind this block can be found in Chapter 7.5 of the following book:

f. harris, "Multirate Signal Processing for Communication Systems", Upper Saddle River, NJ: Prentice Hall, Inc. 2004.

Constructor & Destructor Documentation

pfb_arb_resampler_ccf() [1/2]

gr::filter::kernel::pfb_arb_resampler_ccf::pfb_arb_resampler_ccf	(	float	rate,
		const std::vector< float > &	taps,
		unsigned int	filter_size
	)

Creates a kernel to perform arbitrary resampling on a set of samples.

Parameters

rate	(float) Specifies the resampling rate to use
taps	(vector/list of floats) The prototype filter to populate the filterbank. The taps * should be generated at the filter_size sampling rate.
filter_size	(unsigned int) The number of filters in the filter bank. This is directly related to quantization noise introduced during the resampling. Defaults to 32 filters.

pfb_arb_resampler_ccf() [2/2]

gr::filter::kernel::pfb_arb_resampler_ccf::pfb_arb_resampler_ccf ( const pfb_arb_resampler_ccf &  )

delete

Member Function Documentation

decimation_rate()

unsigned int gr::filter::kernel::pfb_arb_resampler_ccf::decimation_rate ( ) const

inline

filter()

int gr::filter::kernel::pfb_arb_resampler_ccf::filter	(	gr_complex *	output,
		gr_complex *	input,
		int	n_to_read,
		int &	n_read
	)

Performs the filter operation that resamples the signal.

This block takes in a stream of samples and outputs a resampled and filtered stream. This block should be called such that the output has rate * n_to_read amount of space available in the output buffer.

Parameters

output	The output samples at the new sample rate.
input	An input vector of samples to be resampled
n_to_read	Number of samples to read from input.
n_read	(out) Number of samples actually read from input.

Returns

Number of samples put into output.

fractional_rate()

float gr::filter::kernel::pfb_arb_resampler_ccf::fractional_rate ( ) const

inline

group_delay()

int gr::filter::kernel::pfb_arb_resampler_ccf::group_delay ( ) const

inline

Get the group delay of the filter.

interpolation_rate()

unsigned int gr::filter::kernel::pfb_arb_resampler_ccf::interpolation_rate ( ) const

inline

operator=()

pfb_arb_resampler_ccf& gr::filter::kernel::pfb_arb_resampler_ccf::operator= ( const pfb_arb_resampler_ccf &  )

delete

phase()

float gr::filter::kernel::pfb_arb_resampler_ccf::phase

(

)

const

Gets the current phase of the resampler in radians (2 to 2pi).

phase_offset()

float gr::filter::kernel::pfb_arb_resampler_ccf::phase_offset	(	float	freq,
		float	fs
	)

Calculates the phase offset expected by a sine wave of frequency freq and sampling rate fs (assuming input sine wave has 0 degree phase).

print_taps()

void gr::filter::kernel::pfb_arb_resampler_ccf::print_taps

(

)

Print all of the filterbank taps to screen.

set_phase()

void gr::filter::kernel::pfb_arb_resampler_ccf::set_phase

(

float

ph

)

Sets the current phase offset in radians (0 to 2pi).

set_rate()

void gr::filter::kernel::pfb_arb_resampler_ccf::set_rate

(

float

rate

)

Sets the resampling rate of the block.

set_taps()

void gr::filter::kernel::pfb_arb_resampler_ccf::set_taps

(

const std::vector< float > &

taps

)

Resets the filterbank's filter taps with the new prototype filter

Parameters

taps	(vector/list of floats) The prototype filter to populate the filterbank.

taps()

std::vector<std::vector<float> > gr::filter::kernel::pfb_arb_resampler_ccf::taps

(

)

const

Return a vector<vector<>> of the filterbank taps

taps_per_filter()

unsigned int gr::filter::kernel::pfb_arb_resampler_ccf::taps_per_filter

(

)

const

Gets the number of taps per filter.

---

The documentation for this class was generated from the following file:

• pfb_arb_resampler.h