Input Filter
The Input Filter is the second processing block inside a Signal Conditioner when the later is using a Signal_Conditioner
implementation.
The role on an Input Filter block is to filter noise and possible interferences from the incoming signal.
There are three kinds of filter implementations available:
 Finite Impulse Response (FIR) filters, implementing a fixed frequency mask for outofband noise or frequency alias suppression.
Fir_Filter
for baseband signals.Freq_Xlating_Fir_Filter
for signals modulated at a given intermediate frequency.
 Adaptive filters for interference mitigation.
Pulse_Blanking_Filter
for pulsed interferences.Notch_Filter
,Notch_Filter_Lite
for narrowband interferences.
 Short circuit.
Pass_Through
copy the input samples to the output buffer.
In the presence of noise and interferences, the signal y(t) received at the antenna of a GNSS receiver can be modeled as^{1}
where:
 is the useful signal containing the different GNSS components which will be used for receiver operations,
 is the interference signal, and
 is a noise term usually modeled as a complex circularly symmetric Gaussian random process. The samples are assumed independent and identically distributed.
The sequence is obtained by amplifying, downconverting and digitizing the analog signal with a sampling frequency .
Interference Cancellation consists of removing from by means of a signal processing algorithm. The underlying idea seems straightforward, but in practice Interference Cancellation becomes a complicated matter due to the huge variety of interference sources that may coexist within the GNSS signal band. For instance, the interference may be pulsed or continuous. In the first case, the period between pulses, time duration, intensity and bandwidth of the pulses can be constant or vary along time. In the second case, the intensity, instantaneous frequency and frequency rate of the interference may also behave randomly. For this reason, there is no a “onefitsall” algorithm for interference mitigation. Furthermore, during last years research literature has been populated with new signal processing techniques that perform many kinds of Interference Cancellation^{2}.
Finite Impulse Response (FIR) filters
Implementation: Fir_Filter
This implementation, based on the ParksMcClellan algorithm, computes the optimal (in the Chebyshev/minimax sense) FIR filter impulse response given a set of band edges, the desired response on those bands, and the weight given to the error in those bands. The ParksMcClellan algorithm uses the Remez exchange algorithm and Chebyshev approximation theory to design filters with an optimal fit between the desired and actual frequency responses.
This implementation accepts the following parameters:
Parameter  Description  Required 

implementation 
Fir_Filter 
Mandatory 
input_item_type 
[cbyte , cshort , gr_complex ]: Input data type. This implementation only accepts streams of complex data types. 
Mandatory 
output_item_type 
[cbyte , cshort , gr_complex ]: Output data type. You can use this implementation to upcast the data type (i.e., from cbyte to gr_complex and from cshort to gr_complex ). 
Mandatory 
taps_item_type 
[float ]: Type and resolution for the taps of the filter. Only float is allowed in the current version. 
Mandatory 
number_of_taps 
Number of taps in the filter. Increasing this parameter increases the processing time.  Mandatory 
number_of_bands 
Number of frequency bands in the filter.  Mandatory 
band1_begin 
Frequency at the band edges [ b1 e1 b2 e2 b3 e3…]. Frequency is in the range [0, 1], with 1 being the Nyquist frequency (). The number of band_begin and band_end elements must match the number of bands. 
Mandatory 
band1_end 
Frequency at the band edges [ b1 e1 b2 e2 b3 e3 …]  Mandatory 
band2_begin 
Frequency at the band edges [ b1 e1 b2 e2 b3 e3 …]  Mandatory 
band2_end 
Frequency at the band edges [ b1 e1 b2 e2 b3 e3 …]  Mandatory 
ampl1_begin 
Desired amplitude at the band edges [ a(b1) a(e1) a(b2) a(e2) …]. The number of ampl_begin and ampl_end elements must match the number of bands. 
Mandatory 
ampl1_end 
Desired amplitude at the band edges [ a(b1) a(e1) a(b2) a(e2) …].  Mandatory 
ampl2_begin 
Desired amplitude at the band edges [ a(b1) a(e1) a(b2) a(e2) …].  Mandatory 
ampl2_end 
Desired amplitude at the band edges [ a(b1) a(e1) a(b2) a(e2) …].  Mandatory 
band1_error 
Weighting applied to band 1 (usually 1).  Mandatory 
band2_error 
Weighting applied to band 2 (usually 1).  Mandatory 
filter_type 
[bandpass , hilbert , differentiator ]: type of filter to be used. 
Mandatory 
grid_density 
Determines how accurately the filter will be constructed. The minimum value is 16; higher values makes the filter slower to compute, but often results in filters that more exactly match an equiripple filter.  Mandatory 
dump 
[false , true ]: Flag for storing the signal at the filter output in a file. It defaults to false . 
Optional 
dump_filename 
If dump is set to true , path to the file where data will be stored. 
Optional 
Input Filter implementation: Fir_Filter
.
Possible filter_type
are:

