Comparison of L1 and L5 Bands GNSS Signals Acquisition

Abstract

Nowadays, civil Global Navigation Satellite System (GNSS) signals are available in both L1 and L5 bands. A receiver does not need to acquire independently the signals in both bands coming from a same satellite, since their carrier Doppler and code delay are closely related. Therefore, the question of which one to acquire first rises naturally. Although the common thought would tell the L1 band signals which are narrowband, an accurate comparison has never been done, and the decision is not as easy as it seems. Indeed, L5 band signals have several advantages such as stronger power, lower carrier Doppler, or a pilot channel, unlike the Global Positioning System (GPS) L1 C/A signal. The goal of this paper is therefore to compare the acquisition of L1 and L5 bands signals (GPS L1 C/A and L5, Galileo E1 and E5a/b) to determine which one is more complex and by which factor, in terms of processing time and memory, considering hardware receivers and the parallel code search. The results show that overall the L5 band signals are more complex to acquire, but it depends strongly on the conditions. The E5 signal is always more complex to acquire than E1, while the L5 signal can have a complexity close to the L1 C/A in some cases. Moreover, precise assistance providing accurate Doppler could significantly reduce the L5 complexity below the L1 complexity.

1. Introduction

The first stage of a Global Navigation Satellite System (GNSS) receiver is the acquisition, whose aim is to detect the signal and roughly estimate the code delay and the carrier frequency [1]. This is a computationally demanding operation since there are numerous possibilities to test, and today’s receivers are targeting higher and higher sensitivities and the ability to process more and more signals. Nowadays, Fast Fourier Transforms (FFT) are omnipresent in acquisition architectures to accelerate the acquisition, and the amount of memory needed is a major factor in a design [2].

There are now several signals available per constellation, and it is not necessary to acquire the different signals coming from one satellite independently. Indeed, considering two signals coming from the same satellite (for example Global Positioning System (GPS) L1 C/A and L5 signals): They are synchronized (the primary codes start at the same time, and the data and secondary code transitions are synchronized) [3]. The path traveled is the same, therefore the code delay is about the same (there is a slight difference due to the ionosphere that affects them differently [4]. However, knowing one gives precious information on the second); the relative speed being the same, the Doppler are proportional with a known factor (even with the offset due to the local oscillator). Therefore, the main question is: “Which signal should be acquired first?”, to then help the acquisition of the other(s) signal(s). This paper aims to answer this question, and quantify it with application examples.

The answer to this question is not so simple, because each signal has its own advantages and drawbacks. For example, L5 band signals, such as the GPS L5 and Galileo E5 signals, have a high chipping rate (10 times higher than L1 frequency signals). This high chipping rate implies a high sampling frequency, which implies itself a significant amount of samples to store and process, and a lower ratio between the clock frequency of the acquisition process and the sampling frequency leading to a longer processing time [5]. Therefore, L1 band signals, such as the GPS L1 C/A and Galileo E1 signals, are much more interesting on this side, since there is potentially a factor five or ten in the number of samples to process and in the processing speed, thanks to the ratio of the processing and sampling frequencies. Moreover, the L5 and E5 signals have longer primary codes than the L1 C/A and E1 signals, which a priori implies the testing of more code delays, larger FFTs for the correlations, and a bigger amount of memory to store correlation results.

However, the L5 band signals also have advantages: (1) They have a higher power (1.5 dB for the pilot channel of the L5 signal compared to the L1 C/A signal, and 2 dB for the E5a/b signals compared to the E1 signal for the pilot channels), which means that similar detection performance can be obtained with lower integration times; (2) They have a pilot channel, whereas the GPS L1 C/A signal does not have one, therefore this lasts one must limit its coherent integration time, which can lead to a longer total integration time; (3) They have a lower carrier Doppler and Doppler rate (115/154 ≈ 75%), which can reduce the search space and some constraints for the acquisition architecture; and (4) They have a secondary code, which on one side complicates the acquisition, but on another side makes the data synchronization much easier, simplifying the transition to the tracking.

The goal of this paper is therefore to compare in detail the acquisition of the L1 and L5 bands signals, in terms of processing time and memory requirements. More specifically, the GPS L1 C/A and L5 signals, and the Galileo E1 and E5 signals will be considered since these are the only signals in these two bands defined in an official interface specification and broadcasted currently. Two cases will be considered, one where there is no assistance at all (equivalent to a cold start), and one there is enough assistance to determine the secondary code delay, such that the receiver does not need to search it (kind of warm start). Indeed, it is relatively easy to have an estimate of the current secondary code chip. One chip of the L5 or E5 secondary codes lasts 1 ms, which is equivalent to 300 km. Therefore, if the receiver has an estimate of the current time better than 1 ms and an estimate of its position and of the satellites position better than 300 km (achievable with almanac), it is possible to estimate the current secondary code chip, and thus there is no need to search it via a correlation. If an estimate is available but not so accurate, the number of possibilities can still be reduced, e.g., to three or four, instead of 20 or 100.

The remainder of the paper is organized as follows. Section 2 describes briefly the GNSS signals considered, summarizes their characteristics, and introduces the acquisition search method chosen (parallel code search) and the elements of interest. Section 3 provides mathematical expressions of the processing time and the memory requirements for all the possible implementations: Data channel verses pilot channel, assistance verses no assistance, coherent integration only verses use of non-coherent integration, parallel verses semi-parallel verses serial implementation. Then, Section 4 describes the methodology used for the comparison, details all the parameters selected, and compares the acquisition of the GPS L1 C/A and L5 signals, and the acquisition of the Galileo E1 and E5 signals by evaluating the expressions given in Section 3. Finally, Section 5 summarizes the outcomes.

2. GNSS Signals and Acquisition

2.1. GNSS Signals

GNSS signals contain three essential components, namely navigation data, a pseudorandom code (also called primary code with the advent of modern signals) and a carrier. Modern signals may also contain other optional elements, such as a pilot channel where there is no random data; a secondary code, helping the data synchronization, reducing cross-correlation, and mitigating interference; and a sub-carrier, for multipath mitigation [6,7]. Table 1 summarizes the characteristics of the GNSS signals considered.

[ Table omitted. See PDF. ]

The signal after the front-end of a receiver is a combination of several GNSS signals and noise:

_sb(n_TS)=∑u=1U_sbu(n_TS)+_ηb(n_TS),

where _{sbu sbu} is the discrete baseband signal from satellite u u , n n is the discrete time index, _{TS TS} is the sampling period equal to 1/_fS 1/_fS with _{fS fS} the sampling frequency, and _{ηb ηb}is a white Gaussian noise.

The signal from one satellite can be expressed in a generic way as

_sbu(n_TS)=_{adu c2,du}(n_TS−^τu)_c1,du(n_TS−^τu)s_cdu(n_TS−^τu)^du(n_TS−^τu)cos(2π(_fIF+_fDu+_fOSC)n_TS+_φdu)+_{apu c2,pu}(n_TS−^τu)_c1,pu(n_TS−^τu)s_cpu(n_TS−^τu)sin(2π(_fIF+_fDu+_fOSC)n_TS+_φpu),

