Filter blocks and related functions.
a computationally efficient controllable DC blocker
This block implements a computationally efficient DC blocker that produces a tighter notch filter around DC for a smaller group delay than an equivalent FIR filter or using a single pole IIR filter (though the IIR filter is computationally cheaper).
The block defaults to using a delay line of length 32 and the long form of the filter. Optionally, the delay line length can be changed to alter the width of the DC notch (longer lines will decrease the width).
The long form of the filter produces a nearly flat response outside of the notch but at the cost of a group delay of 2D-2.
The short form of the filter does not have as flat a response in the passband but has a group delay of only D-1 and is cheaper to compute.
The theory behind this block can be found in the paper:
Constructor Specific Documentation:
Make a DC blocker block.
| Parameters: |
|
|---|
declare_sample_delay(dc_blocker_cc_sptr self, unsigned int delay)
pc_input_buffers_full_avg(dc_blocker_cc_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(dc_blocker_cc_sptr self) -> pmt_vector_float
a computationally efficient controllable DC blocker
This block implements a computationally efficient DC blocker that produces a tighter notch filter around DC for a smaller group delay than an equivalent FIR filter or using a single pole IIR filter (though the IIR filter is computationally cheaper).
The block defaults to using a delay line of length 32 and the long form of the filter. Optionally, the delay line length can be changed to alter the width of the DC notch (longer lines will decrease the width).
The long form of the filter produces a nearly flat response outside of the notch but at the cost of a group delay of 2D-2.
The short form of the filter does not have as flat a response in the passband but has a group delay of only D-1 and is cheaper to compute.
The theory behind this block can be found in the paper:
Constructor Specific Documentation:
Make a DC blocker block.
| Parameters: |
|
|---|
declare_sample_delay(dc_blocker_ff_sptr self, unsigned int delay)
pc_input_buffers_full_avg(dc_blocker_ff_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(dc_blocker_ff_sptr self) -> pmt_vector_float
Fast FFT filter with gr_complex input, gr_complex output and gr_complex taps.
This block implements a complex decimating filter using the fast convolution method via an FFT. The decimation factor is an interger that is greater than or equal to 1.
The filter takes a set of complex (or real) taps to use in the filtering operation. These taps can be defined as anything that satisfies the user’s filtering needs. For standard filters such as lowpass, highpass, bandpass, etc., the filter.firdes and filter.optfir classes provide convenient generating methods.
This filter is implemented by using the FFTW package to perform the required FFTs. An optional argument, nthreads, may be passed to the constructor (or set using the set_nthreads member function) to split the FFT among N number of threads. This can improve performance on very large FFTs (that is, if the number of taps used is very large) if you have enough threads/cores to support it.
Constructor Specific Documentation:
Build an FFT filter blocks.
| Parameters: |
|
|---|
declare_sample_delay(fft_filter_ccc_sptr self, unsigned int delay)
pc_input_buffers_full_avg(fft_filter_ccc_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(fft_filter_ccc_sptr self) -> pmt_vector_float
Fast FFT filter with gr_complex input, gr_complex output and float taps.
This block implements a complex decimating filter using the fast convolution method via an FFT. The decimation factor is an interger that is greater than or equal to 1.
The filter takes a set of complex (or real) taps to use in the filtering operation. These taps can be defined as anything that satisfies the user’s filtering needs. For standard filters such as lowpass, highpass, bandpass, etc., the filter.firdes and filter.optfir classes provide convenient generating methods.
This filter is implemented by using the FFTW package to perform the required FFTs. An optional argument, nthreads, may be passed to the constructor (or set using the set_nthreads member function) to split the FFT among N number of threads. This can improve performance on very large FFTs (that is, if the number of taps used is very large) if you have enough threads/cores to support it.
Constructor Specific Documentation:
Build an FFT filter blocks.
| Parameters: |
|
|---|
declare_sample_delay(fft_filter_ccf_sptr self, unsigned int delay)
pc_input_buffers_full_avg(fft_filter_ccf_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(fft_filter_ccf_sptr self) -> pmt_vector_float
Fast FFT filter with float input, float output and float taps.
This block implements a real-value decimating filter using the fast convolution method via an FFT. The decimation factor is an interger that is greater than or equal to 1.
The filter takes a set of real-valued taps to use in the filtering operation. These taps can be defined as anything that satisfies the user’s filtering needs. For standard filters such as lowpass, highpass, bandpass, etc., the filter.firdes and filter.optfir classes provide convenient generating methods.
This filter is implemented by using the FFTW package to perform the required FFTs. An optional argument, nthreads, may be passed to the constructor (or set using the set_nthreads member function) to split the FFT among N number of threads. This can improve performance on very large FFTs (that is, if the number of taps used is very large) if you have enough threads/cores to support it.
Constructor Specific Documentation:
Build an FFT filter block.
| Parameters: |
|
|---|
declare_sample_delay(fft_filter_fff_sptr self, unsigned int delay)
pc_input_buffers_full_avg(fft_filter_fff_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(fft_filter_fff_sptr self) -> pmt_vector_float
Filter-Delay Combination Block.
The block takes one or two float stream and outputs a complex stream.
If only one float stream is input, the real output is a delayed version of this input and the imaginary output is the filtered output.
If two floats are connected to the input, then the real output is the delayed version of the first input, and the imaginary output is the filtered output.
The delay in the real path accounts for the group delay introduced by the filter in the imaginary path. The filter taps needs to be calculated before initializing this block.
Constructor Specific Documentation:
Build a filter with delay block.
| Parameters: | taps – |
|---|
declare_sample_delay(filter_delay_fc_sptr self, unsigned int delay)
pc_input_buffers_full_avg(filter_delay_fc_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(filter_delay_fc_sptr self) -> pmt_vector_float
Filterbank with vector of gr_complex input, vector of gr_complex output and float taps.
This block takes in complex vectors and outputs complex vectors of the same size. Vectors of length N, rather than N normal streams are used to reduce overhead.
Constructor Specific Documentation:
Build the filterbank.
| Parameters: | taps – (vector of vector of floats/list of list of floats) Used to populate the filters. |
|---|
declare_sample_delay(filterbank_vcvcf_sptr self, unsigned int delay)
pc_input_buffers_full_avg(filterbank_vcvcf_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(filterbank_vcvcf_sptr self) -> pmt_vector_float
Print all of the filterbank taps to screen.
Resets the filterbank’s filter taps with the new prototype filter
Return a vector<vector<>> of the filterbank taps
FIR filter with gr_complex input, gr_complex output, and gr_complex taps.
The fir_filter_XXX blocks create finite impulse response (FIR) filters that perform the convolution in the time domain:
The taps are a C++ vector (or Python list) of values of the type specified by the third letter in the block’s suffix. For this block, the value is of type gr_complex. Taps can be created using the firdes or optfir tools.
These versions of the filter can also act as down-samplers (or decimators) by specifying an integer value for .
Constructor Specific Documentation:
FIR filter with gr_complex input, gr_complex output, and gr_complex taps.
| Parameters: |
|
|---|
declare_sample_delay(fir_filter_ccc_sptr self, unsigned int delay)
pc_input_buffers_full_avg(fir_filter_ccc_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(fir_filter_ccc_sptr self) -> pmt_vector_float
FIR filter with gr_complex input, gr_complex output, and float taps.
The fir_filter_XXX blocks create finite impulse response (FIR) filters that perform the convolution in the time domain:
The taps are a C++ vector (or Python list) of values of the type specified by the third letter in the block’s suffix. For this block, the value is of type float. Taps can be created using the firdes or optfir tools.
These versions of the filter can also act as down-samplers (or decimators) by specifying an integer value for .
Constructor Specific Documentation:
FIR filter with gr_complex input, gr_complex output, and float taps.
| Parameters: |
|
|---|
declare_sample_delay(fir_filter_ccf_sptr self, unsigned int delay)
pc_input_buffers_full_avg(fir_filter_ccf_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(fir_filter_ccf_sptr self) -> pmt_vector_float
FIR filter with float input, gr_complex output, and gr_complex taps.
The fir_filter_XXX blocks create finite impulse response (FIR) filters that perform the convolution in the time domain:
The taps are a C++ vector (or Python list) of values of the type specified by the third letter in the block’s suffix. For this block, the value is of type gr_complex. Taps can be created using the firdes or optfir tools.
These versions of the filter can also act as down-samplers (or decimators) by specifying an integer value for .
Constructor Specific Documentation:
FIR filter with float input, gr_complex output, and gr_complex taps.
| Parameters: |
|
|---|
declare_sample_delay(fir_filter_fcc_sptr self, unsigned int delay)
pc_input_buffers_full_avg(fir_filter_fcc_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(fir_filter_fcc_sptr self) -> pmt_vector_float
FIR filter with float input, float output, and float taps.
The fir_filter_XXX blocks create finite impulse response (FIR) filters that perform the convolution in the time domain:
The taps are a C++ vector (or Python list) of values of the type specified by the third letter in the block’s suffix. For this block, the value is of type float. Taps can be created using the firdes or optfir tools.
These versions of the filter can also act as down-samplers (or decimators) by specifying an integer value for .
Constructor Specific Documentation:
FIR filter with float input, float output, and float taps.
| Parameters: |
|
|---|
declare_sample_delay(fir_filter_fff_sptr self, unsigned int delay)
pc_input_buffers_full_avg(fir_filter_fff_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(fir_filter_fff_sptr self) -> pmt_vector_float
FIR filter with float input, short output, and float taps.
The fir_filter_XXX blocks create finite impulse response (FIR) filters that perform the convolution in the time domain:
The taps are a C++ vector (or Python list) of values of the type specified by the third letter in the block’s suffix. For this block, the value is of type float. Taps can be created using the firdes or optfir tools.
These versions of the filter can also act as down-samplers (or decimators) by specifying an integer value for .
Constructor Specific Documentation:
FIR filter with float input, short output, and float taps.
| Parameters: |
|
|---|
declare_sample_delay(fir_filter_fsf_sptr self, unsigned int delay)
pc_input_buffers_full_avg(fir_filter_fsf_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(fir_filter_fsf_sptr self) -> pmt_vector_float
FIR filter with short input, gr_complex output, and gr_complex taps.
The fir_filter_XXX blocks create finite impulse response (FIR) filters that perform the convolution in the time domain:
The taps are a C++ vector (or Python list) of values of the type specified by the third letter in the block’s suffix. For this block, the value is of type gr_complex. Taps can be created using the firdes or optfir tools.
These versions of the filter can also act as down-samplers (or decimators) by specifying an integer value for .
Constructor Specific Documentation:
FIR filter with short input, gr_complex output, and gr_complex taps.
| Parameters: |
|
|---|
declare_sample_delay(fir_filter_scc_sptr self, unsigned int delay)
pc_input_buffers_full_avg(fir_filter_scc_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(fir_filter_scc_sptr self) -> pmt_vector_float
Interpolating MMSE filter with complex input, complex output.
Constructor Specific Documentation:
Build the interpolating MMSE filter (complex input, complex output)
| Parameters: |
|
|---|
declare_sample_delay(fractional_interpolator_cc_sptr self, unsigned int delay)
pc_input_buffers_full_avg(fractional_interpolator_cc_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(fractional_interpolator_cc_sptr self) -> pmt_vector_float
Interpolating MMSE filter with float input, float output.
Constructor Specific Documentation:
Build the interpolating MMSE filter (float input, float output)
| Parameters: |
|
|---|
declare_sample_delay(fractional_interpolator_ff_sptr self, unsigned int delay)
pc_input_buffers_full_avg(fractional_interpolator_ff_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(fractional_interpolator_ff_sptr self) -> pmt_vector_float
resampling MMSE filter with complex input, complex output
Constructor Specific Documentation:
Build the resampling MMSE filter (complex input, complex output)
| Parameters: |
|
|---|
declare_sample_delay(fractional_resampler_cc_sptr self, unsigned int delay)
pc_input_buffers_full_avg(fractional_resampler_cc_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(fractional_resampler_cc_sptr self) -> pmt_vector_float
Resampling MMSE filter with float input, float output.
Constructor Specific Documentation:
Build the resampling MMSE filter (float input, float output)
| Parameters: |
|
|---|
declare_sample_delay(fractional_resampler_ff_sptr self, unsigned int delay)
pc_input_buffers_full_avg(fractional_resampler_ff_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(fractional_resampler_ff_sptr self) -> pmt_vector_float
FIR filter combined with frequency translation with gr_complex input, gr_complex output and gr_complex taps.
This class efficiently combines a frequency translation (typically “down conversion”) with a FIR filter (typically low-pass) and decimation. It is ideally suited for a “channel selection filter” and can be efficiently used to select and decimate a narrow band signal out of wide bandwidth input.
Uses a single input array to produce a single output array. Additional inputs and/or outputs are ignored.
Constructor Specific Documentation:
FIR filter with gr_complex input, gr_complex output, and gr_complex taps that also frequency translates a signal from .
Construct a FIR filter with the given taps and a composite frequency translation that shifts center_freq down to zero Hz. The frequency translation logically comes before the filtering operation.
| Parameters: |
|
|---|
declare_sample_delay(freq_xlating_fir_filter_ccc_sptr self, unsigned int delay)
pc_input_buffers_full_avg(freq_xlating_fir_filter_ccc_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(freq_xlating_fir_filter_ccc_sptr self) -> pmt_vector_float
FIR filter combined with frequency translation with gr_complex input, gr_complex output and float taps.
This class efficiently combines a frequency translation (typically “down conversion”) with a FIR filter (typically low-pass) and decimation. It is ideally suited for a “channel selection filter” and can be efficiently used to select and decimate a narrow band signal out of wide bandwidth input.
Uses a single input array to produce a single output array. Additional inputs and/or outputs are ignored.
Constructor Specific Documentation:
FIR filter with gr_complex input, gr_complex output, and float taps that also frequency translates a signal from .
Construct a FIR filter with the given taps and a composite frequency translation that shifts center_freq down to zero Hz. The frequency translation logically comes before the filtering operation.
| Parameters: |
|
|---|
declare_sample_delay(freq_xlating_fir_filter_ccf_sptr self, unsigned int delay)
pc_input_buffers_full_avg(freq_xlating_fir_filter_ccf_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(freq_xlating_fir_filter_ccf_sptr self) -> pmt_vector_float
FIR filter combined with frequency translation with float input, gr_complex output and gr_complex taps.
This class efficiently combines a frequency translation (typically “down conversion”) with a FIR filter (typically low-pass) and decimation. It is ideally suited for a “channel selection filter” and can be efficiently used to select and decimate a narrow band signal out of wide bandwidth input.
Uses a single input array to produce a single output array. Additional inputs and/or outputs are ignored.
Constructor Specific Documentation:
FIR filter with float input, gr_complex output, and gr_complex taps that also frequency translates a signal from .
Construct a FIR filter with the given taps and a composite frequency translation that shifts center_freq down to zero Hz. The frequency translation logically comes before the filtering operation.
| Parameters: |
|
|---|
declare_sample_delay(freq_xlating_fir_filter_fcc_sptr self, unsigned int delay)
pc_input_buffers_full_avg(freq_xlating_fir_filter_fcc_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(freq_xlating_fir_filter_fcc_sptr self) -> pmt_vector_float
FIR filter combined with frequency translation with float input, gr_complex output and float taps.
This class efficiently combines a frequency translation (typically “down conversion”) with a FIR filter (typically low-pass) and decimation. It is ideally suited for a “channel selection filter” and can be efficiently used to select and decimate a narrow band signal out of wide bandwidth input.
Uses a single input array to produce a single output array. Additional inputs and/or outputs are ignored.
Constructor Specific Documentation:
FIR filter with float input, gr_complex output, and float taps that also frequency translates a signal from .
Construct a FIR filter with the given taps and a composite frequency translation that shifts center_freq down to zero Hz. The frequency translation logically comes before the filtering operation.
| Parameters: |
|
|---|
declare_sample_delay(freq_xlating_fir_filter_fcf_sptr self, unsigned int delay)
pc_input_buffers_full_avg(freq_xlating_fir_filter_fcf_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(freq_xlating_fir_filter_fcf_sptr self) -> pmt_vector_float
FIR filter combined with frequency translation with short input, gr_complex output and gr_complex taps.
This class efficiently combines a frequency translation (typically “down conversion”) with a FIR filter (typically low-pass) and decimation. It is ideally suited for a “channel selection filter” and can be efficiently used to select and decimate a narrow band signal out of wide bandwidth input.
Uses a single input array to produce a single output array. Additional inputs and/or outputs are ignored.
Constructor Specific Documentation:
FIR filter with short input, gr_complex output, and gr_complex taps that also frequency translates a signal from .
Construct a FIR filter with the given taps and a composite frequency translation that shifts center_freq down to zero Hz. The frequency translation logically comes before the filtering operation.
| Parameters: |
|
|---|
declare_sample_delay(freq_xlating_fir_filter_scc_sptr self, unsigned int delay)
pc_input_buffers_full_avg(freq_xlating_fir_filter_scc_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(freq_xlating_fir_filter_scc_sptr self) -> pmt_vector_float
FIR filter combined with frequency translation with short input, gr_complex output and float taps.
This class efficiently combines a frequency translation (typically “down conversion”) with a FIR filter (typically low-pass) and decimation. It is ideally suited for a “channel selection filter” and can be efficiently used to select and decimate a narrow band signal out of wide bandwidth input.
Uses a single input array to produce a single output array. Additional inputs and/or outputs are ignored.
Constructor Specific Documentation:
FIR filter with short input, gr_complex output, and float taps that also frequency translates a signal from .
Construct a FIR filter with the given taps and a composite frequency translation that shifts center_freq down to zero Hz. The frequency translation logically comes before the filtering operation.
| Parameters: |
|
|---|
declare_sample_delay(freq_xlating_fir_filter_scf_sptr self, unsigned int delay)
pc_input_buffers_full_avg(freq_xlating_fir_filter_scf_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(freq_xlating_fir_filter_scf_sptr self) -> pmt_vector_float
Hilbert transformer.
real output is input appropriately delayed. imaginary output is hilbert filtered (90 degree phase shift) version of input.
Constructor Specific Documentation:
Build a Hilbert transformer filter block.
| Parameters: |
|
|---|
declare_sample_delay(hilbert_fc_sptr self, unsigned int delay)
pc_input_buffers_full_avg(hilbert_fc_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(hilbert_fc_sptr self) -> pmt_vector_float
IIR filter with complex input, complex output, and complex taps.
This filter uses the Direct Form I implementation, where contains the feed-forward taps, and the feedback ones.
The old style of the IIR filter uses feedback taps that are negative of what most definitions use (scipy and Matlab among them). This parameter keeps using the old GNU Radio style and is set to TRUE by default. When taps generated from scipy, Matlab, or gr_filter_design, use the new style by setting this to FALSE.
The input and output satisfy a difference equation of the form
y[n] - sum_{k=1}^{M} a_k y[n-k] = sum_{k=0}^{N} b_k x[n-k]
with the corresponding rational system function
H(z) = frac{sum_{k=0}^{M} b_k z^{-k}}{1 - sum_{k=1}^{N} a_k z^{-k}}
Constructor Specific Documentation:
| Parameters: |
|
|---|
declare_sample_delay(iir_filter_ccc_sptr self, unsigned int delay)
pc_input_buffers_full_avg(iir_filter_ccc_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(iir_filter_ccc_sptr self) -> pmt_vector_float
IIR filter with complex input, complex output, and double taps.
This filter uses the Direct Form I implementation, where contains the feed-forward taps, and the feedback ones.
The old style of the IIR filter uses feedback taps that are negative of what most definitions use (scipy and Matlab among them). This parameter keeps using the old GNU Radio style and is set to TRUE by default. When taps generated from scipy, Matlab, or gr_filter_design, use the new style by setting this to FALSE.
The input and output satisfy a difference equation of the form
y[n] - sum_{k=1}^{M} a_k y[n-k] = sum_{k=0}^{N} b_k x[n-k]
with the corresponding rational system function
H(z) = frac{sum_{k=0}^{M} b_k z^{-k}}{1 - sum_{k=1}^{N} a_k z^{-k}}
Constructor Specific Documentation:
| Parameters: |
|
|---|
declare_sample_delay(iir_filter_ccd_sptr self, unsigned int delay)
pc_input_buffers_full_avg(iir_filter_ccd_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(iir_filter_ccd_sptr self) -> pmt_vector_float
IIR filter with complex input, complex output, and float taps.
This filter uses the Direct Form I implementation, where contains the feed-forward taps, and the feedback ones.
The old style of the IIR filter uses feedback taps that are negative of what most definitions use (scipy and Matlab among them). This parameter keeps using the old GNU Radio style and is set to TRUE by default. When taps generated from scipy, Matlab, or gr_filter_design, use the new style by setting this to FALSE.
The input and output satisfy a difference equation of the form
y[n] - sum_{k=1}^{M} a_k y[n-k] = sum_{k=0}^{N} b_k x[n-k]
with the corresponding rational system function
H(z) = frac{sum_{k=0}^{M} b_k z^{-k}}{1 - sum_{k=1}^{N} a_k z^{-k}}
Constructor Specific Documentation:
| Parameters: |
|
|---|
declare_sample_delay(iir_filter_ccf_sptr self, unsigned int delay)
pc_input_buffers_full_avg(iir_filter_ccf_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(iir_filter_ccf_sptr self) -> pmt_vector_float
IIR filter with complex input, complex output, and complex (double) taps.
This filter uses the Direct Form I implementation, where contains the feed-forward taps, and the feedback ones.
The old style of the IIR filter uses feedback taps that are negative of what most definitions use (scipy and Matlab among them). This parameter keeps using the old GNU Radio style and is set to TRUE by default. When taps generated from scipy, Matlab, or gr_filter_design, use the new style by setting this to FALSE.
The input and output satisfy a difference equation of the form
y[n] - sum_{k=1}^{M} a_k y[n-k] = sum_{k=0}^{N} b_k x[n-k]
with the corresponding rational system function
H(z) = frac{sum_{k=0}^{M} b_k z^{-k}}{1 - sum_{k=1}^{N} a_k z^{-k}}
Constructor Specific Documentation:
| Parameters: |
|
|---|
declare_sample_delay(iir_filter_ccz_sptr self, unsigned int delay)
pc_input_buffers_full_avg(iir_filter_ccz_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(iir_filter_ccz_sptr self) -> pmt_vector_float
IIR filter with float input, float output and double taps.
This filter uses the Direct Form I implementation, where contains the feed-forward taps, and the feedback ones.
The old style of the IIR filter uses feedback taps that are negative of what most definitions use (scipy and Matlab among them). This parameter keeps using the old GNU Radio style and is set to TRUE by default. When taps generated from scipy, Matlab, or gr_filter_design, use the new style by setting this to FALSE.
The input and output satisfy a difference equation of the form
y[n] - sum_{k=1}^{M} a_k y[n-k] = sum_{k=0}^{N} b_k x[n-k]
with the corresponding rational system function
H(z) = frac{sum_{k=0}^{M} b_k z^{-k}}{1 - sum_{k=1}^{N} a_k z^{-k}}
Constructor Specific Documentation:
| Parameters: |
|
|---|
declare_sample_delay(iir_filter_ffd_sptr self, unsigned int delay)
pc_input_buffers_full_avg(iir_filter_ffd_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(iir_filter_ffd_sptr self) -> pmt_vector_float
Interpolating FIR filter with gr_complex input, gr_complex output and gr_complex taps.
The fir_filter_XXX blocks create finite impulse response (FIR) filters that perform the convolution in the time domain:
The taps are a C++ vector (or Python list) of values of the type specified by the third letter in the block’s suffix. For this block, the value is of type gr_complex. Taps can be created using the firdes or optfir tools.
These versions of the filter can also act as up-samplers (or interpolators) by specifying an integer value for .
Constructor Specific Documentation:
Interpolating FIR filter with gr_complex input, gr_complex output, and gr_complex taps.
| Parameters: |
|
|---|
declare_sample_delay(interp_fir_filter_ccc_sptr self, unsigned int delay)
pc_input_buffers_full_avg(interp_fir_filter_ccc_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(interp_fir_filter_ccc_sptr self) -> pmt_vector_float
Interpolating FIR filter with gr_complex input, gr_complex output and float taps.
The fir_filter_XXX blocks create finite impulse response (FIR) filters that perform the convolution in the time domain:
The taps are a C++ vector (or Python list) of values of the type specified by the third letter in the block’s suffix. For this block, the value is of type float. Taps can be created using the firdes or optfir tools.
These versions of the filter can also act as up-samplers (or interpolators) by specifying an integer value for .
Constructor Specific Documentation:
Interpolating FIR filter with gr_complex input, gr_complex output, and float taps.
| Parameters: |
|
|---|
declare_sample_delay(interp_fir_filter_ccf_sptr self, unsigned int delay)
pc_input_buffers_full_avg(interp_fir_filter_ccf_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(interp_fir_filter_ccf_sptr self) -> pmt_vector_float
Interpolating FIR filter with float input, gr_complex output and gr_complex taps.
The fir_filter_XXX blocks create finite impulse response (FIR) filters that perform the convolution in the time domain:
The taps are a C++ vector (or Python list) of values of the type specified by the third letter in the block’s suffix. For this block, the value is of type gr_complex. Taps can be created using the firdes or optfir tools.
These versions of the filter can also act as up-samplers (or interpolators) by specifying an integer value for .
Constructor Specific Documentation:
Interpolating FIR filter with float input, gr_complex output, and gr_complex taps.
| Parameters: |
|
|---|
declare_sample_delay(interp_fir_filter_fcc_sptr self, unsigned int delay)
pc_input_buffers_full_avg(interp_fir_filter_fcc_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(interp_fir_filter_fcc_sptr self) -> pmt_vector_float
Interpolating FIR filter with float input, float output and float taps.
The fir_filter_XXX blocks create finite impulse response (FIR) filters that perform the convolution in the time domain:
The taps are a C++ vector (or Python list) of values of the type specified by the third letter in the block’s suffix. For this block, the value is of type float. Taps can be created using the firdes or optfir tools.
These versions of the filter can also act as up-samplers (or interpolators) by specifying an integer value for .
Constructor Specific Documentation:
Interpolating FIR filter with float input, float output, and float taps.
| Parameters: |
|
|---|
declare_sample_delay(interp_fir_filter_fff_sptr self, unsigned int delay)
pc_input_buffers_full_avg(interp_fir_filter_fff_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(interp_fir_filter_fff_sptr self) -> pmt_vector_float
Interpolating FIR filter with float input, short output and float taps.
The fir_filter_XXX blocks create finite impulse response (FIR) filters that perform the convolution in the time domain:
The taps are a C++ vector (or Python list) of values of the type specified by the third letter in the block’s suffix. For this block, the value is of type float. Taps can be created using the firdes or optfir tools.
These versions of the filter can also act as up-samplers (or interpolators) by specifying an integer value for .
Constructor Specific Documentation:
Interpolating FIR filter with float input, short output, and float taps.
| Parameters: |
|
|---|
declare_sample_delay(interp_fir_filter_fsf_sptr self, unsigned int delay)
pc_input_buffers_full_avg(interp_fir_filter_fsf_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(interp_fir_filter_fsf_sptr self) -> pmt_vector_float
Interpolating FIR filter with short input, gr_complex output and gr_complex taps.
The fir_filter_XXX blocks create finite impulse response (FIR) filters that perform the convolution in the time domain:
The taps are a C++ vector (or Python list) of values of the type specified by the third letter in the block’s suffix. For this block, the value is of type gr_complex. Taps can be created using the firdes or optfir tools.
These versions of the filter can also act as up-samplers (or interpolators) by specifying an integer value for .
Constructor Specific Documentation:
Interpolating FIR filter with short input, gr_complex output, and gr_complex taps.
| Parameters: |
|
|---|
declare_sample_delay(interp_fir_filter_scc_sptr self, unsigned int delay)
pc_input_buffers_full_avg(interp_fir_filter_scc_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(interp_fir_filter_scc_sptr self) -> pmt_vector_float
Polyphase filterbank arbitrary resampler with gr_complex input, gr_complex output and gr_complex taps.
This block takes in a signal stream and calls gr::filter::kernel::pfb_arb_resampler_ccc to perform arbitrary resampling on the stream.
Output sampling rate is * input rate.
Constructor Specific Documentation:
Build the polyphase filterbank arbitray resampler.
| Parameters: |
|
|---|
Gets the decimation rate of the filter.
declare_sample_delay(pfb_arb_resampler_ccc_sptr self, unsigned int delay)
Gets the fractional rate of the filter.
Get the group delay of the filter.
Gets the interpolation rate of the filter.
pc_input_buffers_full_avg(pfb_arb_resampler_ccc_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(pfb_arb_resampler_ccc_sptr self) -> pmt_vector_float
Gets the current phase of the resampler in radians (2 to 2pi).
Calculates the phase offset expected by a sine wave of frequency and sampling rate (assuming input sine wave has 0 degree phase).
Print all of the filterbank taps to screen.
Sets the current phase offset in radians (0 to 2pi).
Sets the resampling rate of the block.
Resets the filterbank’s filter taps with the new prototype filter
Return a vector<vector<>> of the filterbank taps
Gets the number of taps per filter.
Polyphase filterbank arbitrary resampler with gr_complex input, gr_complex output and float taps.
This block takes in a signal stream and calls gr::filter::kernel::pfb_arb_resampler_ccf to perform arbitrary resampling on the stream.
Output sampling rate is * input rate.
Constructor Specific Documentation:
Build the polyphase filterbank arbitray resampler.
| Parameters: |
|
|---|
Gets the decimation rate of the filter.
declare_sample_delay(pfb_arb_resampler_ccf_sptr self, unsigned int delay)
Gets the fractional rate of the filter.
Get the group delay of the filter.
Gets the interpolation rate of the filter.
pc_input_buffers_full_avg(pfb_arb_resampler_ccf_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(pfb_arb_resampler_ccf_sptr self) -> pmt_vector_float
Gets the current phase of the resampler in radians (2 to 2pi).
Calculates the phase offset expected by a sine wave of frequency and sampling rate (assuming input sine wave has 0 degree phase).
Print all of the filterbank taps to screen.
Sets the current phase offset in radians (0 to 2pi).
Sets the resampling rate of the block.
Resets the filterbank’s filter taps with the new prototype filter
Return a vector<vector<>> of the filterbank taps
Gets the number of taps per filter.
Polyphase filterbank arbitrary resampler with float input, float output and float taps.
This block takes in a signal stream and performs arbitrary resampling. The resampling rate can be any real number . The resampling is done by constructing filters where is the interpolation rate. We then calculate where .
Using and , we can perform rational resampling where is a rational number close to the input rate where we have filters and we cycle through them as a polyphase filterbank with a stride of so that .
To get the arbitrary rate, we want to interpolate between two points. For each value out, we take an output from the current filter, , and the next filter 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, , used determines the quantization error; the larger , the smaller the noise. You can design for a specified noise floor by setting the filter size (parameters ). 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 , a 3-dB bandwidth of and a transition bandwidth of . We can also specify the out-of-band attenuation to use, , 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 ().
The theory behind this block can be found in Chapter 7.5 of the following book.
Constructor Specific Documentation:
Build the polyphase filterbank arbitray resampler.
| Parameters: |
|
|---|
Gets the decimation rate of the filter.
declare_sample_delay(pfb_arb_resampler_fff_sptr self, unsigned int delay)
Gets the fractional rate of the filter.
Get the group delay of the filter.
Gets the interpolation rate of the filter.
pc_input_buffers_full_avg(pfb_arb_resampler_fff_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(pfb_arb_resampler_fff_sptr self) -> pmt_vector_float
Gets the current phase of the resampler in radians (2 to 2pi).
Calculates the phase offset expected by a sine wave of frequency and sampling rate (assuming input sine wave has 0 degree phase).
Print all of the filterbank taps to screen.
Sets the current phase offset in radians (0 to 2pi).
Sets the resampling rate of the block.
Resets the filterbank’s filter taps with the new prototype filter
Return a vector<vector<>> of the filterbank taps
Gets the number of taps per filter.
Polyphase filterbank channelizer with gr_complex input, gr_complex output and float taps.
This block takes in complex inputs and channelizes it to channels of equal bandwidth. Each of the resulting channels is decimated to the new rate that is the input sampling rate divided by the number of channels, .
The PFB channelizer code takes the taps generated above and builds a set of filters. The set contains number of filters and each filter contains ceil(taps.size()/decim) number of taps. Each tap from the filter prototype is sequentially inserted into the next filter. When all of the input taps are used, the remaining filters in the filterbank are filled out with 0’s to make sure each filter has the same number of taps.
Each filter operates using the gr::blocks::fir_filter_XXX classs of GNU Radio, which takes the input stream at and performs the inner product calculation to where is the number of filter taps. To efficiently handle this in the GNU Radio structure, each filter input must come from its own input stream. So the channelizer must be provided with streams where the input stream has been deinterleaved. This is most easily done using the gr::blocks::stream_to_streams block.
The output is then produced as a vector, where index in the vector is the next sample from the th channel. This is most easily handled by sending the output to a gr::blocks::vector_to_streams block to handle the conversion and passing streams out.
The input and output formatting is done using a hier_block2 called pfb_channelizer_ccf. This can take in a single stream and outputs streams based on the behavior described above.
The filter’s taps should be based on the input sampling rate.
For example, using the GNU Radio’s firdes utility to building filters, we build a low-pass filter with a sampling rate of , a 3-dB bandwidth of and a transition bandwidth of . We can also specify the out-of-band attenuation to use, , 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 unity.
The filter output can also be overs ampled. The over sampling rate is the ratio of the the actual output sampling rate to the normal output sampling rate. It must be rationally related to the number of channels as N/i for i in [1,N], which gives an outputsample rate of [fs/N, fs] where fs is the input sample rate and N is the number of channels.
For example, for 6 channels with fs = 6000 Hz, the normal rate is 6000/6 = 1000 Hz. Allowable oversampling rates are 6/6, 6/5, 6/4, 6/3, 6/2, and 6/1 where the output sample rate of a 6/1 oversample ratio is 6000 Hz, or 6 times the normal 1000 Hz. A rate of 6/5 = 1.2, so the output rate would be 1200 Hz.
The theory behind this block can be found in Chapter 6 of the following book.
When dealing with oversampling, the above book is still a good reference along with this paper:
Constructor Specific Documentation:
Build the polyphase filterbank decimator. For example, for 6 channels with fs = 6000 Hz, the normal rateis 6000/6 = 1000 Hz. Allowable oversampling rates are 6/6, 6/5, 6/4, 6/3, 6/2, and 6/1 where the output sample rate of a 6/1 oversample ratio is 6000 Hz, or 6 times the normal 1000 Hz.
| Parameters: |
|
|---|
Gets the current channel map.
declare_sample_delay(pfb_channelizer_ccf_sptr self, unsigned int delay)
pc_input_buffers_full_avg(pfb_channelizer_ccf_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(pfb_channelizer_ccf_sptr self) -> pmt_vector_float
Print all of the filterbank taps to screen.
Set the channel map. Channels are numbers as:
So output stream 0 comes from channel 0, etc. Setting a new channel map allows the user to specify which channel in frequency he/she wants to got to which output stream.
The map should have the same number of elements as the number of output connections from the block. The minimum value of the map is 0 (for the 0th channel) and the maximum number is N-1 where N is the number of channels.
We specify M as the number of output connections made where M <= N, so only M out of N channels are driven to an output stream. The number of items in the channel map should be at least M long. If there are more channels specified, any value in the map over M-1 will be ignored. If the size of the map is less than M the behavior is unknown (we don’t wish to check every entry into the work function).
This means that if the channelizer is splitting the signal up into N channels but only M channels are specified in the map (where M <= N), then M output streams must be connected and the map and the channel numbers used must be less than N-1. Output channel number can be reused, too. By default, the map is [0...M-1] with M = N.
Resets the filterbank’s filter taps with the new prototype filter
Return a vector<vector<>> of the filterbank taps
Polyphase filterbank bandpass decimator with gr_complex input, gr_complex output and float taps.
This block takes in a signal stream and performs interger down- sampling (decimation) with a polyphase filterbank. The first input is the integer specifying how much to decimate by. The second input is a vector (Python list) of floating-point taps of the prototype filter. The third input specifies the channel to extract. By default, the zeroth channel is used, which is the baseband channel (first Nyquist zone).
The parameter specifies which channel to use since this class is capable of bandpass decimation. Given a complex input stream at a sampling rate of and a decimation rate of , the input frequency domain is split into channels that represent the Nyquist zones. Using the polyphase filterbank, we can select any one of these channels to decimate.
The output signal will be the basebanded and decimated signal from that channel. This concept is very similar to the PFB channelizer (see gr::filter::pfb_channelizer_ccf) where only a single channel is extracted at a time.
The filter’s taps should be based on the sampling rate before decimation.
For example, using the GNU Radio’s firdes utility to building filters, we build a low-pass filter with a sampling rate of , a 3-dB bandwidth of and a transition bandwidth of . We can also specify the out-of-band attenuation to use, , 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 unity.
The PFB decimator code takes the taps generated above and builds a set of filters. The set contains number of filters and each filter contains ceil(taps.size()/decim) number of taps. Each tap from the filter prototype is sequentially inserted into the next filter. When all of the input taps are used, the remaining filters in the filterbank are filled out with 0’s to make sure each filter has the same number of taps.
The theory behind this block can be found in Chapter 6 of the following book.
Constructor Specific Documentation:
Build the polyphase filterbank decimator.
| Parameters: |
|
|---|
declare_sample_delay(pfb_decimator_ccf_sptr self, unsigned int delay)
pc_input_buffers_full_avg(pfb_decimator_ccf_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(pfb_decimator_ccf_sptr self) -> pmt_vector_float
Print all of the filterbank taps to screen.
Resets the filterbank’s filter taps with the new prototype filter
Return a vector<vector<>> of the filterbank taps
Polyphase filterbank interpolator with gr_complex input, gr_complex output and float taps.
This block takes in a signal stream and performs interger up- sampling (interpolation) with a polyphase filterbank. The first input is the integer specifying how much to interpolate by. The second input is a vector (Python list) of floating-point taps of the prototype filter.
The filter’s taps should be based on the interpolation rate specified. That is, the bandwidth specified is relative to the bandwidth after interpolation.
For example, using the GNU Radio’s firdes utility to building filters, we build a low-pass filter with a sampling rate of , a 3-dB bandwidth of and a transition bandwidth of . 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, which is also specified as the interpolation rate so that the output levels are the same as the input (this creates an overall increase in power).
The PFB interpolator code takes the taps generated above and builds a set of filters. The set contains number of filters and each filter contains ceil(taps.size()/interp) number of taps. Each tap from the filter prototype is sequentially inserted into the next filter. When all of the input taps are used, the remaining filters in the filterbank are filled out with 0’s to make sure each filter has the same number of taps.
The theory behind this block can be found in Chapter 7.1 of the following book.
Constructor Specific Documentation:
Build the polyphase filterbank interpolator.
| Parameters: |
|
|---|
declare_sample_delay(pfb_interpolator_ccf_sptr self, unsigned int delay)
pc_input_buffers_full_avg(pfb_interpolator_ccf_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(pfb_interpolator_ccf_sptr self) -> pmt_vector_float
Print all of the filterbank taps to screen.
Resets the filterbank’s filter taps with the new prototype filter
Return a vector<vector<>> of the filterbank taps
Polyphase synthesis filterbank with gr_complex input, gr_complex output and float taps.
The PFB sythesis filterbank combines multiple baseband signals into a single channelized signal. Each input stream is, essentially, modulated onto an output channel according the the channel mapping (see set_channel_map for details).
Setting this filterbank up means selecting the number of output channels, the prototype filter, and whether to handle channels at 2x the sample rate (this is generally used only for reconstruction filtering).
The number of channels sets the maximum number of channels to use, but not all input streams must be connected. For M total channels, we can connect inputs 0 to N where N < M-1. Because of the way GNU Radio handles stream connections, we must connect the channels consecutively, and so we must use the set_channel_map if the desired output channels are not the same as the the default mapping. This features gives us the flexibility to output to any given channel. Generally, we try to not use the channels at the edge of the spectrum to avoid issues with filtering and roll-off of the transmitter or receiver.
When using the 2x sample rate mode, we specify the number of channels that will be used. However, the actual output signal will be twice this number of channels. This is mainly important to know when setting the channel map. For M channels, the channel mapping can specy from 0 to 2M-1 channels to output onto.
For more details about this and the concepts of reconstruction filtering, see:
Constructor Specific Documentation:
Build the polyphase synthesis filterbank.
| Parameters: |
|
|---|
Gets the current channel map.
declare_sample_delay(pfb_synthesizer_ccf_sptr self, unsigned int delay)
pc_input_buffers_full_avg(pfb_synthesizer_ccf_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(pfb_synthesizer_ccf_sptr self) -> pmt_vector_float
Print all of the filterbank taps to screen.
Set the channel map. Channels are numbers as:
So input stream 0 goes to channel 0, etc. Setting a new channel map allows the user to specify where in frequency he/she wants the input stream to go. This is especially useful to avoid putting signals into the channels on the edge of the spectrum which can either wrap around (in the case of odd number of channels) and be affected by filter rolloff in the transmitter.
The map must be at least the number of streams being sent to the block. Less and the algorithm will not have enough data to properly setup the buffers. Any more channels specified will be ignored.
Resets the filterbank’s filter taps with the new prototype filter
Return a vector<vector<>> of the filterbank taps
Rational Resampling Polyphase FIR filter with gr_complex input, gr_complex output and gr_complex taps.
Make a rational resampling FIR filter. If the input signal is at rate fs, then the output signal will be at a rate of * fs / .
The interpolation and decimation rates should be kept as small as possible, and generally should be relatively prime to help reduce complexity in memory and computation.
The set of supplied to this filterbank should be designed around the resampling amount and must avoid aliasing (when interpolation/decimation < 1) and images (when interpolation/decimation > 1).
As with any filter, the behavior of the filter taps (or coefficients) is determined by the highest sampling rate that the filter will ever see. In the case of a resampler that increases the sampling rate, the highest sampling rate observed is since in the filterbank, the number of filter arms is equal to . When the resampler decreases the sampling rate (decimation > interpolation), then the highest rate is the input sample rate of the original signal. We must create a filter based around this value to reduce any aliasing that may occur from out-of-band signals.
Another way to think about how to create the filter taps is that the filter is effectively applied after interpolation and before decimation. And yet another way to think of it is that the taps should be a LPF that is at least as narrow as the narrower of the required anti-image postfilter or anti-alias prefilter.
Constructor Specific Documentation:
Make a rational resampling FIR filter.
| Parameters: |
|
|---|
declare_sample_delay(rational_resampler_base_ccc_sptr self, unsigned int delay)
pc_input_buffers_full_avg(rational_resampler_base_ccc_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(rational_resampler_base_ccc_sptr self) -> pmt_vector_float
Rational Resampling Polyphase FIR filter with gr_complex input, gr_complex output and float taps.
Make a rational resampling FIR filter. If the input signal is at rate fs, then the output signal will be at a rate of * fs / .
The interpolation and decimation rates should be kept as small as possible, and generally should be relatively prime to help reduce complexity in memory and computation.
The set of supplied to this filterbank should be designed around the resampling amount and must avoid aliasing (when interpolation/decimation < 1) and images (when interpolation/decimation > 1).
As with any filter, the behavior of the filter taps (or coefficients) is determined by the highest sampling rate that the filter will ever see. In the case of a resampler that increases the sampling rate, the highest sampling rate observed is since in the filterbank, the number of filter arms is equal to . When the resampler decreases the sampling rate (decimation > interpolation), then the highest rate is the input sample rate of the original signal. We must create a filter based around this value to reduce any aliasing that may occur from out-of-band signals.
Another way to think about how to create the filter taps is that the filter is effectively applied after interpolation and before decimation. And yet another way to think of it is that the taps should be a LPF that is at least as narrow as the narrower of the required anti-image postfilter or anti-alias prefilter.
Constructor Specific Documentation:
Make a rational resampling FIR filter.
| Parameters: |
|
|---|
declare_sample_delay(rational_resampler_base_ccf_sptr self, unsigned int delay)
pc_input_buffers_full_avg(rational_resampler_base_ccf_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(rational_resampler_base_ccf_sptr self) -> pmt_vector_float
Rational Resampling Polyphase FIR filter with float input, gr_complex output and gr_complex taps.
Make a rational resampling FIR filter. If the input signal is at rate fs, then the output signal will be at a rate of * fs / .
The interpolation and decimation rates should be kept as small as possible, and generally should be relatively prime to help reduce complexity in memory and computation.
The set of supplied to this filterbank should be designed around the resampling amount and must avoid aliasing (when interpolation/decimation < 1) and images (when interpolation/decimation > 1).
As with any filter, the behavior of the filter taps (or coefficients) is determined by the highest sampling rate that the filter will ever see. In the case of a resampler that increases the sampling rate, the highest sampling rate observed is since in the filterbank, the number of filter arms is equal to . When the resampler decreases the sampling rate (decimation > interpolation), then the highest rate is the input sample rate of the original signal. We must create a filter based around this value to reduce any aliasing that may occur from out-of-band signals.
Another way to think about how to create the filter taps is that the filter is effectively applied after interpolation and before decimation. And yet another way to think of it is that the taps should be a LPF that is at least as narrow as the narrower of the required anti-image postfilter or anti-alias prefilter.
Constructor Specific Documentation:
Make a rational resampling FIR filter.
| Parameters: |
|
|---|
declare_sample_delay(rational_resampler_base_fcc_sptr self, unsigned int delay)
pc_input_buffers_full_avg(rational_resampler_base_fcc_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(rational_resampler_base_fcc_sptr self) -> pmt_vector_float
Rational Resampling Polyphase FIR filter with float input, float output and float taps.
Make a rational resampling FIR filter. If the input signal is at rate fs, then the output signal will be at a rate of * fs / .
The interpolation and decimation rates should be kept as small as possible, and generally should be relatively prime to help reduce complexity in memory and computation.
The set of supplied to this filterbank should be designed around the resampling amount and must avoid aliasing (when interpolation/decimation < 1) and images (when interpolation/decimation > 1).
As with any filter, the behavior of the filter taps (or coefficients) is determined by the highest sampling rate that the filter will ever see. In the case of a resampler that increases the sampling rate, the highest sampling rate observed is since in the filterbank, the number of filter arms is equal to . When the resampler decreases the sampling rate (decimation > interpolation), then the highest rate is the input sample rate of the original signal. We must create a filter based around this value to reduce any aliasing that may occur from out-of-band signals.
Another way to think about how to create the filter taps is that the filter is effectively applied after interpolation and before decimation. And yet another way to think of it is that the taps should be a LPF that is at least as narrow as the narrower of the required anti-image postfilter or anti-alias prefilter.
Constructor Specific Documentation:
Make a rational resampling FIR filter.
| Parameters: |
|
|---|
declare_sample_delay(rational_resampler_base_fff_sptr self, unsigned int delay)
pc_input_buffers_full_avg(rational_resampler_base_fff_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(rational_resampler_base_fff_sptr self) -> pmt_vector_float
Rational Resampling Polyphase FIR filter with float input, short output and float taps.
Make a rational resampling FIR filter. If the input signal is at rate fs, then the output signal will be at a rate of * fs / .
The interpolation and decimation rates should be kept as small as possible, and generally should be relatively prime to help reduce complexity in memory and computation.
The set of supplied to this filterbank should be designed around the resampling amount and must avoid aliasing (when interpolation/decimation < 1) and images (when interpolation/decimation > 1).
As with any filter, the behavior of the filter taps (or coefficients) is determined by the highest sampling rate that the filter will ever see. In the case of a resampler that increases the sampling rate, the highest sampling rate observed is since in the filterbank, the number of filter arms is equal to . When the resampler decreases the sampling rate (decimation > interpolation), then the highest rate is the input sample rate of the original signal. We must create a filter based around this value to reduce any aliasing that may occur from out-of-band signals.
Another way to think about how to create the filter taps is that the filter is effectively applied after interpolation and before decimation. And yet another way to think of it is that the taps should be a LPF that is at least as narrow as the narrower of the required anti-image postfilter or anti-alias prefilter.
Constructor Specific Documentation:
Make a rational resampling FIR filter.
| Parameters: |
|
|---|
declare_sample_delay(rational_resampler_base_fsf_sptr self, unsigned int delay)
pc_input_buffers_full_avg(rational_resampler_base_fsf_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(rational_resampler_base_fsf_sptr self) -> pmt_vector_float
Rational Resampling Polyphase FIR filter with short input, gr_complex output and gr_complex taps.
Make a rational resampling FIR filter. If the input signal is at rate fs, then the output signal will be at a rate of * fs / .
The interpolation and decimation rates should be kept as small as possible, and generally should be relatively prime to help reduce complexity in memory and computation.
The set of supplied to this filterbank should be designed around the resampling amount and must avoid aliasing (when interpolation/decimation < 1) and images (when interpolation/decimation > 1).
As with any filter, the behavior of the filter taps (or coefficients) is determined by the highest sampling rate that the filter will ever see. In the case of a resampler that increases the sampling rate, the highest sampling rate observed is since in the filterbank, the number of filter arms is equal to . When the resampler decreases the sampling rate (decimation > interpolation), then the highest rate is the input sample rate of the original signal. We must create a filter based around this value to reduce any aliasing that may occur from out-of-band signals.
Another way to think about how to create the filter taps is that the filter is effectively applied after interpolation and before decimation. And yet another way to think of it is that the taps should be a LPF that is at least as narrow as the narrower of the required anti-image postfilter or anti-alias prefilter.
Constructor Specific Documentation:
Make a rational resampling FIR filter.
| Parameters: |
|
|---|
declare_sample_delay(rational_resampler_base_scc_sptr self, unsigned int delay)
pc_input_buffers_full_avg(rational_resampler_base_scc_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(rational_resampler_base_scc_sptr self) -> pmt_vector_float
single pole IIR filter with complex input, complex output
The input and output satisfy a difference equation of the form
y[n] - (1-alpha) y[n-1] = alpha x[n]
with the corresponding rational system function
H(z) = frac{alpha}{1 - (1-alpha) z^{-1}}
Note that some texts define the system function with a + in the denominator. If you’re using that convention, you’ll need to negate the feedback tap.
Constructor Specific Documentation:
| Parameters: |
|
|---|
declare_sample_delay(single_pole_iir_filter_cc_sptr self, unsigned int delay)
pc_input_buffers_full_avg(single_pole_iir_filter_cc_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(single_pole_iir_filter_cc_sptr self) -> pmt_vector_float
single pole IIR filter with float input, float output
The input and output satisfy a difference equation of the form
y[n] - (1-alpha) y[n-1] = alpha x[n]
with the corresponding rational system function
H(z) = frac{alpha}{1 - (1-alpha) z^{-1}}
Note that some texts define the system function with a + in the denominator. If you’re using that convention, you’ll need to negate the feedback tap.
Constructor Specific Documentation:
| Parameters: |
|
|---|
declare_sample_delay(single_pole_iir_filter_ff_sptr self, unsigned int delay)
pc_input_buffers_full_avg(single_pole_iir_filter_ff_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(single_pole_iir_filter_ff_sptr self) -> pmt_vector_float