passband
: designs a FIR filter, using the weightsband1_error
,band2_error
, etc. to weight the fit in each frequency band. 
hilbert
: designs linearphase filters with odd symmetry. This class of filters has a desired amplitude of 1 across the entire band. 
differentiator
: For nonzero amplitude bands, it weights the error by a factor of so that the error at low frequencies is much smaller than at high frequencies. For FIR differentiators, which have an amplitude characteristic proportional to frequency, these filters minimize the maximum relative error (the maximum of the ratio of the error to the desired amplitude).
The following figure shows the relationship between = [band1_begin
band1_end
band2_begin
band2_end
] and = [ampl1_begin
ampl1_end
ampl2_begin
ampl2_end
] vectors in defining a desired frequency
response for the Input Filter:
Definition of frequency mask parameters.
If you have access to MATLAB, you can plot easily the frequency response of the filter. Just copy these lines into the command window:
f = [0 0.45 0.55 1];
a = [1 1 0 0];
b = firpm(5, f, a);
[h, w] = freqz(b, 1, 512);
plot(f, a, w/pi, abs(h))
legend('Ideal', 'Filter design')
xlabel('Radian Frequency (\omega/\pi)'), ylabel('Magnitude')
Example of GNSSSDR configuration:
;######### INPUT_FILTER CONFIG ############
InputFilter.implementation=Fir_Filter
InputFilter.dump=false
InputFilter.dump_filename=../data/input_filter.dat
InputFilter.input_item_type=cbyte
InputFilter.output_item_type=gr_complex
InputFilter.taps_item_type=float
InputFilter.number_of_taps=5
InputFilter.number_of_bands=2
InputFilter.band1_begin=0.0
InputFilter.band1_end=0.45
InputFilter.band2_begin=0.55
InputFilter.band2_end=1.0
InputFilter.ampl1_begin=1.0
InputFilter.ampl1_end=1.0
InputFilter.ampl2_begin=0.0
InputFilter.ampl2_end=0.0
InputFilter.band1_error=1.0
InputFilter.band2_error=1.0
InputFilter.filter_type=bandpass
InputFilter.grid_density=16
Implementation: Freq_Xlating_Fir_Filter
This implementation features a frequencytranslating FIR filter. This is often used when input data is at an intermediate frequency, as it performs filtering, decimation and frequency shifting in one single step. The basic principle of this block is to perform:
Input signal Filtering Output signal.
This block is a wrapper of GNU Radio’s freq_xlating_fir_filter_XXX_impl.cc.t block. It applies the baseband filter moved up to the intermediate frequency , then it performs decimation by a factor and a derotation with to downshift the signal to baseband. Thus, the filter parameters apply to the signal before decimation.
The block 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.
This implementation accepts the following parameters:
Parameter  Description  Required 

