GNU Radio C++ API Reference: firdes.h Source File

| GNU Radio C++ API Reference 3.10.12.0 The Free & Open Software Radio Ecosystem |

Loading...
Searching...
No Matches
firdes.h
Go to the documentation of this file.
1/* -*- c++ -*- */
2/*
3 * Copyright 2002,2008,2012 Free Software Foundation, Inc.
4 *
5 * This file is part of GNU Radio
6 *
7 * SPDX-License-Identifier: GPL-3.0-or-later
8 *
9 */
10
11#ifndef _FILTER_FIRDES_H_
12#define _FILTER_FIRDES_H_
13
14#include <gnuradio/fft/window.h>
15#include <gnuradio/filter/api.h>
16#include <gnuradio/gr_complex.h>
17#include <cmath>
18#include <vector>
19
20namespace gr {
21namespace filter {
22
23/*!
24 * \brief Finite Impulse Response (FIR) filter design functions.
25 * \ingroup filter_design
26 */
27
28 class FILTER_API firdes
29{
30public:
31 static std::vector<float> window(fft::window::win_type type, int ntaps, double param);
32
33 // ... class methods ...
34
35 /*!
36 * \brief Use "window method" to design a low-pass FIR filter. The
37 * normalized width of the transition band is what sets the number of
38 * taps required. Narrow --> more taps. Window type determines maximum
39 * attenuation and passband ripple.
40 *
41 * \param gain overall gain of filter (typically 1.0)
42 * \param sampling_freq sampling freq (Hz)
43 * \param cutoff_freq center of transition band (Hz)
44 * \param transition_width width of transition band (Hz)
45 * \param window one of fft::window::win_type
46 * \param param parameter for Kaiser, Exp., Gaussian, Tukey windows
47 */
48 static std::vector<float>
49 low_pass(double gain,
50 double sampling_freq,
51 double cutoff_freq, // Hz center of transition band
52 double transition_width, // Hz width of transition band
53 fft::window::win_type window = fft::window::win_type::WIN_HAMMING,
54 double param = 6.76); // used for Kaiser, Exp., Gaussian, Tukey windows
55
56 /*!
57 * \brief Use "window method" to design a low-pass FIR filter. The
58 * normalized width of the transition band and the required stop band
59 * attenuation is what sets the number of taps required. Narrow --> more
60 * taps More attenuation --> more taps. The window type determines
61 * maximum attenuation and passband ripple.
62 *
63 * \param gain overall gain of filter (typically 1.0)
64 * \param sampling_freq sampling freq (Hz)
65 * \param cutoff_freq beginning of transition band (Hz)
66 * \param transition_width width of transition band (Hz)
67 * \param attenuation_dB required stopband attenuation
68 * \param window one of fft::window::win_type
69 * \param param parameter for Kaiser, Exp., Gaussian, Tukey windows
70 */
71 static std::vector<float>
72 low_pass_2(double gain,
73 double sampling_freq,
74 double cutoff_freq, // Hz beginning transition band
75 double transition_width, // Hz width of transition band
76 double attenuation_dB, // out of band attenuation dB
77 fft::window::win_type window = fft::window::win_type::WIN_HAMMING,
78 double param = 6.76); // used for Kaiser, Exp., Gaussian, Tukey windows
79
80 /*!
81 * \brief Use "window method" to design a high-pass FIR filter. The
82 * normalized width of the transition band is what sets the number of
83 * taps required. Narrow --> more taps. The window determines maximum
84 * attenuation and passband ripple.
85 *
86 * \param gain overall gain of filter (typically 1.0)
87 * \param sampling_freq sampling freq (Hz)
88 * \param cutoff_freq center of transition band (Hz)
89 * \param transition_width width of transition band (Hz)
90 * \param window one of fft::window::win_type
91 * \param param parameter for Kaiser, Exp., Gaussian, Tukey windows
92 */
93 static std::vector<float>
94 high_pass(double gain,
95 double sampling_freq,
96 double cutoff_freq, // Hz center of transition band
97 double transition_width, // Hz width of transition band
98 fft::window::win_type window = fft::window::win_type::WIN_HAMMING,
99 double param = 6.76); // used for Kaiser, Exp., Gaussian, Tukey windows
100
101 /*!
102 * \brief Use "window method" to design a high-pass FIR filter. The
103 * normalized width of the transition band and the required stop band
104 * attenuation is what sets the number of taps required. Narrow --> more
105 * taps More attenuation --> more taps. The window determines maximum
106 * attenuation and passband ripple.
107 *
108 * \param gain overall gain of filter (typically 1.0)
109 * \param sampling_freq sampling freq (Hz)
110 * \param cutoff_freq center of transition band (Hz)
111 * \param transition_width width of transition band (Hz).
112 * \param attenuation_dB out of band attenuation
113 * \param window one of fft::window::win_type
114 * \param param parameter for Kaiser, Exp., Gaussian, Tukey windows
115 */
116 static std::vector<float>
117 high_pass_2(double gain,
118 double sampling_freq,
119 double cutoff_freq, // Hz center of transition band
120 double transition_width, // Hz width of transition band
121 double attenuation_dB, // out of band attenuation dB
122 fft::window::win_type window = fft::window::win_type::WIN_HAMMING,
123 double param = 6.76); // used for Kaiser, Exp., Gaussian, Tukey windows
124
125 /*!
126 * \brief Use "window method" to design a band-pass FIR filter. The
127 * normalized width of the transition band is what sets the number of
128 * taps required. Narrow --> more taps. The window determines maximum
129 * attenuation and passband ripple.
130 *
131 * \param gain overall gain of filter (typically 1.0)
132 * \param sampling_freq sampling freq (Hz)
133 * \param low_cutoff_freq center of transition band (Hz)
134 * \param high_cutoff_freq center of transition band (Hz)
135 * \param transition_width width of transition band (Hz).
136 * \param window one of fft::window::win_type
137 * \param param parameter for Kaiser, Exp., Gaussian, Tukey windows
138 */
139 static std::vector<float>
140 band_pass(double gain,
141 double sampling_freq,
142 double low_cutoff_freq, // Hz center of transition band
143 double high_cutoff_freq, // Hz center of transition band
144 double transition_width, // Hz width of transition band
145 fft::window::win_type window = fft::window::win_type::WIN_HAMMING,
146 double param = 6.76); // used for Kaiser, Exp., Gaussian, Tukey windows
147
148 /*!
149 * \brief Use "window method" to design a band-pass FIR filter. The
150 * normalized width of the transition band and the required stop band
151 * attenuation is what sets the number of taps required. Narrow --> more
152 * taps. More attenuation --> more taps. Window type determines maximum
153 * attenuation and passband ripple.
154 *
155 * \param gain overall gain of filter (typically 1.0)
156 * \param sampling_freq sampling freq (Hz)
157 * \param low_cutoff_freq center of transition band (Hz)
158 * \param high_cutoff_freq center of transition band (Hz)
159 * \param transition_width width of transition band (Hz).
160 * \param attenuation_dB out of band attenuation
161 * \param window one of fft::window::win_type
162 * \param param parameter for Kaiser, Exp., Gaussian, Tukey windows
163 */
164 static std::vector<float>
165 band_pass_2(double gain,
166 double sampling_freq,
167 double low_cutoff_freq, // Hz beginning transition band
168 double high_cutoff_freq, // Hz beginning transition band
169 double transition_width, // Hz width of transition band
170 double attenuation_dB, // out of band attenuation dB
171 fft::window::win_type window = fft::window::win_type::WIN_HAMMING,
172 double param = 6.76); // used for Kaiser, Exp., Gaussian, Tukey windows
173 /*!
174 * \brief Use the "window method" to design a complex band-reject FIR
175 * filter. The normalized width of the transition band is what sets the
176 * number of taps required. Narrow --> more taps. The window type
177 * determines maximum attenuation and passband ripple.
178 *
179 * \param gain overall gain of filter (typically 1.0)
180 * \param sampling_freq sampling freq (Hz)
181 * \param low_cutoff_freq center of transition band (Hz)
182 * \param high_cutoff_freq center of transition band (Hz)
183 * \param transition_width width of transition band (Hz)
184 * \param window one of fft::window::win_type
185 * \param param parameter for Kaiser, Exp., Gaussian, Tukey windows
186 */
187 static std::vector<gr_complex> complex_band_reject(
188 double gain,
189 double sampling_freq,
190 double low_cutoff_freq,
191 double high_cutoff_freq,
192 double transition_width, // Hz width of transition band
193 fft::window::win_type window = fft::window::win_type::WIN_HAMMING,
194 double param = 6.76); // used for Kaiser, Exp., Gaussian, Tukey windows
195
196 /*!
197 * \brief Use "window method" to design a complex band-reject FIR filter.
198 * The normalized width of the transition band and the required stop band
199 * attenuation is what sets the number of taps required. Narrow --> more
200 * taps More attenuation --> more taps. Window type determines maximum
201 * attenuation and passband ripple.
202 *
203 * \param gain overall gain of filter (typically 1.0)
204 * \param sampling_freq sampling freq (Hz)
205 * \param low_cutoff_freq center of transition band (Hz)
206 * \param high_cutoff_freq center of transition band (Hz)
207 * \param transition_width width of transition band (Hz)
208 * \param attenuation_dB out of band attenuation
209 * \param window one of fft::window::win_type
210 * \param param parameter for Kaiser, Exp., Gaussian, Tukey windows
211 */
212 static std::vector<gr_complex> complex_band_reject_2(
213 double gain,
214 double sampling_freq,
215 double low_cutoff_freq, // Hz beginning transition band
216 double high_cutoff_freq, // Hz beginning transition band
217 double transition_width, // Hz width of transition band
218 double attenuation_dB, // out of band attenuation dB
219 fft::window::win_type window = fft::window::win_type::WIN_HAMMING,
220 double param = 6.76); // used for Kaiser, Exp., Gaussian, Tukey windows
221
222 /*!
223 * \brief Use the "window method" to design a complex band-pass FIR
224 * filter. The normalized width of the transition band is what sets the
225 * number of taps required. Narrow --> more taps. The window type
226 * determines maximum attenuation and passband ripple.
227 *
228 * \param gain overall gain of filter (typically 1.0)
229 * \param sampling_freq sampling freq (Hz)
230 * \param low_cutoff_freq center of transition band (Hz)
231 * \param high_cutoff_freq center of transition band (Hz)
232 * \param transition_width width of transition band (Hz)
233 * \param window one of fft::window::win_type
234 * \param param parameter for Kaiser, Exp., Gaussian, Tukey windows
235 */
236 static std::vector<gr_complex> complex_band_pass(
237 double gain,
238 double sampling_freq,
239 double low_cutoff_freq, // Hz center of transition band
240 double high_cutoff_freq, // Hz center of transition band
241 double transition_width, // Hz width of transition band
242 fft::window::win_type window = fft::window::win_type::WIN_HAMMING,
243 double param = 6.76); // used for Kaiser, Exp., Gaussian, Tukey windows
244
245 /*!
246 * \brief Use "window method" to design a complex band-pass FIR filter.
247 * The normalized width of the transition band and the required stop band
248 * attenuation is what sets the number of taps required. Narrow --> more
249 * taps More attenuation --> more taps. Window type determines maximum
250 * attenuation and passband ripple.
251 *
252 * \param gain overall gain of filter (typically 1.0)
253 * \param sampling_freq sampling freq (Hz)
254 * \param low_cutoff_freq center of transition band (Hz)
255 * \param high_cutoff_freq center of transition band (Hz)
256 * \param transition_width width of transition band (Hz)
257 * \param attenuation_dB out of band attenuation
258 * \param window one of fft::window::win_type
259 * \param param parameter for Kaiser, Exp., Gaussian, Tukey windows
260 */
261 static std::vector<gr_complex> complex_band_pass_2(
262 double gain,
263 double sampling_freq,
264 double low_cutoff_freq, // Hz beginning transition band
265 double high_cutoff_freq, // Hz beginning transition band
266 double transition_width, // Hz width of transition band
267 double attenuation_dB, // out of band attenuation dB
268 fft::window::win_type window = fft::window::win_type::WIN_HAMMING,
269 double param = 6.76); // used for Kaiser, Exp., Gaussian, Tukey windows
270
271 /*!
272 * \brief Use "window method" to design a band-reject FIR filter. The
273 * normalized width of the transition band is what sets the number of
274 * taps required. Narrow --> more taps. Window type determines maximum
275 * attenuation and passband ripple.
276 *
277 * \param gain overall gain of filter (typically 1.0)
278 * \param sampling_freq sampling freq (Hz)
279 * \param low_cutoff_freq center of transition band (Hz)
280 * \param high_cutoff_freq center of transition band (Hz)
281 * \param transition_width width of transition band (Hz)
282 * \param window one of fft::window::win_type
283 * \param param parameter for Kaiser, Exp., Gaussian, Tukey windows
284 */
285 static std::vector<float>
286 band_reject(double gain,
287 double sampling_freq,
288 double low_cutoff_freq, // Hz center of transition band
289 double high_cutoff_freq, // Hz center of transition band
290 double transition_width, // Hz width of transition band
291 fft::window::win_type window = fft::window::win_type::WIN_HAMMING,
292 double param = 6.76); // used for Kaiser, Exp., Gaussian, Tukey windows
293
294 /*!
295 * \brief Use "window method" to design a band-reject FIR filter. The
296 * normalized width of the transition band and the required stop band
297 * attenuation is what sets the number of taps required. Narrow --> more
298 * taps More attenuation --> more taps. Window type determines maximum
299 * attenuation and passband ripple.
300 *
301 * \param gain overall gain of filter (typically 1.0)
302 * \param sampling_freq sampling freq (Hz)
303 * \param low_cutoff_freq center of transition band (Hz)
304 * \param high_cutoff_freq center of transition band (Hz)
305 * \param transition_width width of transition band (Hz).
306 * \param attenuation_dB out of band attenuation
307 * \param window one of fft::window::win_type
308 * \param param parameter for Kaiser, Exp., Gaussian, Tukey windows
309 */
310 static std::vector<float>
311 band_reject_2(double gain,
312 double sampling_freq,
313 double low_cutoff_freq, // Hz beginning transition band
314 double high_cutoff_freq, // Hz beginning transition band
315 double transition_width, // Hz width of transition band
316 double attenuation_dB, // out of band attenuation dB
317 fft::window::win_type window = fft::window::win_type::WIN_HAMMING,
318 double param = 6.76); // used for Kaiser, Exp., Gaussian, Tukey windows
319
320 /*!\brief design a Hilbert Transform Filter
321 *
322 * \param ntaps number of taps, must be odd
323 * \param windowtype one kind of fft::window::win_type
324 * \param param parameter for Kaiser, Exp., Gaussian, Tukey windows
325 */
326 static std::vector<float>
327 hilbert(unsigned int ntaps = 19,
328 fft::window::win_type windowtype = fft::window::win_type::WIN_RECTANGULAR,
329 double param = 6.76);
330
331 /*!
332 * \brief design a Root Cosine FIR Filter (do we need a window?)
333 *
334 * \param gain overall gain of filter (typically 1.0)
335 * \param sampling_freq sampling freq (Hz)
336 * \param symbol_rate symbol rate, must be a factor of sample rate
337 * \param alpha excess bandwidth factor
338 * \param ntaps number of taps
339 */
340 static std::vector<float>
341 root_raised_cosine(double gain,
342 double sampling_freq,
343 double symbol_rate, // Symbol rate, NOT bitrate (unless BPSK)
344 double alpha, // Excess Bandwidth Factor
345 int ntaps);
346
347 /*!
348 * \brief design a Gaussian filter
349 *
350 * \param gain overall gain of filter (typically 1.0)
351 * \param spb symbol rate, must be a factor of sample rate
352 * \param bt bandwidth to bitrate ratio
353 * \param ntaps number of taps
354 */
355 static std::vector<float> gaussian(double gain,
356 double spb,
357 double bt, // Bandwidth to bitrate ratio
358 int ntaps);
359
360private:
361 static double bessi0(double x);
362 static void sanity_check_1f(double sampling_freq, double f1, double transition_width);
363 static void
364 sanity_check_2f(double sampling_freq, double f1, double f2, double transition_width);
365 static void sanity_check_2f_c(double sampling_freq,
366 double f1,
367 double f2,
368 double transition_width);
369
370 static int compute_ntaps(double sampling_freq,
371 double transition_width,
372 fft::window::win_type window_type,
373 double param);
374
375 static int compute_ntaps_windes(double sampling_freq,
376 double transition_width,
377 double attenuation_dB);
378};
379
380} /* namespace filter */
381} /* namespace gr */
382
383#endif /* _FILTER_FIRDES_H_ */
gr::fft::window::win_type
win_type
Definition window.h:28
gr::fft::window::WIN_RECTANGULAR
@ WIN_RECTANGULAR
Basic rectangular window; max attenuation 21 dB.
Definition window.h:34
gr::fft::window::WIN_HAMMING
@ WIN_HAMMING
Hamming window; max attenuation 53 dB.
Definition window.h:30
gr::filter::firdes
Finite Impulse Response (FIR) filter design functions.
Definition firdes.h:29
gr::filter::firdes::hilbert
static std::vector< float > hilbert(unsigned int ntaps=19, fft::window::win_type windowtype=fft::window::win_type::WIN_RECTANGULAR, double param=6.76)
design a Hilbert Transform Filter
gr::filter::firdes::gaussian
static std::vector< float > gaussian(double gain, double spb, double bt, int ntaps)
design a Gaussian filter
gr::filter::firdes::window
static std::vector< float > window(fft::window::win_type type, int ntaps, double param)
gr::filter::firdes::band_pass
static std::vector< float > band_pass(double gain, double sampling_freq, double low_cutoff_freq, double high_cutoff_freq, double transition_width, fft::window::win_type window=fft::window::win_type::WIN_HAMMING, double param=6.76)
Use "window method" to design a band-pass FIR filter. The normalized width of the transition band is ...
gr::filter::firdes::band_reject
static std::vector< float > band_reject(double gain, double sampling_freq, double low_cutoff_freq, double high_cutoff_freq, double transition_width, fft::window::win_type window=fft::window::win_type::WIN_HAMMING, double param=6.76)
Use "window method" to design a band-reject FIR filter. The normalized width of the transition band i...
gr::filter::firdes::high_pass
static std::vector< float > high_pass(double gain, double sampling_freq, double cutoff_freq, double transition_width, fft::window::win_type window=fft::window::win_type::WIN_HAMMING, double param=6.76)
Use "window method" to design a high-pass FIR filter. The normalized width of the transition band is ...
gr::filter::firdes::complex_band_reject
static std::vector< gr_complex > complex_band_reject(double gain, double sampling_freq, double low_cutoff_freq, double high_cutoff_freq, double transition_width, fft::window::win_type window=fft::window::win_type::WIN_HAMMING, double param=6.76)
Use the "window method" to design a complex band-reject FIR filter. The normalized width of the trans...
gr::filter::firdes::complex_band_pass
static std::vector< gr_complex > complex_band_pass(double gain, double sampling_freq, double low_cutoff_freq, double high_cutoff_freq, double transition_width, fft::window::win_type window=fft::window::win_type::WIN_HAMMING, double param=6.76)
Use the "window method" to design a complex band-pass FIR filter. The normalized width of the transit...
gr::filter::firdes::band_pass_2
static std::vector< float > band_pass_2(double gain, double sampling_freq, double low_cutoff_freq, double high_cutoff_freq, double transition_width, double attenuation_dB, fft::window::win_type window=fft::window::win_type::WIN_HAMMING, double param=6.76)
Use "window method" to design a band-pass FIR filter. The normalized width of the transition band and...
gr::filter::firdes::complex_band_pass_2
static std::vector< gr_complex > complex_band_pass_2(double gain, double sampling_freq, double low_cutoff_freq, double high_cutoff_freq, double transition_width, double attenuation_dB, fft::window::win_type window=fft::window::win_type::WIN_HAMMING, double param=6.76)
Use "window method" to design a complex band-pass FIR filter. The normalized width of the transition ...
gr::filter::firdes::root_raised_cosine
static std::vector< float > root_raised_cosine(double gain, double sampling_freq, double symbol_rate, double alpha, int ntaps)
design a Root Cosine FIR Filter (do we need a window?)
gr::filter::firdes::complex_band_reject_2
static std::vector< gr_complex > complex_band_reject_2(double gain, double sampling_freq, double low_cutoff_freq, double high_cutoff_freq, double transition_width, double attenuation_dB, fft::window::win_type window=fft::window::win_type::WIN_HAMMING, double param=6.76)
Use "window method" to design a complex band-reject FIR filter. The normalized width of the transitio...
gr::filter::firdes::low_pass_2
static std::vector< float > low_pass_2(double gain, double sampling_freq, double cutoff_freq, double transition_width, double attenuation_dB, fft::window::win_type window=fft::window::win_type::WIN_HAMMING, double param=6.76)
Use "window method" to design a low-pass FIR filter. The normalized width of the transition band and ...
gr::filter::firdes::low_pass
static std::vector< float > low_pass(double gain, double sampling_freq, double cutoff_freq, double transition_width, fft::window::win_type window=fft::window::win_type::WIN_HAMMING, double param=6.76)
Use "window method" to design a low-pass FIR filter. The normalized width of the transition band is w...
gr::filter::firdes::high_pass_2
static std::vector< float > high_pass_2(double gain, double sampling_freq, double cutoff_freq, double transition_width, double attenuation_dB, fft::window::win_type window=fft::window::win_type::WIN_HAMMING, double param=6.76)
Use "window method" to design a high-pass FIR filter. The normalized width of the transition band and...
gr::filter::firdes::band_reject_2
static std::vector< float > band_reject_2(double gain, double sampling_freq, double low_cutoff_freq, double high_cutoff_freq, double transition_width, double attenuation_dB, fft::window::win_type window=fft::window::win_type::WIN_HAMMING, double param=6.76)
Use "window method" to design a band-reject FIR filter. The normalized width of the transition band a...
api.h
FILTER_API
#define FILTER_API
Definition gr-filter/include/gnuradio/filter/api.h:18
gr_complex.h
gr::filter
Definition dc_blocker_cc.h:18
gr
GNU Radio logging wrapper.
Definition basic_block.h:29
window.h