where the subscript d and p denotes the data and pilot channels respectively, ^{au au} is the amplitude, _{c1u c1u} is the primary code, _{c2u c2u} is the secondary code, s^cu s^cu is the subcarrier, ^{du du} is the navigation data, ^{τu τu} is the unknown code delay, _{fDu fDu} is the unknown Doppler frequency, _{fOSC fOSC} is the oscillator offset (not known in a cold start, but may be known or have a good estimation in warm and hot starts [8]), _{fIF fIF} is the intermediate frequency, and ^{φu φu} is the carrier phase. Note that in Equation (2), the data channel is denoted with a cos and the pilot channel is denoted with a sin, however it does not mean that they are necessary in quadrature, as shown in Table 1; it depends on the value of _{φd φd} and _{φp φp} [9]. Furthermore, the code Doppler is not considered in this model to keep it simple. Next, it is assumed that the code Doppler is compensated in the receiver. Since it is proportional to the carrier Doppler, it is relatively simple to adapt the local code chipping rate or to shift the correlation results during their accumulation.

Next, only the pilot channels are considered for the acquisition (except for the GPS L1 C/A signal that has only a data channel), because they allow longer coherent integration time, and it is known that the longer the coherent integration time the better the sensitivity [8,10]. However, it is not always possible to extend the coherent integration time to very long duration, due to the instability of the local oscillator [11,12,13] or the unknown dynamics of the receiver [8,14]. Therefore, to be as general as possible, two cases will be considered for the signal: The first with coherent integration only, without any limit; and the second with a coherent integration of one secondary code period, i.e., 20 ms for the L5 signal and 100 ms for Galileo signals, followed by further non-coherent integration.

2.2. Acquisition of GNSS Signals

There are several methods to perform the acquisition of GNSS signals, namely the serial search [1]; the Parallel Frequency Search (PFS), which uses an FFT to search simultaneously all or a part of the Doppler frequency bins [15,16]; the Parallel Code Search (PCS), which uses FFTs to compute the code correlation in order to search simultaneously all the code delay bins [1,17]; and two-dimensional search where FFTs are used for both frequency and code domains [9,16,18,19].

The method considered in this paper is the PCS that computes the correlation over the primary code correlation using FFTs, because [5]: (1) It is an efficient method providing a high level of parallelism; (2) the parallelism is still exploited in presence of a basic assistance, unlike the parallel frequency search (because it is much easier to reduce the frequency search space than the code delay search space from any assistance [8]); (3) the code Doppler can easily be compensated; and (4) it requires less memory than two-dimensional searches. To emphasize this, one can note that this is the method implemented in today’s mass market receivers [2], and considered or already implemented in spaceborne GNSS receivers [20,21,22].

An overview of the PCS architecture considered is shown in Figure 1. The incoming signal is stored into a memory, to be processed at a higher frequency in order to reduce the processing time [5]. Then, during the processing, the signal is multiplied by a local carrier, followed by an FFT-based correlation performed over one primary code period (in fact, two primary code periods are used to manage the possible transition and the zero-padding possibly needed, but this is repeated for every period [23,24]). At this stage, if the Doppler is completely removed, the i ith primary code correlation result can be expressed as

_ri=a _{c2,i−mS rP}+_ηi,

for a pilot channel signal, or as

_ri=a _{di rP}+_ηi,

for a data channel signal, where _{c2,i−mS c2,i−mS} is the (i−_mS) (i−_mS) th chip of the secondary code (the subscript is modulo _{NS NS} , with _{NS NS} the length of the secondary code in chip), _{mS mS} is the unknown delay of the incoming secondary code, _{rP rP} is the primary code autocorrelation of length _{NP NP} ( _{NP NP} being the number of samples in one primary code period), and _{ηi ηi} is the noise [23].

Figure 1. Overview of the considered parallel code search with long integration. Dashed blocks are optional.

Then, further coherent integration can be performed. If there is data, the data transition should be managed; if there is a secondary code, the secondary code should be removed with another correlation. This is described in detail in Section 3. Finally, non-coherent integration can be performed. The number of accumulators used for the coherent and non-coherent integrations can vary depending if the accumulations are performed in serial (one accumulator testing one delay at once), parallel (many accumulators testing all delays at once), or semi-parallel (several accumulators testing several delays at once).

For the comparisons in this paper, the implementations will be based on Figure 1 and inspired from [23], which compares many ways to implement the acquisition (e.g., the accumulation can be done before or after the FFTs, a temporary memory can be used or not, and the accumulation can be done serially or in parallel). The next section will detail the specific cases that interest us, i.e., using coherent integration only or using non-coherent integrations, and considering parallel, serial and semi-parallel accumulations. It is considered that the accumulations are performed after the FFT-based primary code correlation, and that there is no temporary memory since it is useless for coherent integration only and with non-coherent accumulations the structure would become different than the one of the implementations of the L1 C/A signal.

To assess the performance of the different implementations, the processing time and the amount of memory will be evaluated and compared. Therefore, in Figure 1, our focus is on the main memory storing the incoming signal, and on the accumulators after the FFT-based primary code correlation. The primary code correlation is considered traditional, because any method to make it faster such as those proposed in Reference [24,25,26] could be applied to any of the following implementations, and thus would not affect the comparison. Likewise for the secondary code correlation, where there are known methods to reduce the complexity by a factor two at least [27,28,29]. Thus, these methods are not considered in the evaluation of the memory and processing time in Section 3.

3. Assessment of Processing Time and Memory Requirements

This section aims to determine the expression of the processing time and of the amount of memory for the different implementations. For this, it discusses first the acquisition of a data channel, and then the acquisition of a pilot channel, without assistance (where the correlation over the secondary code should be performed) and with assistance (where the delay of the secondary code is known, allowing a simple secondary code removal). For each implementation, the timing diagram is provided and the processing time is directly deduced from it, as done in Reference [17,23]. Note that these expressions are fully deterministic and exact since the processing time for one frequency bin is given, not the mean acquisition time [30], which is sufficient to compare the implementations.

3.1. Acquisition of a Data Channel

This section discusses the acquisition of a data channel. This mainly concerns the GPS L1 C/A signal, since all the modern signals have a pilot channel.

There are different methods to manage the data transition during the acquisition. Since high sensitivity is considered, the longest coherent integration time is desired. Therefore, the method that computes many accumulations in parallel starting at different times to test all the possibilities, called full-bits method with estimation of bit transition times in Reference [31], is considered. The highest accumulated value should be the one where the accumulation starts with the data bit. Consequently, the implementation would be the one of Figure 2. The size of the memory-based accumulators is _NP=_{fS TP NP}=_{fS TP} , with _{TP TP}the period of the PRN code, e.g., 1 ms for the L1 C/A signal.

Figure 2. Implementation of a data channel acquisition (timing diagram available in Figure 3).

Figure 3. Timing diagram of a data channel acquisition shown in Figure 2, with ND=4 ND=4 for the illustration (in reality ND=20 ND=20 for the GPS L1 C/A signal). Colors indicate different portions corresponding to the length of one data bit. Grey color indicates intermediate results (i.e., the value is not yet the final one).

The size of the FFT can be _NFFT=_{NP NFFT}=_NP or nextpow2(2 _{NP NP} ), where nextpow2(n) means the power of two equal to or higher than n, i.e., ^{2⎡log(n)⎤ 2⎡log(n)⎤} . To preserve the periodicity of the code, either the sampling frequency should give a length _{NP NP} that is a power of two, or the length should be doubled by zero-padding. To avoid the loss due to the data transition within the correlation, the length should be doubled by zero-padding. Therefore, to be as general as possible and consider a flexible choice on the sampling frequency, it will not be assumed that _{NP NP} is a power of two, and therefore _NFFT= _NFFT= nextpow2(2 _{NP NP} ) =^{2⎡log(2_NP)⎤} =^{2⎡log(2_NP)⎤}.