implementation 
Freq_Xlating_Fir_Filter 
Mandatory 
filter_type 
[lowpass , bandpass , hilbert , differentiator ]: type of filter to be used after the frequency translation. 
Mandatory 
input_item_type 
[byte , short , float , gr_complex ]: This implementation accepts as input data type real samples. It also accepts complex samples of the type gr_complex , assuming the presence of an intermediate frequency. The filter also works with IF=0 . 
Mandatory 
output_item_type 
[cbyte , cshort , gr_complex ]: Output data type. You can use this implementation to upcast the data type. 
Mandatory 
sampling_frequency 
Specifies the input sample rate , in samples per second.  Mandatory 
IF 
Specifies the intermediate frequency to be removed, in Hz. It defaults to Hz (i.e., baseband complex signal).  Optional 
decimation_factor 
Decimation factor (defaults to 1). Needs to be an integer.  Optional 
taps_item_type 
[float ]: Type and resolution for the taps of the filter. Only float is allowed in the current version. 
Mandatory 
number_of_taps 
Number of taps in the filter. Increasing this parameter increases the processing time. If filter_type is set to lowpass , this parameter has no effect 
Optional 
number_of_bands 
Number of frequency bands in the filter. If filter_type is set to lowpass , this parameter has no effect 
Optional 
band1_begin 
Frequency at the band edges [ b1 e1 b2 e2 b3 e3…]. Frequency is in the range [0, 1], with 1 being the Nyquist frequency (). The number of band_begin and band_end elements must match the number of bands. If filter_type is set to lowpass , this parameter has no effect 
Optional 
band1_end 
Frequency at the band edges [ b1 e1 b2 e2 b3 e3 …]. If filter_type is set to lowpass , this parameter has no effect 
Optional 
band2_begin 
Frequency at the band edges [ b1 e1 b2 e2 b3 e3 …]. If filter_type is set to lowpass , this parameter has no effect 
Optional 
band2_end 
Frequency at the band edges [ b1 e1 b2 e2 b3 e3 …]. If filter_type is set to lowpass , this parameter has no effect 
Optional 
ampl1_begin 
Desired amplitude at the band edges [ a(b1) a(e1) a(b2) a(e2) …]. The number of ampl_begin and ampl_end elements must match the number of bands. If filter_type is set to lowpass , this parameter has no effect 
Optional 
ampl1_end 
Desired amplitude at the band edges [ a(b1) a(e1) a(b2) a(e2) …]. If filter_type is set to lowpass , this parameter has no effect 
Optional 
ampl2_begin 
Desired amplitude at the band edges [ a(b1) a(e1) a(b2) a(e2) …]. If filter_type is set to lowpass , this parameter has no effect 
Optional 
ampl2_end 
Desired amplitude at the band edges [ a(b1) a(e1) a(b2) a(e2) …]. If filter_type is set to lowpass , this parameter has no effect 
Optional 
band1_error 
Weighting applied to band 1 (usually 1). If filter_type is set to lowpass , this parameter has no effect 
Optional 
band2_error 
Weighting applied to band 2 (usually 1). If filter_type is set to lowpass , this parameter has no effect 
Optional 
grid_density 
Determines how accurately the filter will be constructed. The minimum value is 16; higher values makes the filter slower to compute, but often results in filters that more exactly match an equiripple filter. If filter_type is set to lowpass , this parameter has no effect 
Optional 
bw 
Specifies the cutoff frequency, in Hz, of the lowpass filter used after the Intermediate Frequency removal. If filter_type is not set to lowpass , this parameter has no effect. It defaults to (sampling_frequency /decimation_factor )/2 Hz. 
Optional 
tw 
Specifies the width of the transition band (centered at bw ), in Hz, of the lowpass filter used after the Intermediate Frequency removal. If filter_type is not set to lowpass , this parameter has no effect. It defaults to . 
Optional 
dump 
[false , true ]: Flag for storing the signal at the filter output in a file. It defaults to false . 
Optional 
dump_filename 
If dump is set to true , path to the file where data will be stored. 
Optional 
Input Filter implementation: Freq_Xlating_Fir_Filter
.
Example:
;######### INPUT_FILTER CONFIG ############
InputFilter.implementation=Freq_Xlating_Fir_Filter
InputFilter.dump=false
InputFilter.dump_filename=../data/input_filter.dat
InputFilter.input_item_type=byte
InputFilter.output_item_type=gr_complex
InputFilter.taps_item_type=float
InputFilter.number_of_taps=5
InputFilter.number_of_bands=2
InputFilter.band1_begin=0.0
InputFilter.band1_end=0.45
InputFilter.band2_begin=0.55
InputFilter.band2_end=1.0
InputFilter.ampl1_begin=1.0
InputFilter.ampl1_end=1.0
InputFilter.ampl2_begin=0.0
InputFilter.ampl2_end=0.0
InputFilter.band1_error=1.0
InputFilter.band2_error=1.0
InputFilter.filter_type=bandpass
InputFilter.grid_density=16
InputFilter.IF=2000000
InputFilter.sampling_frequency=8000000
Adaptive filters for interference mitigation
The first step of any interference mitigation algorithm consists in determining whether the interference is present within the receiver’s frequency band. A simple method is to calculate the input signal power and compare it against a certain threshold. This threshold should be set according to the signal level in absence of the interference signal. Since the power of the GNSS useful signal components at the receiver’s antenna is extremely weak (several tens of dB below the background noise), the input signal power when the interference source is switched off is in practice the same as the background noise power. This is
After the ADC step and exploiting the statistical properties of (i.i.d. Gaussian symmetric circular noise), it is possible to guarantee a certain probability of false alarm, i.e. the probability of detecting the interference when the jamming signal is not present. Comparing the signal magnitude against the threshold and taking a decision in all the samples is not feasible in real time applications, so the detection algorithm runs on signal segments of length samples. The energy of a signal segment is
The random variable follows a chisquared distribution with degrees of freedom. According with the tabulated values of that distribution, it is possible to set the threshold that produces a given probability of false alarm. When the segment’s energy exceeds the detection threshold, then the segment is processed with the interference mitigation algorithm.
Note that should be estimated by a noise floor power estimation method. With the purpose of minimizing the random effects, several noise power estimations are averaged on consecutive signal segments. In addition, as the receiver background noise may change along the time, the estimation of is performed periodically. In this sense, the minimum signal length to be processed (filtered by a mitigation input filter) is one signal segment because the detection of an interference affects to the entire segment. The figure below summarizes the underlying idea.
Noise estimation parameters.
Implementation: Pulse_Blanking_Filter
IMPORTANT: This implementation is only available from the next
branch of GNSSSDR’s repository, so it is not present in the current stable release.
The basic principle of a Pulse Blanking filter is illustrated in the figure below. If the input signal has a squared magnitude within an observation window that is greater than the blanking threshold, , then the output signal is set to zero. Otherwise, the output is equal to the input. Replacing the corrupted samples by zero ensures that correlation values are minimally distorted.
Diagram of the Pulse Blanking filter.
where:
The implementation of this block provides the following interface:
Parameter  Description  Required 

