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 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
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
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
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 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
Uniformly modulated polyphase DFT filter bank: analysis
Uniformly modulated polyphase DFT filter bank: synthesis
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