The corresponding timing diagram is shown in Figure 3, from which we can deduce the processing time in clock cycle for one frequency bin:

_TFB=K_{NFFT ND}+2(_NFFT+L)+_NFFT(_ND−2)+_NP=K_ND(2_NP+_NZ)+_NP(2_ND−1)+_{NZ ND}+2L=_NP[(K+1)2_ND+1]+_NZ[(K+1)_ND]+2L,

where K K is the number of data bits accumulated non-coherently (i.e., the number of non-coherent accumulations here: K=_NNC K=_NNC ), _NFFT=2_NP+_{NZ NFFT}=2_NP+_NZ with _{NZ NZ} the number of zeros padded, _{ND ND} is the number of primary code periods in one data bit ( _ND=20 _ND=20 for the GPS L1 C/A signal), and L Lthe latency of the FFT (i.e., the number of clock cycles between the first output sample and the last input sample).

Regarding the amount of memory necessary, the memory-based accumulators require

M=_ND2_{NP BC}+_{ND NP BNC} bits=_{ND NP}(2_BC+_BNC) bits=_{ND NP}[3_BR+3⎡_{log 2}(_ND)⎤+⎡_log2(K)⎤] bits,

where _{BC BC} is the number of bits used to quantize the output of the coherent accumulators ( _{yi yi} ) and _{BNC BNC} is the number of bits used to quantize the output of the non-coherent accumulators ( _{zi zi}), with

_BC=_BR+⎡_{log 2}(_ND)⎤,

and

_BNC=_BC+⎡_log2(K)⎤=_BR+⎡_{log 2}(_ND)⎤+⎡_log2(K)⎤,

where _{BR BR} is the number of bits used to quantize the output of the correlation ( _{ri ri}). Note that these last two equations assume that there is no truncation during the accumulations.

3.2. Acquisition of a Pilot Channel without Assistance

3.2.1. Coherent Integration Only with Parallel Implementation

As mentioned previously, in the case where there is no non-coherent accumulation, there is only one stage of accumulator-based memory, and therefore there is no interest in having a temporary memory between the Inverse FFT (IFFT) output and the coherent accumulator(s).

The parallel implementation is already given in Reference [23], and shown in Figure 4 (where it is assumed that the coherent integration time is a multiple of the secondary code period), and the corresponding timing diagram is shown in Figure 5. The processing time for one frequency bin is thus

_TFB=K_{NFFT NS}+2(_NFFT+L)−(_NP+_NZ)=K_NS(2_NP+_NZ)+3_NP+_NZ+2L=_NP(2K_NS+3)+_NZ(K_NS+1)+2L,

where K K is the number of secondary code periods accumulated coherently. Thus, _KC=K_{NS KC}=K_NS correlation results are coherently accumulated (or written in another way, the coherent integration time is _TC=_{KC TP}=K_{NS TP TC}=_{KC TP}=K_{NS TP}).

Figure 4. Implementation of a pilot channel acquisition, with coherent integration only, in a parallel way (timing diagram available in Figure 5).

Figure 5. Timing diagram of the pilot channel acquisition shown in Figure 4, with NS=4 NS=4 for the illustration.

Regarding the amount of memory necessary, the memory-based accumulators require

M=_NS2_{NP BC} bits=_NS2_NP(_BR+⎡_{log 2}(K_NS)⎤) bits,

where _BC=_BR+⎡_log2(K_NS)⎤ _BC=_BR+⎡_log2(K_NS)⎤ is the number of bits used to quantize the output of the coherent accumulators ( _{yi yi}).

3.2.2. Coherent Integration Only with Serial Implementation

The serial implementation is already given in Reference [23], and shown in Figure 6, with its corresponding timing diagram in Figure 7. However, the timing diagram in Reference [23] is not totally correct because it shows that the coherent integration for different secondary code delay is computed first and then non-coherent accumulations can be done, which is not correct or would require additional storage. In Figure 7, the correlations and further coherent accumulations are computed first, and then the operation is repeated for different delays of the secondary code. Note, however, that the processing time in Reference [23] is correct and identical to the one given below.

Figure 6. Implementation of a pilot channel acquisition, without non-coherent accumulation, in a serial way (timing diagram available in Figure 7).

Figure 7. Timing diagram of the pilot channel acquisition shown in Figure 6, with NS=4 NS=4 and K=3 K=3 .

The processing time for one frequency bin is thus,

_TFB=K_{NFFT NS2}+2(_NFFT+L)−(_NP+_NZ)=K_NS2(2_NP+_NZ)+3_NP+_NZ+2L=_NP(2K_NS2+3)+_NZ(K_NS2+1)+2L.

Regarding the amount of memory necessary, the memory-based accumulator requires

M=2_{NP BC} bits,=2_NP(_BR+⎡_{log 2}(K_NS)⎤) bits,

where _BC=_BR+⎡_log2(K_NS)⎤ _BC=_BR+⎡_log2(K_NS)⎤as previously.

3.2.3. Coherent Integration only with Semi-Parallel Implementation

From the previous cases, it is easy to generalize to the case where _{NA NA} accumulators tests _{NA NA}delays in parallel. The processing time for one frequency bin is

_TFB=K_{NFFT NS}⎡_NSNA⎤+2(_NFFT+L)−(_NP+_NZ)=K_NS⎡_NSNA⎤(2_NP+_NZ)+3_NP+_NZ+2L=K_NS⎡_NSNA⎤(2_NP+_NZ)+3_NP+_NZ+2L=_NP(2K_NS⎡_NSNA⎤+3)+_NZ(K_NS⎡_NSNA⎤+1)+2L.

It can be checked that Equation (13) becomes Equation (9), with _NA=_{NS NA}=_NS , and becomes Equation (11) with _NA=1 _NA=1.

Regarding the amount of memory necessary, the memory-based accumulators require

M=_NA2_{NP BC} bits,=_NA2_NP(_BR+⎡_{log 2}(K_NS)⎤) bits,

where _BC=_BR+⎡_log2(K_NS)⎤ _BC=_BR+⎡_log2(K_NS)⎤ as previously. In the same way, Equation (14) becomes Equation (10), with _NA=_{NS NA}=_NS , and becomes Equation (12) with _NA=1 _NA=1.

3.2.4. Use of Non-Coherent Accumulation with Parallel Implementation

This implementation is very similar to the one of the data channel acquisition; there are only two differences:

1. The number of branches is _{NS NS} instead of _{ND ND}.

2. For a pilot channel, the coherent accumulations for the different delays start and finish at the same time, therefore the latency and the length of data needed is slightly reduced.

The implementation is shown in Figure 8. Since the accumulations start and finish at the same time, the timing diagram is the same as for the case of coherent integration only, shown in Figure 5, except that the portion repeated is for further coherent and non-coherent accumulations (and the number of repetition is still K K).

Figure 8. Implementation of a pilot channel acquisition, with non-coherent accumulation, in a parallel way (timing diagram available in Figure 5).

Regarding the memory, the memory-based accumulators require

M=_NS2_{NP BC}+_{NS NP BNC} bits=_{NS NP}(2_BC+_BNC) bits=_{NS NP}[3_BR+3⎡_{log 2}(K_NS/_NNC)⎤+⎡_log2(_NNC)⎤] bits,

with

_BC=_BR+⎡_{log 2}(K_NS/_NNC)⎤,

and