implementation 
Pulse_Blanking_Filter 
Mandatory 
pfa 
Probability of false alarm. It defaults to  Optional 
length 
Number of signal samples per analysis segment. It defaults to .  Optional 
item_type 
Data type. This implementation only accepts gr_complex . It defaults to gr_complex . 
Optional 
segments_est 
Number of signal segments in a noise floor estimation epoch. It defaults to .  Optional 
segments_reset 
Number of signal segments between two consecutive noise floor estimations. It defaults to .  Optional 
IF 
Specifies the intermediate frequency to be removed, in Hz. It defaults to Hz (i.e., baseband complex signal).  Optional 
sampling_frequency 
If IF is set to any value below or above Hz, sampling_frequency specifies the sample rate , in samples per second. If IF is not set, this parameter has no effect. It defaults to Sps. 
Optional 
bw 
If IF is set to any value below or above Hz, bw specifies the cutoff frequency, in Hz, of the lowpass filter used after the Intermediate Frequency removal. If IF is not set, this parameter has no effect. It defaults to Hz. 
Optional 
tw 
If IF is set to any value above Hz, tw specifies the width of the transition band (centered at bw ), in Hz, of the lowpass filter used after the Intermediate Frequency removal. If IF is not set, this parameter has no effect. It defaults to . 
Optional 
dump 
[true , false ]. Flag for storing the signal at the filter output in a file. It defaults to false . 
Optional 
dump_filename 
If dump is set to true , path to the file where output data is stored. 
Optional 
Input Filter implementation: Pulse_Blanking_Filter
.
Example:
;######### INPUT_FILTER CONFIG ############
InputFilter.implementation=Pulse_Blanking_Filter
InputFilter.pfa=0.01
InputFilter.segments_est=5000
Implementation: Notch_Filter
IMPORTANT: This implementation is only available from the next
branch of GNSSSDR’s repository, so it is not present in the current stable release.
The aim of the Notch filter is to eliminate jamming signals who are instantaneously narrowband and, also, their instantaneous frequency changes along time.
Diagram of the notch filter.
When Interference Cancellation is adopted, the interfering signal is at first removed from , and subsequent signal processing is applied to . Since is usually not known, an estimation technique is required to reconstruct it and to obtain . This interference is usually estimated by considering a specific signal model which depends only on a reduced number of parameters. Let us consider a single component signal^{1}
where and are two real signals with and . Although this model is quite general, the hypothesis assumed by the single component model is that is instantaneously narrow band, i.e., it has a single frequency component at each instant in time. Continuous Wave and chirp signals are examples of waveforms that can be described by this model. The instantaneous frequency of a single component signal is defined as the discrete derivative of its phase:
This block implements a simple, singlesample Prony’s frequency estimator^{3}. The interference frequency is estimated as
Single component signals can be generated by a first order recurrence equation,
where is a timevarying coefficient that can be expressed as:
This principle is exploited in a single pole notch filter which is characterized by the following transfer function:
where is the complex zero of the filter and is the pole contraction factor, ranging from to . The pole contraction factor determines the bandwidth of the Notch filter, the closer to , the narrower the filter bandwidth.
The implementation of this block provides the following interface:
Parameter  Description  Required 