_BNC=_BC+⎡_log2(_NNC)⎤=_BR+⎡_{log 2}(K_NS/_NNC)⎤+⎡_log2(_NNC)⎤.

3.2.5. Use of Non-Coherent Accumulation with Serial Implementation

This implementation is shown in Figure 9. The processing time is the same as the serial implementation with coherent integration only (Figure 6), because the timing diagram (Figure 7) is similar. Indeed, the number of secondary code periods processed is still K/_NNC×_NNC=K K/_NNC×_NNC=K, even if it is spread between coherent and non-coherent accumulations.

Figure 9. Implementation of a pilot channel acquisition, with non-coherent accumulation, in a serial way (timing diagram available in Figure 7).

Regarding the memory, the memory-based accumulators require

M=2_{NP BC}+_{NP BNC} bits=_NP(2_BC+_BNC) bits=_NP[3_BR+3⎡_{log 2}(K_NS/_NNC)⎤+⎡_log2(_NNC)⎤] bits,

where _{BC BC} and _{BNC BNC}are the same as previously (Equations (16) and (17)).

3.2.6. Use of Non-Coherent Accumulation with Semi-Parallel Implementation

It is again easy to generalize to the case where _{NA NA} accumulators tests _{NA NA}delays in parallel. The processing time is the same as the semi-parallel implementation with coherent integration only. Regarding the amount of memory necessary, the memory-based accumulators require

M=_NA2_{NP BC}+_{NA NP BNC} bits=_{NA NP}(2_BC+_BNC) bits=_{NA NP}[3_BR+3⎡_{log 2}(K_NS/_NNC)⎤+⎡_log2(_NNC)⎤] bits,

where _{BC BC} and _{BNC BNC}are the same as previously (Equations (16) and (17)).

3.3. Acquisition of a Pilot Channel with Assistance

This section presents the serial and semi-parallel implementation when _{NSCB NSCB} delays of the secondary code should be tested instead of _{NS NS} , with 1≤_NSCB<_NS 1≤_NSCB<_NS (for the case _NSCB=1 _NSCB=1, only the serial implementation is considered). Note that since only the number of delays is reduced, the processing time will be reduced, but the amount of memory will not change.

3.3.1. Coherent Integration Only with Serial Implementation

The implementation is exactly the same as when there is no assistance, shown in Figure 6. The timing diagram is also the same, shown in Figure 7, the only difference is that the part that repeats is repeated _{NSCB NSCB} times instead of _{NS NS}times. The processing time for one frequency bin is thus,

_TFB=K_{NFFT NS NSCB}+2(_NFFT+L)−(_NP+_NZ)=K_{NS NSCB}(2_NP+_NZ)+3_NP+_NZ+2L=_NP(2K_{NS NSCB}+3)+_NZ(K_{NS NSCB}+1)+2L.

Therefore, the processing time is approximately divided by _NS/_{NSCB NS}/_NSCB compared to the case without assistance, as expected. Note that if the assistance is perfect, i.e., _NSCB=1 _NSCB=1, the processing time becomes the same as the one for the parallel implementation without assistance (Equation (9)), as expected.

3.3.2. Coherent Integration Only with Semi-Parallel Implementation

From the previous cases, it is easy to generalize to the case where _{NA NA} accumulators test _{NA NA} delays in parallel among the _{NSCB NSCB}possible. The processing time for one frequency bin is

_TFB=K_{NFFT NS}⎡_NSCBNA⎤+2(_NFFT+L)−(_NP+_NZ)=K_NS⎡_NSCBNA⎤(2_NP+_NZ)+3_NP+_NZ+2L=_NP(2K_NS⎡_NSCBNA⎤+3)+_NZ(K_NS⎡_NSCBNA⎤+1)+2L.

3.3.3. Use of Non-Coherent Accumulation with Serial Implementation

The implementation is exactly the same as when there is no assistance, shown in Figure 9. The timing diagram is also the same, shown in Figure 7, the only difference is that the part that repeats is repeated _{NSCB NSCB} times instead of _{NS NS} times, as in Section 3.3.1. Therefore, the processing time for one frequency bin is given in Equation (20).

3.3.4. Use of Non-Coherent Accumulation with Semi-Parallel Implementation

In the same way, is exactly the same as when there is no assistance, and the processing time is the same as the semi-parallel coherent only implementation—therefore the processing time is given in Equation (21).

3.4. Summary

To have a better overview of the previous expressions, Table 2 summarizes the processing time and the memory requirements for the different implementations.

[ Table omitted. See PDF. ]

4. Application to GPS and Galileo Signals

4.1. Determination of the Integration Time

Now, let us compare the different implementations with actual parameters. To have a good overview of the performance, several sensitivities are selected, from −140 dBm to −160 dBm with a step of 5 dBm to cover moderate to high sensitivities. However, as mentioned in the introduction and shown in Table 1, the expected power is not the same for the different signals. Therefore, to perform a fair comparison, the sensitivities should be adapted for each signal, and the values above would be for one signal only. Here the GPS L1 C/A has been chosen as reference. Since the GPS L5 signal has an expected power 1.5 dB above the L1 C/A signal power, the sensitivities considered for the L5 signal are −138.5 dBm, −143.5 dBm, −148.5 dBm, −153.5 dBm, and −158.5 dBm. This allows us to do a fair comparison representative of the reality. The same will apply for the Galileo signals.

Then, again to have a fair comparison, some elements must be considered specifically for each signal: The number of frequency bins and code bins, which influence the size of the search space and consequently influence the required Signal-to-Noise Ratio (SNR), probability of false alarm and probability of detection. This is illustrated in Figure 10, with NFB NFB the number of frequency bins, NPCB NPCB the number of primary code bins, NSCB NSCB the number of secondary code bins, NCB=NPCB NSCB NCB=NPCB NSCB the number of code bins, NCELL=NFB NCB NCELL=NFB NCB the number of cells of the search space, PFA,G PFA,G and PFA,C PFA,C the global and cell probabilities of false alarm respectively, related by PFA,G=1−(1−PFA,C)NCELL PFA,G=1−(1−PFA,C)NCELL or PFA,C=1−(1−PFA,C)1/NCELL PFA,C=1−(1−PFA,C)1/NCELL , and PD PD the probability of detection [8].

Figure 10. Parameters influencing the Signal-to-Noise Ratio (SNR) required.

Finally, once the required SNR is estimated, the coherent integration time and the number of non-coherent accumulations can be evaluated, as shown in Figure 11. The implementation losses depend on the quantization, frequency step, code step, and potential sign transition. Following the outcomes of [32], a 3-bit quantization, a frequency step δf δf of 2/(3_TC) 2/(3_TC) , and a code step of 1/2 chip is considered, and since the full bit method and secondary code correlation is used there is no transition loss. Regarding the case of coherent integration only, Figure 11b shows that this is an iterative process. There is even a second iteration not shown in Figure 10 and Figure 11, because increasing the coherent integration will decrease the frequency step (since δf=2/(3/_TC) δf=2/(3/_TC) ). This will increase the number of frequency bins _{NFB NFB} (since _NFB=_fSS/δf=3_{fSS TC}/2 _NFB=_fSS/δf=3_{fSS TC}/2 with _{fSS fSS} the search space), which itself increases the required SNR after Figure 10, which consequently may change the coherent integration time after Figure 11b. Therefore, for a very accurate estimation in the case of coherent integration only, these iterations should be performed.