implementation 
Notch_Filter 
Mandatory 
p_c_factor 
Pole contraction factor of the filter, . It ranges from to . The higher the value, the lower the filter bandwidth. It defaults to  Optional 
pfa 
Probability of false alarm. It defaults to  Optional 
length 
Number of signal samples per analysis segment. It defaults to .  Optional 
item_type 
Data type. This implementation only accepts gr_complex . It defaults to gr_complex . 
Optional 
segments_est 
Number of signal segments in a noise floor estimation epoch. It defaults to .  Optional 
segments_reset 
Number of signal segments between two consecutive noise floor estimations. It defaults to .  Optional 
dump 
[true , false ]. Flag for storing the signal at the filter output in a file. It defaults to false . 
Optional 
dump_filename 
If dump is set to true , path to the file where output data is stored. 
Optional 
Input Filter implementation: Notch_Filter
.
Example:
;######### INPUT_FILTER CONFIG ############
InputFilter.implementation=Notch_Filter
InputFilter.p_c_factor=0.95
InputFilter.segments_est=5000
Implementation: Notch_Filter_Lite
IMPORTANT: This implementation is only available from the next
branch of GNSSSDR’s repository, so it is not present in the current stable release.
This is an implementation of a notch filter in which the user can choose the updating rate of the filter central frequency estimation. This requires lower computational resources since the Prony estimation is no longer performed sample by sample.
That update rate must be set according to the variation rate of the jammer frequency. Slow variations in the jammer frequency are well tracked by a slow updating rate, but this is not true for fast variations. In this implementation, the maximum updating rate available is one update per signal segment, this is to say, , where is the sampling frequency and is the number of samples per signal segment.
The implementation of this block provides the following interface:
Parameter  Description  Required 

implementation 
Notch_Filter_Lite 
Mandatory 
p_c_factor 
Pole contraction factor of the filter, . It ranges from to . The higher the value, the narrower the filter bandwidth. It defaults to  Optional 
pfa 
Probability of false alarm. It defaults to  Optional 
coeff_rate 
Updating rate of the filter coefficients. It defaults to tenth the sampling frequency set at SignalSource.sampling_frequency . 
Optional 
length 
Number of signal samples per analysis segment. It defaults to .  Optional 
item_type 
Data type. This implementation only accepts gr_complex . It defaults to gr_complex . 
Optional 
segments_est 
Number of signal segments in a noise floor estimation epoch. It defaults to .  Optional 
segments_reset 
Number of signal segments between two consecutive noise floor estimations. It defaults to .  Optional 
dump 
[true , false ]. Flag for storing the signal at the filter output in a file. It defaults to false . 
Optional 
dump_filename 
If dump is set to true , path to the file where output data is stored. 
Optional 
Input Filter implementation: Notch_Filter_Lite
.
Example:
;######### INPUT_FILTER CONFIG ############
InputFilter.implementation=Notch_Filter_Lite
InputFilter.p_c_factor=0.95
InputFilter.length=64
Short circuit
Implementation: Pass_Through
This implementation copies samples from its input to its output, without performing any filtering or data type conversion.
It accepts the following parameters:
Parameter  Description  Required 

implementation 
Pass_Through 
Mandatory 
item_type 
[gr_complex , cshort , cbyte ]: Format of data samples. It defaults to gr_complex . 
Optional 
Input Filter implementation: Pass_Through
.
Examples:
;######### INPUT FILTER CONFIG ############
InputFilter.implementation=Pass_Through
;######### INPUT FILTER CONFIG ############
InputFilter.implementation=Pass_Through
InputFilter.item_type=cshort
References

D. Borio, A MultiState Notch Filter for GNSS Jamming Mitigation, in Proc. of the International Conference on Localization and GNSS (ICLGNSS), pp. 16, June 2014, Helsinki, Finland. DOI: 10.1109/ICLGNSS.2014.6934175. ↩ ↩^{2}

F. Dovis, Ed. GNSS Interference Threats and Countermeasures, Artech House, Noordwood, MA, 2015. ↩

R. Prony, Essai expérimental et analytique sur les lois de la dilabilité des fluides élastiques, et sur celles de la force expansive de la vapeur de l’eau et de la vapeur de l’alkool, à différentes températures, Journal de l’École Polytechnique, Floréal et Prairial, Vol. 1, no. 22, pp. 24–76, 1795. ↩
Leave a comment