Figure 11. Evaluation of the coherent integration time and number of non-coherent accumulations: (a) When the coherent integration time is fixed, and the number of non-coherent accumulations is estimated; (b) When there is coherent integration only, and the coherent integration time is estimated.

4.2. Comparison of GPS L1 C/A and L5 Signals Acquisition

4.2.1. Determination of Acquisition Parameters

The general parameters independent of the integration time that have been selected are summarized in Table 3 (the spreadsheets used to obtain the further tables are available in supplementary materials). The sampling frequencies are chosen to be as low as possible, because it is desired that the acquisition be as fast as possible, i.e., slightly above twice the chipping rate since these are BPSK signals (it is not exactly twice the chipping rate because the sampling frequency should never be a multiple of the chipping rate, else it would lead to a very bad accuracy in the estimation of the pseudo-ranges and position [33]).

[ Table omitted. See PDF. ]

Starting with the L1 C/A signal, a typical search space of ±5 kHz is considered [8], and since the coherent integration time is fixed to 20 ms, the frequency step is 2/(3_TC)= 2/(3_TC)= 33.3 Hz, implying 2 × 5000/33.3 ≈ 300 frequency bins. The code step is one sample, giving 2048 code bins. The number of cells is thus 300 × 2048 = 614,400. A global probability of false alarm of ^{10−3 10−3} is chosen to avoid false alarms, which gives _PFA,C=1.63×¹⁰⁻⁹ _PFA,C=1.63×¹⁰⁻⁹ , and finally a typical probability of detection of 0.9 is chosen following [8], which gives a required final SNR of 17.15 dB.

Since a case of assistance will be considered for the L5 signal, this same assistance should be considered for the L1 C/A signal to make a fair comparison. As mentioned previously, the assistance indicates the current chip of the secondary code (or a small range), and the information needed for this information (time, and receiver and satellites position) can also be used to reduce the frequency search space. Therefore, with assistance, counting an error of 60 Hz due to almanac inaccuracy and an uncertainty of 180 Hz for the receiver velocity (Doppler added by a receiver at 130 km/h in the direction of a satellite) [8], it will be assumed that the search space is reduced to 16 bins, corresponding to ±266.7 Hz.

The same is done for the L5 signal, considering four cases, coherent integration limited to 20 ms or unlimited, and with or without assistance. One difference in the assumptions is that since the L5 frequency is about 75% the one of the L1 frequency, the expected Doppler and the search space for an L5 signal should be reduced. This gives 225 frequency bins without assistance (±3750 Hz), and 12 frequency bins with assistance (±200 Hz). For the L5 signal, the assistance reduces the number of secondary code bin _{NSCB NSCB} and consequently the number of code bins _{NCB NCB} . For the application here, the best assistance is assumed, i.e., the current secondary code chip is known and _NSCB=1 _NSCB=1 and _NCB=_{NPCB NCB}=_NPCB.

Table 4 summarizes all this information. Note that to be very accurate, the number of frequency bins for the unlimited _{TC TC} case should be higher since _NFB=3_{fSS TC}/2 _NFB=3_{fSS TC}/2 , and an iterative calculation should be performed as mentioned previously. However, this would lead to a different required SNR for each sensitivity, which would be hard to synthesize. Consequently, the same number of frequency bins is considered as simplification, keeping in mind that for these two cases the performance will be a little bit optimistic compared to the real one. Note also that another approximation is made, namely that a Gaussian variable is considered for the detection test. This is the case when the number of non-coherent accumulations is high, however, when there is not or a just few non-coherent accumulations, the variable is not Gaussian, which would affect the way the probabilities of false alarm and detection are calculated [8].

[ Table omitted. See PDF. ]

Now that the required SNR is determined, the coherent and total integration times can be estimated following Figure 11, and the values are summarized in Table 5 and Table 6, considering the average and worst case regarding the implementation losses (quantization, frequency step, and code step), namely 0.55 + 0.53 + 1.16 = 2.24 dB and 0.55 + 1.65 + 2.50 = 4.70 dB respectively.

[ Table omitted. See PDF. ][ Table omitted. See PDF. ]

Before going on the evaluation of the different implementations, Table 7 shows the ratio of the total integration time between several cases to quantify the impact of using the L5 signal, unlimited coherent integration time, and assistance. From Table 7, it is clear that the main way to reduce the total integration time is to increase the coherent integration time, especially for very weak signals. Then, the use of L5 brings an interesting reduction, thanks to its higher power, even if the required SNR after correlation is higher due to the bigger search space. Finally, the assistance has the lowest effect on the total integration time, but the reduction is still appreciable (and remember that the assistance reduces the frequency search space, which will have a significant positive impact on the acquisition time).

[ Table omitted. See PDF. ]

4.2.2. Determination of Ratio of Complexity for One Frequency Bin

Using the total integration time of Table 5 and Table 6, the parameters that depend on the integration, i.e., the processing time and the memory requirements, can be determined for the different cases. Table 8 illustrates this in detail for a sensitivity of −150 dBm, where the ratio of processing time and memory between the L5 signal and the L1 C/A signal is given. The final metric of performance is the product of ratios. If nothing is specified, there is no assistance. Then, Table 9 complements it by adding the input memory that stores the input signal. Finally, Table 10 and Figure 12 summarize the product of ratios for all the sensitivities, considering or not the input memory.

Figure 12. Ratio of complexity (product of processing time ratio and memory ratio) between the L5 and L1 C/A signals. (Left) without assistance, (right) with assistance. Solid curves do not consider the input memory, while dashed curves consider the input memory.

[ Table omitted. See PDF. ]

[ Table omitted. See PDF. ][ Table omitted. See PDF. ]

First, it can be seen that when the coherent integration time is limited to 20 ms for the L5 signal (non-coherent (NC) case), the L5 signal implementations are much more complex, with products of ratios higher than 100 without assistance.

It can also be noted in Table 8 and Table 9 that without taking into account the input memory, using a parallel, semi-parallel or serial implementation provides about the same performance (except for some semi-parallel that are not efficient, such as the one with nine accumulators because it requires more memory than with seven accumulators for the same processing time since ⎡20/9⎤=⎡20/7⎤=3 ⎡20/9⎤=⎡20/7⎤=3 ). When considering the input memory, the parallel implementation becomes more efficient, because such implementation uses a lot of memory, and therefore the input memory represents a smaller portion of it. This is more and more true as the sensitivity decreases. This is why only the parallel implementation is considered in Table 10 and Figure 12 when there is no assistance.

Now, let us focus on the interesting implementations, i.e., when the coherent integration time is not limited. Without assistance, for moderate sensitivities, the L5 implementations are much more complex with products of ratios up to 50. For very high sensitivity, the product of ratios becomes much smaller, even lower than 1 for a sensitivity of −160 dBm. This is mainly because the L1 C/A signal needs a very long integration time, and the input memory can even be larger for the L1 C/A signal than for the L5 signal. With assistance, the products of ratios are much smaller, between 0.1 and 4.6. Therefore, the L5 implementation can be more efficient for the computation of one frequency bin, or if it is less efficient it is by a relatively small ratio.

However, remember that the number of frequency bins for unlimited _{TC TC} is not the actual one, and it should be much higher with very long coherent integration time (except if the assistance is very accurate, which is possible in some applications [22]).

4.2.3. Determination of Ratio of Complexity for Multiple Frequency Bins

Now that the complexity considering only one frequency bin has been studied, let us consider the real case where it is the acquisition time that matters. For this, the relation between the processing time of one frequency bin and the acquisition time should be determined, i.e., how many frequency bins are searched until the detection of the signal. Of course, this depends on the Doppler frequency of the received signal; however, assuming a uniform distribution of the Doppler frequency over the search space, in average _NFB/2 _NFB/2frequency bins are searched. Therefore, to include this in the evaluation of the complexity, the ratio of number of frequency bins searched between the different signals should be estimated, and since the number of frequency bins searched is directly proportional to the total number of bins, the ratio of total number of bins could be used. Two elements will thus be involved: (1) The width of the search space; and (2) the frequency step to browse the search space, which is inversely proportional to coherent integration time. Therefore, compared to the previous results, for the L5 signal with a coherent integration limited to 20 ms (as the L1 C/A signal), it is expected that the final ratio of complexity will be lower since the width of the search space is lower. However, for the L5 signal with longer coherent integration time, the frequency step will decrease, the number of frequency bins will increase and thus the final complexity will increase.

This is shown in Table 11, where the ratio of number of frequency bins is around 0.8 when non-coherent integration is used regardless the assistance, and where the ratio increases with the sensitivity when coherent integration only is used. Applying these ratios to Table 10 gives Table 12 that shows the final complexity ratio, considering the processing time of one frequency bin, the number of frequency bins searched and the memory requirements. It can then be seen that without assistance, the L5 signal is much more complex to acquire. With assistance, the ratios of complexity are lower, but the L5 signal is still more complex to acquire, except for a few cases.

[ Table omitted. See PDF. ][ Table omitted. See PDF. ]

4.2.4. Validation

To validate the previous developments, Matlab simulations have been performed for several sensitivities. GPS L1 C/A and L5 signals have been simulated with a random Doppler frequency within the search space and a random code delay, and acquired following the serial implementations of Section 2. This has been repeated 100 times, and the average of the measurements has been extracted.

Figure 13 illustrates this for a sensitivity of −145 dBm without assistance, where the ratio measured is relatively constant (the fluctuations are due to the fact that the detection may happen on a bin around the exact one). Then, Table 13 shows the theoretical and measured number of frequency bins and the ratio between L5 and L1. It can be seen that the number of frequency bins searched until detection is around half the total number of frequency bins, as expected. More importantly, it is seen that the measured ratio of the number of frequency bins searched matches the theoretical one, which validates the previous developments.

Figure 13. Number of frequency bins browsed (top) and ratio (bottom) of this over 100 simulations, for a sensitivity of −145 dBm without assistance.

[ Table omitted. See PDF. ]

4.3. Comparison of Galileo E1 and E5 Signals Acquisition

The general parameters independent of the integration time that have been selected for Galileo signals are summarized in Table 14. For the Galileo signals, three cases are compared. E1 with a sampling frequency slightly higher 6 times the chipping rate in order to have a code step small enough to give the same losses as in the BPSK case [24]. However, this leads to long sequences (longer than the E5a or E5b). Therefore, E1 with a sampling frequency slightly higher than four times the chipping rate to cover the main lobes of the signals is then considered, but this requires some additional techniques to compensate the correlation shape [34,35]. Finally, for E5a or E5b, a sampling frequency slightly higher than twice the chipping rate is considered, like the L5 signal.

[ Table omitted. See PDF. ]

The E1 and E5 secondary codes are both 100 ms long even if the number of chips is different, therefore this value will be considered as coherent integration time when using non-coherent integration.

Starting with the E1 signal, to be fair compared to the parameters selected for the GPS signals, a typical search space of ±4 kHz is considered (since the Galileo satellites have a lower speed and a maximum range rate around 20% lower); and since the coherent integration time is fixed to 100 ms, the frequency step is 2/(3_TC)= 2/(3_TC)= 6.67 Hz, implying 2 × 4000/6.67 ≈ 1200 frequency bins. The code step is one sample, giving 16,384 primary code bins for a sampling frequency of 4.096 MHz and 24,576 primary code bins for a sampling frequency of 6.144 MHz. Since the E1 secondary code is 25 chips long, the number of cells is 1200 × 16,384 × 25 = 491,520,000 and 1200 × 24,576 × 25 = 737,280,000 respectively. A global probability of false alarm of ^{10−3 10−3} gives _PFA,C=2.04×¹⁰⁻¹² _PFA,C=2.04×¹⁰⁻¹² and _PFA,C=1.36×¹⁰⁻¹² _PFA,C=1.36×¹⁰⁻¹²respectively, and finally a typical probability of detection of 0.9 gives a required final SNR of 18.30 dB and 18.35 dB respectively.

Then, as for the GPS, a case with assistance is also considered, where the current chip of the secondary code is known, and where the frequency search space is reduced to 213.3 Hz (80% of the 266.7 Hz of the GPS L1 C/A), giving 32 frequency bins.

The same is done for the E5 signal, considering four cases, coherent integration limited to 100 ms or unlimited, and with or without assistance. As for GPS, the only difference in the assumptions is that the frequency search space is about 75% the one of the E1 signal, which gives 900 frequency bins without assistance (±3000 Hz), and 24 frequency bins with assistance (±160 Hz).

Table 15 summarizes all this information. The values for the unlimited _{TC TC} case are considered the same, although the number of frequency bins should be adapted, as already mentioned in Section 4.2.

[ Table omitted. See PDF. ]

Next, the coherent and total integration times can be estimated following Figure 11, and the values are summarized in Table 16 and Table 17, considering the average and worst case regarding the implementation losses (same losses as for GPS signals). It can be seen that the integration times are very similar for the both sampling frequencies with the E1 signals. However, the integration time with the E5 signal is much lower in general, thanks to its power that is 2 dB higher.

[ Table omitted. See PDF. ][ Table omitted. See PDF. ]

Then, Table 18 then shows the ratio of the total integration time between several cases to quantify the impact of using unlimited coherent integration time and assistance with Galileo signals. It confirms the outcomes of Table 7 that the best way to reduce the total integration time is to increase the coherent integration time, especially for weak signals, but that having assistance still helps to reduce the integration time in a non-negligible way.

[ Table omitted. See PDF. ]

Then, Table 19 and Table 20 and Figure 14 summarize the product of ratios for all the sensitivities, both taking into account the input memory and not consider this factor—comparing E1 with itself for different sampling frequencies, and comparing E5 with E1, respectively.

Figure 14. Ratio of complexity (product of processing time ratio and memory ratio) between the E5 signal and the E1 signal with a sampling frequency of 4.096 MHz. (Left) without assistance, (right) with assistance. Solid curves do not consider the input memory, while dashed curves consider the input memory.

[ Table omitted. See PDF. ]

[ Table omitted. See PDF. ]

Table 19 shows that using a sampling frequency of 6.144 MHz instead of 4.096 MHz for the E1 signal triples the complexity most of the time. Therefore, it can be concluded it is certainly more efficient to use a sampling frequency of 4.096 MHz and a technique that modifies the local code to get rid of the side peak [34,35], rather than using a sampling frequency of 6.144 MHz.

Then, Table 20 and Figure 14 show that when there is no assistance, the E5 acquisition is approximately 25 to 45 times more complex. This is due to the very long secondary code to synchronize with (100 chips), which dramatically impacts the complexity.

When there is assistance, without considering the input memory, the E5 acquisition is still more complex, but by a lower ratio, around 6 for coherent only implementation and around 11 when non-coherent accumulation is used. One may note that if the ratio between E5 and E1 with a sampling frequency of 6.144 MHz was calculated (by simply diving the ratio of Table 20 by those of Table 19), the E5 could be only twice more complex than E1 for coherent only implementation. This is impressive, noting that the sampling frequency of the E5 is more than three times higher and the primary code is more than twice longer.

Finally, still with assistance, if the input memory is considered, the complexity increases and increases with the sensitivity, because at this time the sampling frequency of 20.48 MHz of the E5 signal becomes a huge burden.

Now, we can take into account the average number of frequency bins searched until detection to obtain the final ratios of complexity. Table 21 shows the ratio of number of frequency bins between the signals. As for the GPS, when there is non-coherent integration and that the coherent integration time is the same for both signals, the ratio depends only on the width of the search space, hence the ratio of 0.8. Then, with coherent integration only, since both signals are not limited in the coherent integration time (unlike the comparison of GPS L1 C/A and L5), the ratio is in favor of the E5 signal because it requires a smaller integration time thanks to its higher power.

[ Table omitted. See PDF. ]

Finally, applying these ratios to Table 20 gives Table 22 that shows the final complexity ratio, and it can be seen that even if the ratios are lower than Table 20, the E5 signal is still more complex than the E1.

[ Table omitted. See PDF. ]

5. Conclusions

This paper performed a very detailed comparison of the complexity of the acquisition of L1 and L5 bands signals, to determine which signal should be acquired first to then help the other, to verify the common thought that L5 band signals acquisition is more complex, and especially to quantify this ratio.

Such detailed comparison is needed because many parameters influence positively or negatively each band and each signal, such as the chipping rate, the sampling frequency, the carrier frequency, the length of the primary and secondary codes, the signal power, or the availability of a pilot channel; it is therefore difficult to make accurate estimation.

In a first part, general expressions of the processing time and memory requirements have been presented and are summarized in Table 2. Such expressions are applicable for any GNSS signal, and depend on several parameters. Some parameters depend on the signal considered, such as the number of samples in one code period (which depends on the code length and sampling frequency), or the length of the secondary code; and some parameters do not depend on the signal considered but depend on the context and design, such as the number of non-coherent integrations or the number of bits used for the quantization.

In a second part, the comparisons have been performed by evaluating the aforementioned expressions. An accurate estimation of the processing time and memory requirements has thus been done, providing all the details of the methodology, and considering many details (such as the search space that influences the probability of false alarm at the cell level and the signal-to-noise ratio required). In order to have a general view and not just one example, the following has been considered: Five sensitivities (from −140 dBm to −160 dBm with a step of 5 dBm); both unassisted and assisted case; and both coherent only integration (when applicable) and the use of non-coherent integration. Studies have been included to evaluate the impact of each element (Table 7 and Table 18).

For GPS, the L1 C/A and L5 signals have been compared. Table 10 and Figure 12 provide the ratio between the complexity of each of them considering the processing time of one frequency bin and the memory requirements, and Table 12 provides the final ratio of complexity which takes also into account the average number of frequency bins browsed until the signal detection. The developments have been validated by Matlab simulations (Table 13). The acquisition of the L5 signal is most of the time more complex. Without assistance, if the sensitivity or the coherent integration time is moderate, acquiring the L5 signal is much more complex (ratios higher than 50 most often, i.e., it may require 50 times more memory, or have a processing time that is 50 times longer, or e.g., 10 times more memory, with a 5 times longer processing time). For very high sensitivity with long coherent integration time, the complexity ratio for one frequency bin is smaller, but still to the detriment of the L5 signal, except at −160 dBm. With assistance, the complexity ratios are smaller for any sensitivity, but only those for unlimited coherent integration time are of interests, since the ratios for one frequency bin become between 0.1 and 4.6. i.e., the GPS L5 signal acquisition may be significantly less complex than the GPS L1 C/A signal one in some high sensitivity cases if only one or few frequency bins that have to be tested (which would require very accurate Doppler assistance). When considering more frequency bins, the L5 signal is more complex to acquire, except few cases.

For Galileo, the E1 signal has been compared with itself first, considering two different sampling frequencies, 4.096 MHz and 6.144 MHz, the first one being close to the minimum and the second one offering the same code loss as a BPSK signals sampled at about twice the chipping rate. Table 19 provides the ratios of complexity, and shows using a sampling frequency of 6.144 triples the complexity most of the time. It is therefore recommended to use the minimum sampling frequency of 4.096 MHz and use techniques to remove the side peaks of the main correlation peak.

Then, the E1 and E5 signals have been compared. Table 20 and Figure 14 provide the ratios of complexity for one frequency bin, and shows that the acquisition of the E5 signal is always more complex. Without assistance, acquiring the E5 signal is much more complex (ratios higher between 25 and 45). With assistance, the complexity ratios are smaller for any sensitivity, the lowest ratios being for unlimited coherent integration times; but the minimum ratio is still around 6 (without considering the input memory, else the ratios increase with the sensitivity), which makes the Galileo E5 signal acquisition significantly more complex than the Galileo E1 one even in the best case. Considering more frequency bins reduces these ratios (Table 22), however the E5 signal is still more complex to acquire.

In conclusion, the GPS and Galileo L5 band signals are overall more complex to acquire than the GPS and Galileo L1 band signals, although in some particular cases the difference may be negligible or limited. In particular, the L5 signal could show better performance in presence of very accurate assistance to avoid a significant increase of the number of frequency bins when using very long coherent integration times.

The methodology and the expressions and developments provided in this paper can be easily used to compare the complexity of current or future GNSS signals in specific cases for a wide variety of hardware implementations.

Supplementary Materials

The spreadsheets used to obtain Table 3, Table 4, Table 5, Table 6, Table 7, Table 8, Table 9, Table 10, Table 11, Table 12, Table 13, Table 14, Table 15, Table 16, Table 17, Table 18, Table 19, Table 20, Table 21 and Table 22 excepted Table 13 are available online at https://www.mdpi.com/1424-8220/18/9/2779/s1.

Author Contributions

C.B. initiated the idea of making this comparison; J.L. carried out the derivations and comparisons, and wrote the paper; and R.L.J. supervised the work. All of the authors contributed to discussions and revisions of the manuscript. Formal analysis, J.L.; Investigation, C.B.; Methodology, J.L.; Supervision, R.L.J.; Writing-original draft, J.L.; Writing-review & editing, R.L.J. and C.B.

Funding

This research received no external funding.

Conflicts of Interest

The authors declare no conflict of interest.

References

1. Borre, K.; Akos, D.M.; Bertelsen, N.; Rinder, P.; Jensen, S.H. A Software-Defined GPS and Galileo Receiver: A Single-Frequency Approach; Birkhäuser: Basel, Switzerland, 2007; ISBN 978-0817643904.

2. Van Diggelen, F. Who’s your daddy? Why GPS will continue to dominate consumer GNSS. Inside GNSS 2014, 9, 30–41.

3. Navstar GPS Space Segment—User Segment L5 Interfaces, Interface Specification (IS-GPS-705); National Coordination Office for Space-Based Positioning, Navigation, and Timing: Washington, DC, USA, 2003.

4. Misra, P.; Enge, P. Global Positioning System: Signals, Measurements, and Performance, 2nd ed.; Ganga-Jamuna Press: Lincoln, MA, USA, 2010; ISBN 978-0970954428.

5. Leclère, J.; Botteron, C.; Farine, P.-A. Comparison framework of FPGA-based GNSS signals acquisition architectures. IEEE Trans. Aeros. Electron. Syst. 2013, 49, 1497–1518.

6. Kaplan, E.D.; Hegarty, C.J. Understanding GPS/GNSS: Principles and Applications, 3rd ed.; Artech House: Norwood, MA, USA, 2017; ISBN 978-1630810580.

7. Betz, J.W. Engineering Satellite-Based Navigation and Timing: Global Navigation Satellite Systems, Signals, and Receivers; Wiley-IEEE Press: New York, NY, USA, 2015; ISBN 978-1118615973.

8. Van Diggelen, F. A-GPS: Assisted GPS, GNSS, and SBAS; Artech House: Norwood, MA, USA, 2009; ISBN 978-1596933743.

9. Foucras, M. Performance Analysis of Modernized GNSS Signal Acquisition. Ph.D. Thesis, INP Toulouse, Toulouse, France, 2015.

10. Pany, T.; Riedl, B.; Winkel, J.; Wörz, T.; Schweikert, R.; Niedermeier, H.; Lagraste, S.; López-Risueño, G.; Jiménez-Baños, D.F. Coherent integration time: The longer, the better. Inside GNSS 2009, 4, 52–61.

11. Gaggero, P.O. Effect of Oscillator Instability on GNSS Signal Integration Time. Master’s Thesis, University of Neuchâtel, Neuchâtel, Switzerland, 2008.

12. Gaggero, P.O.; Borio, D. Ultra-stable oscillators: Limits of GNSS coherent integration. In Proceedings of the 21st International Technical Meeting of The Satellite Division of the Institute of Navigation (ION GNSS 2008), Savannah, GA, USA, 16–19 September 2008; pp. 565–575.

13. Gowdayyanadoddi, N.S.; Broumandan, A.; Curran, J.T.; Lachapelle, G. Benefits of an ultra stable oscillator for long coherent integration. In Proceedings of the 27th International Technical Meeting of The Satellite Division of the Institute of Navigation (ION GNSS+ 2014), Tampa, FL, USA, 8–12 September 2014; pp. 1578–1594.

14. Broumandan, A.; Nielsen, J.; Lachapelle, G. Coherent integration time limit for a mobile GNSS receiver for indoor GNSS applications. GPS Solut. 2012, 16, 157–167.

15. Mathis, H.; Flammant, P.; Thiel, A. An analytic way to optimize the detector of a post-correlation FFT acquisition algorithm. In Proceedings of the 16th International Technical Meeting of the Satellite Division of the Institute of Navigation (ION GPS/GNSS 2003), Portland, OR, USA, 9–12 September 2003; pp. 689–699.

16. Leclère, J.; Foucras, M.; Landry, R., Jr.; Ekambi, B. Efficient DBZP acquisition of GNSS signals using the radix-3 FFT algorithm. IEEE Aerosp. Electron. Syst. Mag. 2018. to be submitted.

17. Leclère, J. Resource-Efficient Parallel Acquisition Architectures for Modernized GNSS Signals. Ph.D. Thesis, EPFL, Neuchâtel, Switzerland, 2014.

18. Akopian, D. Fast FFT based GPS satellite acquisition methods. IEE Proc. Radar Sonar Navig. 2005, 152, 277–286.

19. Ziedan, N.I.; Garrison, J.L. Unaided acquisition of weak GPS signals using circular correlation or double-block zero padding. In Proceedings of the IEEE Position Location and Navigation Symposium (PLANS), Monterey, CA, USA, 26–29 April 2004; pp. 461–470.

20. Winternitz, L.M.; Bamford, W.A.; Heckler, G.W. A GPS receiver for high-altitude satellite navigation. IEEE J. Sel. Top. Signal Process. 2009, 3, 541–556.

21. Capuano, V.; Blunt, P.; Botteron, C.; Tian, J.; Leclère, J.; Wang, Y.; Basile, F.; Farine, P.-A. Standalone GPS L1 C/A Receiver for Lunar Missions. Sensors 2016, 16, 347.

22. Musumeci, L.; Dovis, F.; Silva, J.S.; da Silva, P.F.; Lopes, H.D. Design of a High Sensitivity GNSS receiver for Lunar missions. Adv. Space Res. 2016, 57, 2285–2313.

23. Leclère, J.; Botteron, C.; Farine, P.-A. High sensitivity acquisition of GNSS signals with secondary code on FPGAs. IEEE Aerosp. Electron. Syst. Mag. 2017, 32, 46–63.

24. Leclère, J.; Botteron, C.; Farine, P.-A. Acquisition of modern GNSS signals using a modified parallel code-phase search architecture. Signal Process. 2014, 95, 177–191.

25. Leclère, J.; Botteron, C.; Farine, P.-A. Improving the performance of the FFT-based parallel code-phase search acquisition of GNSS signals by decomposition of the circular correlation. In Proceedings of the 25th International Technical Meeting of the Satellite Division of the Institute of Navigation (ION GNSS 2012), Nashville, TN, USA, 17–21 September 2012; pp. 1406–1416.

26. Leclère, J.; Botteron, C.; Landry, R., Jr.; Farine, P.-A. FFT splitting for improved FPGA-based acquisition of GNSS. Int. J. Navig. Obs. 2015, 2015.

27. Leclère, J.; Landry, R., Jr. Complexity reduction for high sensitivity acquisition of GNSS signals with a secondary code. In Proceedings of the 29th International Technical Meeting of the Satellite Division of the Institute of Navigation (ION GNSS+ 2016), Portland, OR, USA, 12–16 September 2016; pp. 436–443.

28. Leclère, J.; Andrianarison, M.; Landry, R., Jr. Efficient GNSS secondary code correlations for high sensitivity acquisition. In Proceedings of the European Navigation Conference, Lausanne, Switzerland, 9–12 May 2017.

29. Leclère, J.; Landry, R., Jr. Combining secondary code correlations for fast GNSS signal acquisition. In Proceedings of the IEEE/ION Position Location and Navigation Symposium (PLANS), Monterey, CA, USA, 23–26 April 2018; pp. 46–55.

30. Couronneau, N. Performance Analysis of Assisted-GNSS Receivers. Ph.D. Thesis, University of Cambridge, Cambridge, UK, 2013.

31. Psiaki, M.L. Block acquisition of weak GPS signals in a software receiver. In Proceedings of the 14th International Technical Meeting of The Satellite Division of the Institute of Navigation (ION GPS 2001), Salt Lake City, UT, USA, 11–14 September 2001; pp. 2838–2850.

32. Leclère, J.; Landry, R., Jr.; Botteron, C. A review of GNSS signals acquisition in space. IEEE Trans. Aerosp. Electron. Syst. 2018. under review.

33. Akos, D.M.; Pini, M. Effect of sampling frequency on GNSS receiver performance. Navigation 2006, 53, 85–95.

34. Ward, P.W. A design technique to remove the correlation ambiguity in binary offset carrier (BOC) spread spectrum signals. In Proceedings of the 59th Annual Meeting of the Institute of Navigation and CIGTF 22nd Guidance Test Symposium, Albuquerque, NM, USA, 23–25 June 2003; pp. 146–155.

35. Heiries, V.; Roviras, D.; Ries, L.; Calmettes, V. Analysis of non ambiguous BOC signal acquisition performance. In Proceedings of the 17th International Technical Meeting of the Satellite Division of the Institute of Navigation (ION GNSS 2004), Long beach, CA, USA, 21–24 September 2004; pp. 2611–2622.