Abstract:
The navigation system described here utilizes GPS and Galileo satellite signals combined with Inertial Navigation Systems (INS), where a Coupled Antenna (CAN) provides both GNSS and Inertial Measurement Unit (IMU) data to a Highly Integrated GNSS-Inertial (Hi-Gi) receiver. Such receiver makes use of a high fidelity relation between GNSS unprocessed Correlator Output (COUT) I and Q data and the user trajectory, and inertial sensor data, which in turn are combined within a Kalman Filter (KF). The KF determines the navigation solution that is also used to provide feedback to the receiver demodulation signal processing stage, thus eliminating the need of dedicated structures such as Delayed Locked Loops (DLL) and Phase Locked Loops (PLL), allowing a significant improvement in navigation performance. The improvement allows this system to provide high quality measurements and operate in circumstances where usual techniques are not usable; for example during satellite signal interruption due to obstruction, or in very high dynamics or even in attenuated signal environments, due to, for example, the canopy of trees. The KF also makes use of particular Galileo signal characteristics, lock detectors and Coupled Antenna that allow the system to operate in such environments.

Description:
TECHNICAL FIELD 
     The following description refers to navigation systems in general and more specifically Global Navigation Satellite Systems using GPS and Galileo that are integrated with INS to provide enhanced navigation and ability to navigate in low signal strength, high dynamics or in other GNSS or INS harsh conditions. 
     BACKGROUND 
     GPS is classified as a GNSS (Global Navigation Satellite System) that has reached fully operational capability in 1995, and is developed by the United States Department of Defense. GPS is widely used today as a system that allows navigation in a myriad of domains, from space, aeronautics to maritime. It is also widely used in other applications such as map-making, land-surveying, time reference keeping and serves different communities such as the military, commercial and scientific. 
     Galileo is a European GNSS planed to be operational in 2012. It is being developed by the European Union and the European Space Agency. Galileo will introduce new signals with distinct characteristics of GPS and will provide a higher precision than is currently available with GPS. New signals will include a pilot tone signal, which has no navigation data modulation. 
     GPS and Galileo operate using the same principle: the receiver determines its position using distance measurements between itself and visible satellites. This is achieved by measuring the time elapsed between satellite transmission and receiver reception, and also by demodulating the received signal that contains the satellite position data, also known as ephemeris. Once the measurements are obtained and the navigation message demodulated, the user position is easily determined by solving a set of non-linear equations, where the number of unknowns are the three coordinates. Since the receiver does not have a perfectly accurate clock, besides three satellites for determination of three coordinates, an additional satellite measurement in needed. Furthermore, since the signals transmitted by the satellites are affected by propagation delays, such as due to ionosphere, additional algorithms are required by the receiver to correct the performed measurements. 
     GPS and Galileo signals are considerably weak when they arrive at the receiver. Furthermore such signals can be easily obstructed, for example due to a tall building, or can be attenuated due to, for example, the canopy of trees. This results in the inability to determine a valid navigation solution. Furthermore, when the dynamics between the satellite and user are very high and if no external aiding is used, an additional error may distort the navigation solution, usually termed dynamic stress error. 
     INS consists of an IMU (Inertial Measurement Unit) that is combined with a set of algorithms that provide the position, velocity and attitude of a platform by measuring the linear and angular accelerations applied to the system in an inertial reference frame. INS is widely used in navigation systems such as in aircraft, as it is immune to interference and offers a reliable an independent means for navigation. INS requires periodic calibration and maintenance at a period that typically depends on the quality and cost of the sensors. In some cases, using low cost sensors, the calibration is required every second to avoid excessive drifting. 
     To overcome individual INS and GNSS problems as those mentioned before, a widely used technique consists in integrating INS with GNSS, where each of the systems complement each other. In a prior art system, an additional technique consists in increasing the integration times of GNSS signals so that, during the integration, the navigation solution is provided by the INS. Increasing the integration time of GNSS signals is a usual technique employed in GNSS signal tracking to allow detection of weaker signals, but results in decreased sensibility due to dynamics unless external aid is available from, for example, the INS. Another limitation of long integrations is that its duration is limited to the navigation data period of GNSS signals. With Galileo pilot tone signal, since no navigation data is modulated, this will not be a problem but attention is still required not to loose required sensibility due to dynamics. 
     Different techniques can be used to integrate GNSS and INS, using different levels of integration, ranging from uncoupled, loosely coupled, tightly coupled to ultra-tightly coupled. Recent attempts to use ultra-tight integration between GNSS and INS techniques rely on replacing the traditional tracking structures with a KF (Kalman Filter). This technique allows elimination of bandwidth limitations imposed by filters within the DLLs (Delayed Locked Loops) and PLLs (Phase Locked Loops). Furthermore it allows multi-satellite tracking, which permits more robust satellite tracking as one signal aids the other since the navigation and the tracking are now performed together. In the ultra-tight approach, the combined GNSS-INS system provides the necessary feedback to aid the code and carrier phase tracking. Tracking of these components consists in aligning the incoming signal&#39;s code and carrier phase with the local generated replica in a permanent feedback and correction mechanism, requiring the use of code and carrier phase discriminators that provide an estimate of the error. 
     The bandwidth limitation of the DLL and PLL can affect the quality of the navigation solution, principally if the receiver clock or the inertial aiding quality are not good, resulting in an additional error in real and imaginary components of a correlator output COUT, also termed the I and Q components. One prior art technique is to model clock and the just mentioned I and Q errors in the KF in a tight coupling or, using an ultra-tightly coupled architecture as exemplified in the patent with international publication number WO 2005/124278 A1. In this type of approach, the I and Q data is used and the filter bandwidth is no longer a system design parameter, but intrinsically determined by the KF at every update epoch of the KF. However, a series on non-linear transformations and assumptions of the I and Q data are required. In prior art systems, as described in the United States patent with publication number US 2006/0161329 A1 and publication number U.S. Pat. No. 7,151,486 B2, the I and Q data are modelled as functions of simple cosine and sine with given amplitudes and white Gaussian noise, and transformations of measured I and Q data using discriminators, that in turn are related with KF states assuming the above mentioned simplified model. This model and transformations result in approximations that deteriorate the navigation solution, therefore making more difficult to track the GNSS in harsh environments, such as when the signal strength is low; when the dynamics are high; when the quality of the aiding or the clock is degraded. In both U.S. Pat. No. 7,151,486 B2 and US 2006/0161329 A1 the tracking modules provide residuals resulting from the transformations to navigation filter modules and therefore the integration between the I and Q data and the inertial sensor is not performed in the same filter. 
     An additional limitation in prior art systems is the tracking of low strength GPS signals often resulting in false signal lock, degrading the navigation solution. This problem is typical in tight coupling, since very small PLL and DLL bandwidths and multi-satellite tracking allow operation in noisier scenarios. The same problem applies in ultra-tight coupling. Therefore, in both tight and ultra-tight coupling, special attention is required in order to provide optimal signal lock detection. 
     In other prior art systems, the GNSS antenna and the inertial sensor and receiver are physical separated from each other and from the receiver, and therefore when installed, such as in an aircraft, due to the vibrations and other small movements in the structure, additional processing effort is required to remove, smooth or estimate such variations, that can affect the quality of the tracking in the tight ultra-tight coupling. 
     SUMMARY 
     In this description, a GNSS-INS Highly Integrated receiver (Hi-Gi) receiver allows solving the shortcomings described before by using a high fidelity relation between the correlator outputs I and Q data and the user position and velocity, and, in this way, achieve enhanced navigation in terms of position and velocity accuracy and availability in difficult environments such as in low signal strength, in high dynamics and during GNSS signal interruption. Furthermore no discriminator is used for carrier phase tracking so that I and Q data are direct observables of the navigation filter together with the inertial sensor data, thus eliminating additional source of error and achieving high level of integration between the inertial and the GNSS sensors. To assist in achieving the enhanced navigation, an optimal lock detector is employed and the GNSS antenna and inertial sensor integrated in the same casing. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWING 
       The invention is now described in detail with the help of the annexed drawings, where the  FIG. 1  depicts the architecture of the preferred embodiment of the invention. 
     
    
    
     DETAILED DESCRIPTION 
     The navigation system  100  comprises a hybrid sensor herein referred as Coupled Antenna (CAN)  101 . This sensor comprises a GNSS antenna and inertial sensors IMU typically a MEMS (Micro-Electro-Mechanical System) and provides both GNSS Radio Frequency (RF) data and inertial (acceleration and/or angular velocities) data. This data is fed to the receiver RF Front-End (RF-FE)  102  and also to the Hi-Gi navigator  109 . 
     The RF-FE  102  performs the acquisition and pre-processing of the signal transmitted by the satellite. This pre-processing includes, but is not limited to, the following functions: signal filtering, down-conversion to Intermediate Frequency (IF), Analog-to-Digital conversion (ADC) (including sampling, quantisation and Automatic Gain control (AGC)) and, optionally, down-conversion to baseband (BB). The AGC keeps the amplitude of the incoming signal constant, since it changes in time, amongst others factors, due to satellite movement. 
     The navigation system  100  is furthermore comprised by various channels, each allocated to a different satellite and signal frequency, having as inputs the RF-FE  102  data. Each channel comprises the following modules: code acquisition  104 , phase rotation  103 , multipliers  106 , local code generators  105 , Integrate and Dump (I&amp;D)  107 , lock detectors  108  and navigation data demodulator  110 . The multipliers, the local code generator and the I&amp;D form the so called Correlator Output (COUT) that consists of I and Q data. When the locally generated replicas of the code and phase are correctly aligned with the incoming signal, the I and Q data will reflect such high correlation. Several replicas of the local code are used, namely the Very-Early (VE), Early (E), Prompt (P), Late (L) and Very-Late (VL), corresponding to different code delays and resulting in different COUT signals. 
     Furthermore, the navigation system  100  also comprises the Hi-Gi navigator  109  that receives the inertial sensor data from the CAN Coupled Antenna  101  as well as the I and Q output data, and outputs the navigation solution, inertial sensors corrections, estimated code delay and estimated carrier phase and frequency. The estimated code delay and carrier phase and frequency outputs of the navigator  109  are communicated to the phase rotation  103  and local code generator  105 , respectively. This communication provides a feedback mechanism that allows controlling the error growth. The code delay and carrier phase and frequency are tracked simultaneously and for all channels in the KF using a high fidelity relation between the I and Q and the KF states. The KF states do not include the code delay, carrier phase or frequency measurement estimates themselves, nor their respective errors. Instead, the KF states include the position, velocity, attitude, clock bias and drift errors together with the inertial sensor misalignment, drift and bias, which are related to the actual code delay and carrier phase and frequency errors. In the case of the code delay tracking, the transformation includes normalisation and absolute values of the Early and Late I and Q measurements but in the case of the carrier phase no transformation is required and the KF uses directly the I and Q data. 
     The Hi-Gi also allows taking benefit from the steeper auto correlation function of Galileo signals, contributing to a more stable KF, thus aiding in achieving better performance in adverse conditions. Furthermore, the high fidelity model takes into account the integration time in the calculation of the correlation loss due to carrier frequency errors, which are particularly important for longer integration times (such as those allowed by Galileo pilot signals and assuming a linear phase during the integration period). Additionally, the KF of  109  uses satellite ephemeris from the navigation data to determine the satellites&#39; position and velocity. In turn, these are used to determine the estimates of code delay and carrier phase and frequency, outputs of  109 . The navigation data can be extracted from the COUT signals by the data demodulator  110  (if the signal being tracked is a data signal) or can be provided by an external source. 
     In the current description the traditional DLL and PLL structures are not present, although they can be implemented in parallel, and in this case, during receiver operation, a transition would occur between such more traditional structure and the Hi-Gi, as soon as the loops have converged and, in the case of a pilot channel, secondary code demodulation has been performed. 
     Within the Hi-Gi navigator  109 , the pre-processor determines additional required corrections, such as ionospheric and tropospheric. Usually these errors, although not small, have slow variations in time. The integer fix function is required since, in some cases, the KF may momentarily be unable to correctly track the incoming signal, resulting in unwanted ambiguity that needs to be fixed to provide a correct navigation solution. This fix is aided with data from a reference station. 
     The lock detectors  108  are used to determine if an interruption of the GNSS signal at the receiver has occurred and, in that case, communicate such event to the KF. Such detectors are of outmost importance in the Hi-Gi receiver since they prevent the KF from using data that would corrupt the navigation solution. Once such event is detected, the KF of  109  keeps communication with the local code generator  105 , so that when the outage has finished the re-acquisition can be instantaneous. 
     The navigation system  100  also comprises a data demodulator  110  module that is responsible for extracting the navigation data modulated in the incoming GNSS signals. 
     The acquisition module  104  is responsible for code acquisition of the GNSS signal and providing first estimates to start tracking the signals for both the local code generator  105  and to the phase rotation  103 . 
     The phase rotation  103 , multipliers  106 , I&amp;D  107 , Lock Detectors  108  and data demodulator  110  modules are repeated for each channel which, in turn, is allocated to a different GNSS satellite or signal. The phase rotation  103  is implemented using an NCO (Numerically Control Oscillator) and is responsible for generating the local carrier replica based on the carrier phase and frequency estimates. Subsequently, the signal is despread by multiplying it by the local (Prompt) code replica and a slight delayed (Late, Very-Late) and advanced (Early, Very-Early) versions of it. These are subsequently passed through the I&amp;D components  107  before they are used in the KF of  109 . The outputs of the I&amp;D blocks are the so called correlator output I and Q data, and are generated at a frequency defined by the integration period. When there is a GNSS signal interruption, the estimated code delay is still computed by the navigator and provided to the GNSS tracking stage using the before mentioned feedback mechanism, allowing to keep the internal code replica aligned for some amount of time. This allows skipping acquisition when signal interruption ends and tracking resumes. 
     The high fidelity model of the outputs of the correlator, before it is normalized, separates the contributions of the carrier and code Doppler and misalignment in five multiplicative factors and is given, for each integration number, n, as: 
                 S   n     ≈         A   n     ⁢     D   n     ⁢     E   n     ⁢     R   n     ⁢     L   n       +     W   n         ,   with                   A   n     =         10       C   /     N   0       10       ⁢     T   i           ,     
     ⁢       D   n     =     ±   1       ,     
     ⁢       E   n     =       ⅇ     j   ⁡     [       (       ϕ     i   n       -       ω   n     ⁢     t   n         )     -     (         ϕ   ^     n     -         ω   ^     n     ⁢     t   n         )       ]         ⁢         ⅇ       j   ⁡     (       ω   n     -       ω   ^     n       )       ⁢     t   n         -     ⅇ                           j   ⁡     (       ω   n     -       ω   ^     n       )       ⁢     (       t   n     +     T   i       )                 1   -     ⅇ       j   ⁡     (       ω   n     -       ω   ^     n       )       ⁢     T   s                 ,     
     ⁢       R   n     =     R   ⁡     (       -     τ   n       +     (         τ   ^     n     +     τ   corr       )       )         ,     
     ⁢       L   n     =     1   -     2   ⁢     (     1   -     1     4   ⁢     K   mod           )     ⁢     1   2     ⁢          1   -       χ   n         χ   ^     n              ⁢     (     1   +       K   mod     ⁢       T   i       T   c           )           ,         
where:
         n is the integration number, defining the integration time range [t n , t n +T i [ (where t n =(n−1)T i );   T i  is the integration period [s];   T c  is the chip time [s];   T s  is the pre-integration sampling period [s];   C/N 0  is the Carrier-to-Noise Ratio [dB-Hz];   τ n  is the code delay at time t n  [s];   {circumflex over (τ)} n  is the estimated code delay [s];   φ i     n    is the carrier phase at the beginning of the n-th integration [rad];   {circumflex over (φ)} n  is the carrier phase estimate [rad];   ω n  is the average Doppler shift during the n-th integration [rad/s] and ω n =ω| t=t     n    [rad/s];   {circumflex over (ω)} n  is the Doppler shift estimate [rad/s] and {circumflex over (ω)} n ={circumflex over (ω)}| t=t     n    [rad/s];   R(•) is the autocorrelation function of the GNSS signal for a given delay;   τ corr  is zero for the Prompt correlator and τ corr =  + d/2 for the Early and Late correlators, with d being the Early-Late correlator spacing [s] (in the case of Galileo BOC signals two extra correlators are used, as mentioned before, and their spacing is such that, when the Prompt correlator is on the main peak, the VE and VL correlators are positioned in the first secondary peaks, one at each side of the main peak);   K mod  is a constant dependent on the modulation: K mod =½ for BPSK modulations and K mod =n/m for BOC(n,m) modulations (which is the number of subcarrier periods in one code chip);   χ is the time expansion factor given by       

     
       
         
           
             
               χ 
               = 
               
                 
                   χ 
                   ⁡ 
                   
                     ( 
                     ω 
                     ) 
                   
                 
                 = 
                 
                   1 
                   
                     1 
                     + 
                     
                       ω 
                       
                         ω 
                         0 
                       
                     
                   
                 
               
             
             ; 
           
         
       
         
         
           
             {circumflex over (χ)} is the assumed (or estimated, if updated throughout the tracking phase) time expansion factors given by 
           
         
       
    
     
       
         
           
             
               
                 χ 
                 ^ 
               
               = 
               
                 
                   χ 
                   ⁡ 
                   
                     ( 
                     
                       ω 
                       ^ 
                     
                     ) 
                   
                 
                 = 
                 
                   1 
                   
                     1 
                     + 
                     
                       
                         ω 
                         ^ 
                       
                       
                         ω 
                         0 
                       
                     
                   
                 
               
             
             , 
           
         
       
         
         
           
              respectively; 
             ω 0  is the RF carrier frequency [Hz]; 
             W n  is the n-th realisation of a Gaussian random variable with zero mean and variance N=T i /T s  (which is the number of samples in one integration period). 
           
         
       
    
     The A n  factor accounts for the maximum amplitude of the correlator output for a given C/N 0  assuming unit noise power before correlation, the D n  factor is the data symbol and the W n  is the post-correlation noise. The remaining factors account for correlation losses due to carrier phase and frequency errors (E n  factor), code delay error (R n ) and code Doppler (L n ). 
     Note that this model assumes that the local carrier replica is generated according to
 
{circumflex over (Φ)} n ( t )={circumflex over (φ)} n +{circumflex over (ω)} n ( t−t   n )
 
and the incoming signal&#39;s carrier phase can be approximated by a piecewise linear phase defined as
 
                   ϕ   n     ⁡     (   t   )       =       ϕ     i   n       +       ω   n     ⁡     (     t   -     t   n       )           ,     
     ⁢   where                 ω   n     =         ϕ     i     n   +   1         -     ϕ     i   n           NT   s             
is the average Doppler frequency during the n-th integration.
 
     The term E n  can be re-written as a function of carrier phase and frequency errors: 
     
       
         
           
             
               E 
               n 
             
             = 
             
               
                 ⅇ 
                 
                   j 
                   ⁡ 
                   
                     [ 
                     
                       ( 
                       
                         ψ 
                         - 
                         
                           
                             η 
                             ⁡ 
                             
                               ( 
                               
                                 n 
                                 - 
                                 1 
                               
                               ) 
                             
                           
                           ⁢ 
                           
                             T 
                             i 
                           
                         
                       
                       ) 
                     
                     ] 
                   
                 
               
               ⁢ 
               
                 
                   
                     ⅇ 
                     
                       
                         jη 
                         ⁡ 
                         
                           ( 
                           
                             n 
                             - 
                             1 
                           
                           ) 
                         
                       
                       ⁢ 
                       
                         T 
                         i 
                       
                     
                   
                   - 
                   
                     ⅇ 
                     
                       
                         jη 
                         ⁢ 
                         nT 
                       
                       i 
                     
                   
                 
                 
                   1 
                   - 
                   
                     ⅇ 
                     
                       jη 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       
                         T 
                         s 
                       
                     
                   
                 
               
             
           
         
       
     
     The phase error is the difference between the estimated phase and incoming phase:
 
ψ=φ i     n   −{circumflex over (φ)} n  
 
The frequency error is the difference between the estimated and incoming carrier frequency:
 
η=  ω   i     n   −  {circumflex over (ω)}   n  
 
     Given the relation between the phase and the satellite-user range (assuming constant Doppler during the integration period and  ω   0 =2πf 0  where f 0  is the RF carrier frequency and N a  the unknown ambiguity in the carrier phase and c the speed of light): 
             ϕ   =         -       ϖ   0     c       ⁢   ρ     +     N   a                     ϕ   ^     =         -       ϖ   0     c       ⁢     ρ   ^       +       N   ^     a             
where the estimated satellite-user distance is:
 
{circumflex over (ρ)}=√{square root over (( X−{circumflex over (x)} ) 2 +( Y−ŷ ) 2 +( Z−{circumflex over (z)} ) 2 )}
 
     In this description the receiver clock, ionospheric, tropospheric and GNSS satellite clock errors has been omitted for representation simplicity but should be considered in the realisation as these can be simply obtained from the navigation data. 
     The true satellite-user distance is assumed to be:
 
ρ=√{square root over (( X −( {circumflex over (x)}+Δx )) 2 +( Y −( ŷ+Δy )) 2 +( Z− ( {circumflex over (z)}+Δz )) 2 )}
 
where the X, Y and Z is the satellite position in ECEF coordinates, and x, y and z the receiver position in the same coordinate system.
 
     Given the relation between the frequency and the range rate: 
               ϖ   =       ϖ   0     ⁢       ρ   .     c         ,       ϖ   ^     =       ϖ   0     ⁢         ρ   .     ^     c               
where the estimated satellite-user range-rate is:
 
                 ρ   .     ^     =     -         ϖ   0       c   ⁢     ρ   ^         ⁡     [         (       x   ^     -   X     )     ⁢     (         x   .     ^     -     X   .       )       +       (       y   ^     -   Y     )     ⁢     (         y   .     ^     -     Y   .       )       +       (       z   ^     -   Z     )     ⁢     (         z   .     ^     -     Z   .       )         ]               
and the true satellite-user range rate assumed to be:
 
     
       
         
           
             
               ρ 
               . 
             
             = 
             
               - 
               
                 
                   
                     ϖ 
                     0 
                   
                   cρ 
                 
                 ⁡ 
                 
                   [ 
                   
                     
                       
                         
                           
                             
                               ( 
                               
                                 
                                   ( 
                                   
                                     
                                       x 
                                       ^ 
                                     
                                     + 
                                     
                                       Δ 
                                       ⁢ 
                                       
                                           
                                       
                                       ⁢ 
                                       x 
                                     
                                   
                                   ) 
                                 
                                 - 
                                 X 
                               
                               ) 
                             
                             ⁢ 
                             
                               ( 
                               
                                 
                                   ( 
                                   
                                     
                                       
                                         x 
                                         . 
                                       
                                       ^ 
                                     
                                     + 
                                     
                                       Δ 
                                       ⁢ 
                                       
                                         
                                           
                                               
                                           
                                           ⁢ 
                                           x 
                                         
                                         . 
                                       
                                     
                                   
                                   ) 
                                 
                                 - 
                                 
                                   X 
                                   . 
                                 
                               
                               ) 
                             
                           
                           + 
                         
                       
                     
                     
                       
                         
                           
                             
                               ( 
                               
                                 
                                   ( 
                                   
                                     
                                       y 
                                       ^ 
                                     
                                     + 
                                     
                                       Δ 
                                       ⁢ 
                                       
                                           
                                       
                                       ⁢ 
                                       y 
                                     
                                   
                                   ) 
                                 
                                 - 
                                 Y 
                               
                               ) 
                             
                             ⁢ 
                             
                               ( 
                               
                                 
                                   ( 
                                   
                                     
                                       
                                         y 
                                         . 
                                       
                                       ^ 
                                     
                                     + 
                                     
                                       Δ 
                                       ⁢ 
                                       
                                           
                                       
                                       ⁢ 
                                       
                                         y 
                                         . 
                                       
                                     
                                   
                                   ) 
                                 
                                 - 
                                 
                                   Y 
                                   . 
                                 
                               
                               ) 
                             
                           
                           + 
                         
                       
                     
                     
                       
                         
                           
                             ( 
                             
                               
                                 ( 
                                 
                                   
                                     z 
                                     ^ 
                                   
                                   + 
                                   
                                     Δ 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     z 
                                   
                                 
                                 ) 
                               
                               - 
                               Z 
                             
                             ) 
                           
                           ⁢ 
                           
                             ( 
                             
                               
                                 ( 
                                 
                                   
                                     
                                       x 
                                       . 
                                     
                                     ^ 
                                   
                                   + 
                                   
                                     Δ 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     
                                       x 
                                       . 
                                     
                                   
                                 
                                 ) 
                               
                               - 
                               
                                 Z 
                                 . 
                               
                             
                             ) 
                           
                         
                       
                     
                   
                   ] 
                 
               
             
           
         
       
     
     It is now possible to relate the receiver frequency and carrier phase errors with the receiver velocity and position. In the Hi-Gi navigator, the KF will track also the code errors. The code error is defined to be the difference between the estimated code and incoming code, in seconds:
 
ζ=ρ−{circumflex over (τ)}
 
     Given the relation between the code with the satellite-user range:
 
ρ−{circumflex over (ρ)}= c (τ−{circumflex over (τ)})
 
     The KF uses the correlator output Early and Late signals that are related with code error ξ that in turn is related with the position error and the Early-Late correlator spacing: 
     
       
         
           
             
               
                  
                 
                   R 
                   
                     n 
                     E 
                   
                 
                  
               
               - 
               
                  
                 
                   R 
                   
                     n 
                     L 
                   
                 
                  
               
             
             = 
             
               
                  
                 
                   R 
                   ⁡ 
                   
                     ( 
                     
                       
                         - 
                         ζ 
                       
                       + 
                       
                         d 
                         2 
                       
                     
                     ) 
                   
                 
                  
               
               - 
               
                  
                 
                   R 
                   ⁡ 
                   
                     ( 
                     
                       
                         - 
                         ζ 
                       
                       - 
                       
                         d 
                         2 
                       
                     
                     ) 
                   
                 
                  
               
             
           
         
       
     
     For tracking of the code, the I and Q measurement is transformed before it is used in the KF, so that it can be related to the model while for tracking the phase they are directly used without any transformation. The I and Q measurements correspond to the real and imaginary part of the normalised COUT after navigation data extraction, that is the real and imaginary part of 
               S   n   ′            S   n   ′                
where S′ n  is the measured COUT, so that each channel input of  109  corresponds to three different measurements of the KF: the Prompt I F , Q p  and the difference |I E +Q E |−|I L +Q L |.
 
     The measurement equation of the KF is z k =H k x k +v k  where H k  is the Jacobian matrix, that uses the high fidelity model, evaluated at each filter iteration k, and where x k  is the state vector and v k  the white Gaussian noise. The state vector comprises position, velocity, attitude, and clock errors and inertial sensor errors such as misalignment, bias and scale factor. 
     The KF generates an internal prediction of the I p , Q p  and |I E +Q E |−|I L +Q L | using internal estimates of the position and velocity, which are used to perform the linearization. The partial derivatives of H are then determined, so that the different elements of H can be written, as an example, for the carrier phase and frequency error and along the x direction, in the following partial derivative decomposition and using the correlator model and also assuming that normalisation eliminates amplitude components leaving only the term E n : 
                 ∂   E         ∂   Δ     ⁢           ⁢   x       =         ∂   E       ∂   ψ       ⁢       ∂   ψ         ∂   Δ     ⁢           ⁢   x                         ∂   E         ∂   Δ     ⁢           ⁢     x   .         =         ∂   E       ∂   η       ⁢       ∂   η         ∂   Δ     ⁢           ⁢     x   .                 
and for the code, along the x direction:
 
     
       
         
           
             
               
                 ∂ 
                 
                   ( 
                   
                     
                        
                       
                         R 
                         E 
                       
                        
                     
                     - 
                     
                        
                       
                         R 
                         L 
                       
                        
                     
                   
                   ) 
                 
               
               
                 
                   ∂ 
                   Δ 
                 
                 ⁢ 
                 
                     
                 
                 ⁢ 
                 x 
               
             
             = 
             
               
                 
                   ∂ 
                   
                     ( 
                     
                       
                          
                         
                           R 
                           E 
                         
                          
                       
                       - 
                       
                          
                         
                           R 
                           L 
                         
                          
                       
                     
                     ) 
                   
                 
                 
                   ∂ 
                   ζ 
                 
               
               ⁢ 
               
                 
                   ∂ 
                   ζ 
                 
                 
                   
                     ∂ 
                     Δ 
                   
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   x 
                 
               
             
           
         
       
     
     The derivatives of the code and phase errors previously mentioned are obtained using the expressions given next. The internal estimates of the carrier phase, frequency and code are used to control the error growth of the KF as explained next. First, these are predicted at every filter iteration using the best estimate available of the position and velocity and therefore, in the determination of the estimates of code, phase and frequency required in the feedback tracking process, the satellite-user range and range rate is given for every iteration k using position and velocity of epoch k−1: 
     
       
         
           
             
               
                 
                   
                     
                       ρ 
                       ^ 
                     
                     k 
                   
                   = 
                   
                     
                       
                         
                           ( 
                           
                             
                               x 
                               k 
                             
                             - 
                             
                               
                                 x 
                                 ^ 
                               
                               
                                 k 
                                 - 
                                 1 
                               
                             
                           
                           ) 
                         
                         2 
                       
                       + 
                       
                         
                           ( 
                           
                             
                               Y 
                               k 
                             
                             - 
                             
                               
                                 y 
                                 ^ 
                               
                               
                                 k 
                                 - 
                                 1 
                               
                             
                           
                           ) 
                         
                         2 
                       
                       + 
                       
                         
                           ( 
                           
                             
                               Z 
                               k 
                             
                             - 
                             
                               
                                 z 
                                 ^ 
                               
                               
                                 k 
                                 - 
                                 1 
                               
                             
                           
                           ) 
                         
                         2 
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                   
                     
                       
                         ϕ 
                         ^ 
                       
                       k 
                     
                     = 
                     
                         
                     
                     ⁢ 
                     
                       
                         - 
                         
                           
                             ϖ 
                             0 
                           
                           c 
                         
                       
                       ⁢ 
                       
                         
                           ρ 
                           ^ 
                         
                         k 
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                   
                       
                   
                   ⁢ 
                   
                     
                       - 
                       
                         
                           ϖ 
                           0 
                         
                         c 
                       
                     
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     
                       
                         
                           
                             ( 
                             
                               
                                 X 
                                 k 
                               
                               - 
                               
                                 
                                   x 
                                   ^ 
                                 
                                 
                                   k 
                                   - 
                                   1 
                                 
                               
                             
                             ) 
                           
                           2 
                         
                         + 
                         
                           
                             ( 
                             
                               
                                 Y 
                                 k 
                               
                               - 
                               
                                 
                                   y 
                                   ^ 
                                 
                                 
                                   k 
                                   - 
                                   1 
                                 
                               
                             
                             ) 
                           
                           2 
                         
                         + 
                         
                           
                             ( 
                             
                               
                                 Z 
                                 k 
                               
                               - 
                               
                                 
                                   z 
                                   ^ 
                                 
                                 
                                   k 
                                   - 
                                   1 
                                 
                               
                             
                             ) 
                           
                           2 
                         
                       
                     
                   
                 
               
             
           
         
       
       
         
           
             
               
                 
                   
                     
                       ϖ 
                       ^ 
                     
                     k 
                   
                   = 
                   
                     
                       
                         ϖ 
                         0 
                       
                       c 
                     
                     ⁢ 
                     
                       
                         
                           ρ 
                           . 
                         
                         ^ 
                       
                       k 
                     
                   
                 
               
             
             
               
                 
                   = 
                   
                     
                       
                         ϖ 
                         0 
                       
                       c 
                     
                     ⁢ 
                     
                       
                         1 
                         
                           
                             ρ 
                             ^ 
                           
                           k 
                         
                       
                       ⁡ 
                       
                         [ 
                         
                           
                             
                               
                                 
                                   
                                     ( 
                                     
                                       
                                         
                                           x 
                                           ^ 
                                         
                                         
                                           k 
                                           - 
                                           1 
                                         
                                       
                                       - 
                                       
                                         X 
                                         k 
                                       
                                     
                                     ) 
                                   
                                   ⁢ 
                                   
                                     ( 
                                     
                                       
                                         
                                           
                                             x 
                                             . 
                                           
                                           ^ 
                                         
                                         
                                           k 
                                           - 
                                           1 
                                         
                                       
                                       - 
                                       
                                         
                                           X 
                                           . 
                                         
                                         k 
                                       
                                     
                                     ) 
                                   
                                 
                                 + 
                               
                             
                           
                           
                             
                               
                                 
                                   
                                     ( 
                                     
                                       
                                         
                                           y 
                                           ^ 
                                         
                                         
                                           k 
                                           - 
                                           1 
                                         
                                       
                                       - 
                                       
                                         Y 
                                         k 
                                       
                                     
                                     ) 
                                   
                                   ⁢ 
                                   
                                     ( 
                                     
                                       
                                         
                                           
                                             y 
                                             . 
                                           
                                           ^ 
                                         
                                         
                                           k 
                                           - 
                                           1 
                                         
                                       
                                       - 
                                       
                                         
                                           Y 
                                           . 
                                         
                                         k 
                                       
                                     
                                     ) 
                                   
                                 
                                 + 
                               
                             
                           
                           
                             
                               
                                 
                                   ( 
                                   
                                     
                                       
                                         z 
                                         ^ 
                                       
                                       
                                         k 
                                         - 
                                         1 
                                       
                                     
                                     - 
                                     
                                       Z 
                                       k 
                                     
                                   
                                   ) 
                                 
                                 ⁢ 
                                 
                                   ( 
                                   
                                     
                                       
                                         
                                           z 
                                           . 
                                         
                                         ^ 
                                       
                                       
                                         k 
                                         - 
                                         1 
                                       
                                     
                                     - 
                                     
                                       
                                         Z 
                                         . 
                                       
                                       k 
                                     
                                   
                                   ) 
                                 
                               
                             
                           
                         
                         ] 
                       
                     
                   
                 
               
             
           
         
       
     
     For the determination of the code, carrier and frequency errors, the following is used: 
     
       
         
           
             
               τ 
               - 
               
                 τ 
                 ^ 
               
             
             = 
             
               
                 1 
                 c 
               
               [ 
               
                 
                   
                     
                       
                         
                           
                             
                               ( 
                               
                                 
                                   X 
                                   k 
                                 
                                 - 
                                 
                                   ( 
                                   
                                     
                                       
                                         x 
                                         ^ 
                                       
                                       
                                         k 
                                         - 
                                         1 
                                       
                                     
                                     + 
                                     
                                       Δ 
                                       ⁢ 
                                       
                                           
                                       
                                       ⁢ 
                                       
                                         x 
                                         
                                           k 
                                           - 
                                           1 
                                         
                                       
                                     
                                   
                                   ) 
                                 
                               
                               ) 
                             
                             2 
                           
                           + 
                         
                       
                     
                     
                       
                         
                           
                             
                               ( 
                               
                                 
                                   Y 
                                   k 
                                 
                                 - 
                                 
                                   ( 
                                   
                                     
                                       
                                         y 
                                         ^ 
                                       
                                       
                                         k 
                                         - 
                                         1 
                                       
                                     
                                     + 
                                     
                                       Δ 
                                       ⁢ 
                                       
                                           
                                       
                                       ⁢ 
                                       
                                         y 
                                         
                                           k 
                                           - 
                                           1 
                                         
                                       
                                     
                                   
                                   ) 
                                 
                               
                               ) 
                             
                             2 
                           
                           + 
                         
                       
                     
                     
                       
                         
                           
                             ( 
                             
                               
                                 Z 
                                 k 
                               
                               - 
                               
                                 ( 
                                 
                                   
                                     
                                       z 
                                       ^ 
                                     
                                     
                                       k 
                                       - 
                                       1 
                                     
                                   
                                   + 
                                   
                                     Δ 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     
                                       z 
                                       
                                         k 
                                         - 
                                         1 
                                       
                                     
                                   
                                 
                                 ) 
                               
                             
                             ) 
                           
                           2 
                         
                       
                     
                   
                 
                 - 
                 
                   
                     ρ 
                     ^ 
                   
                   k 
                 
               
               ] 
             
           
         
       
       
         
           
             
               
                 ϕ 
                 k 
               
               - 
               
                 
                   ϕ 
                   ^ 
                 
                 k 
               
             
             -= 
             
               
                 
                   - 
                   
                     
                       ϖ 
                       0 
                     
                     c 
                   
                 
                 ⁢ 
                 
                   
                     
                       
                         ( 
                         
                           
                             X 
                             k 
                           
                           - 
                           
                             ( 
                             
                               
                                 
                                   x 
                                   ^ 
                                 
                                 
                                   k 
                                   - 
                                   1 
                                 
                               
                               + 
                               
                                 Δ 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 
                                   
                                     x 
                                     ^ 
                                   
                                   
                                     k 
                                     - 
                                     1 
                                   
                                 
                               
                             
                             ) 
                           
                         
                         ) 
                       
                       2 
                     
                     + 
                     
                       
 
                     
                     ⁢ 
                     
                       
                         ( 
                         
                           
                             Y 
                             k 
                           
                           - 
                           
                             ( 
                             
                               
                                 
                                   y 
                                   ^ 
                                 
                                 
                                   k 
                                   - 
                                   1 
                                 
                               
                               + 
                               
                                 Δ 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 
                                   
                                     y 
                                     ^ 
                                   
                                   
                                     k 
                                     - 
                                     1 
                                   
                                 
                               
                             
                             ) 
                           
                         
                         ) 
                       
                       2 
                     
                     + 
                     
                       
 
                     
                     ⁢ 
                     
                       
                         ( 
                         
                           
                             Z 
                             k 
                           
                           - 
                           
                             ( 
                             
                               
                                 
                                   z 
                                   ^ 
                                 
                                 
                                   k 
                                   - 
                                   1 
                                 
                               
                               + 
                               
                                 Δ 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 
                                   
                                     y 
                                     ^ 
                                   
                                   
                                     k 
                                     - 
                                     1 
                                   
                                 
                               
                             
                             ) 
                           
                         
                         ) 
                       
                       2 
                     
                   
                 
               
               - 
               
                 
                   ϕ 
                   ^ 
                 
                 k 
               
             
           
         
       
       
         
           
             
               
                 ϖ 
                 k 
               
               - 
               
                 
                   ϖ 
                   ^ 
                 
                 k 
               
             
             = 
             
               
                 
                   
                     
                       
                         
                           ϖ 
                           0 
                         
                         c 
                       
                     
                   
                   
                     
                       
                         1 
                         
                           
                             ρ 
                             ^ 
                           
                           k 
                         
                       
                     
                   
                 
                 ⁡ 
                 
                   [ 
                   
                     
                       
                         
                           ( 
                           
                             
                               ( 
                               
                                 
                                   
                                     x 
                                     ^ 
                                   
                                   
                                     k 
                                     - 
                                     1 
                                   
                                 
                                 + 
                                 
                                   Δ 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   
                                     
                                       x 
                                       ^ 
                                     
                                     
                                       k 
                                       - 
                                       1 
                                     
                                   
                                 
                               
                               ) 
                             
                             - 
                             
                               X 
                               k 
                             
                           
                           ) 
                         
                       
                     
                     
                       
                         
                           
                             ( 
                             
                               
                                 ( 
                                 
                                   
                                     
                                       
                                         x 
                                         . 
                                       
                                       ^ 
                                     
                                     
                                       k 
                                       - 
                                       1 
                                     
                                   
                                   + 
                                   
                                     Δ 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     
                                       
                                         
                                           x 
                                           . 
                                         
                                         ^ 
                                       
                                       
                                         k 
                                         - 
                                         I 
                                       
                                     
                                   
                                 
                                 ) 
                               
                               - 
                               
                                 
                                   X 
                                   . 
                                 
                                 k 
                               
                             
                             ) 
                           
                           + 
                         
                       
                     
                     
                       
                         
                           ( 
                           
                             
                               ( 
                               
                                 
                                   
                                     y 
                                     ^ 
                                   
                                   
                                     k 
                                     - 
                                     1 
                                   
                                 
                                 + 
                                 
                                   Δ 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   
                                     
                                       y 
                                       ^ 
                                     
                                     
                                       k 
                                       - 
                                       1 
                                     
                                   
                                 
                               
                               ) 
                             
                             - 
                             
                               Y 
                               k 
                             
                           
                           ) 
                         
                       
                     
                     
                       
                         
                           
                             ( 
                             
                               
                                 ( 
                                 
                                   
                                     
                                       
                                         y 
                                         . 
                                       
                                       ^ 
                                     
                                     
                                       k 
                                       - 
                                       1 
                                     
                                   
                                   + 
                                   
                                     Δ 
                                     ⁢ 
                                     
                                       
                                         
                                           
                                               
                                           
                                           ⁢ 
                                           
                                             y 
                                             . 
                                           
                                         
                                         ^ 
                                       
                                       
                                         k 
                                         - 
                                         1 
                                       
                                     
                                   
                                 
                                 ) 
                               
                               - 
                               
                                 
                                   Y 
                                   . 
                                 
                                 k 
                               
                             
                             ) 
                           
                           + 
                         
                       
                     
                     
                       
                         
                           
                             
                               ( 
                               
                                 
                                   
                                     z 
                                     ^ 
                                   
                                   
                                     k 
                                     - 
                                     1 
                                   
                                 
                                 + 
                                 
                                   Δ 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   
                                     
                                       z 
                                       ^ 
                                     
                                     
                                       k 
                                       - 
                                       1 
                                     
                                   
                                 
                               
                               ) 
                             
                             - 
                             
                               Z 
                               k 
                             
                           
                           ) 
                         
                       
                     
                     
                       
                         
                           ( 
                           
                             
                               ( 
                               
                                 
                                   
                                     
                                       z 
                                       . 
                                     
                                     ^ 
                                   
                                   
                                     k 
                                     - 
                                     1 
                                   
                                 
                                 + 
                                 
                                   Δ 
                                   ⁢ 
                                   
                                     
                                       
                                         
                                             
                                         
                                         ⁢ 
                                         
                                           z 
                                           . 
                                         
                                       
                                       ^ 
                                     
                                     
                                       k 
                                       - 
                                       1 
                                     
                                   
                                 
                               
                               ) 
                             
                             - 
                             
                               
                                 Z 
                                 . 
                               
                               k 
                             
                           
                           ) 
                         
                       
                     
                   
                   ] 
                 
               
               - 
               
                 ϖ 
                 ^ 
               
             
           
         
       
     
     Using the internal estimates for tracking the carrier phase and frequency, the KF will minimise the amounts: 
               Re   ⁢     {       S   n   ′            S   n   ′            }       -     Re   ⁢     {         E   ^     n              E   ^     n            }                     Im   ⁢     {       S   n   ′            S   n   ′            }       -     Im   ⁢     {         E   ^     n              E   ^     n            }             
and for the code:
 
     
       
         
           
             
               ( 
               
                 
                    
                   
                     
                       S 
                       
                         n 
                         E 
                       
                       ′ 
                     
                     
                        
                       
                         S 
                         
                           n 
                           P 
                         
                         ′ 
                       
                        
                     
                   
                    
                 
                 - 
                 
                    
                   
                     
                       S 
                       
                         n 
                         L 
                       
                       ′ 
                     
                     
                        
                       
                         S 
                         
                           n 
                           P 
                         
                         ′ 
                       
                        
                     
                   
                    
                 
               
               ) 
             
             - 
             
               
                 ( 
                 
                   
                      
                     
                       
                         R 
                         ^ 
                       
                       
                         n 
                         E 
                       
                     
                      
                   
                   - 
                   
                      
                     
                       
                         R 
                         ^ 
                       
                       
                         n 
                         L 
                       
                     
                      
                   
                 
                 ) 
               
               ⁢ 
               
                   
               
               ⁢ 
               where 
             
           
         
       
       
         
           
             
               
                 E 
                 ^ 
               
               n 
             
             = 
             
               
                 ⅇ 
                 
                   j 
                   ⁡ 
                   
                     [ 
                     
                       ( 
                       
                         
                           ψ 
                           ^ 
                         
                         - 
                         
                           
                             
                               η 
                               ^ 
                             
                             ⁡ 
                             
                               ( 
                               
                                 n 
                                 - 
                                 1 
                               
                               ) 
                             
                           
                           ⁢ 
                           
                             T 
                             i 
                           
                         
                       
                       ) 
                     
                     ] 
                   
                 
               
               ⁢ 
               
                 
                   
                     ⅇ 
                     
                       j 
                       ⁢ 
                       
                         
                           η 
                           ^ 
                         
                         ⁡ 
                         
                           ( 
                           
                             n 
                             - 
                             1 
                           
                           ) 
                         
                       
                       ⁢ 
                       
                         T 
                         i 
                       
                     
                   
                   - 
                   
                     ⅇ 
                     
                       j 
                       ⁢ 
                       
                         η 
                         ^ 
                       
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       
                         nT 
                         i 
                       
                     
                   
                 
                 
                   1 
                   - 
                   
                     ⅇ 
                     
                       j 
                       ⁢ 
                       
                         η 
                         ^ 
                       
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       
                         T 
                         s 
                       
                     
                   
                 
               
             
           
         
       
       
         
           
             
               
                 R 
                 ^ 
               
               
                 n 
                 E 
               
             
             = 
             
               R 
               ⁡ 
               
                 ( 
                 
                   
                     ζ 
                     ^ 
                   
                   + 
                   d 
                 
                 ) 
               
             
           
         
       
       
         
           
             
               
                 R 
                 ^ 
               
               
                 n 
                 L 
               
             
             = 
             
               R 
               ⁡ 
               
                 ( 
                 
                   
                     ζ 
                     ^ 
                   
                   - 
                   d 
                 
                 ) 
               
             
           
         
       
       
         
           
             
               ψ 
               ^ 
             
             = 
             
               
                 ϕ 
                 k 
               
               - 
               
                 
                   ϕ 
                   ^ 
                 
                 k 
               
             
           
         
       
       
         
           
             
               η 
               ^ 
             
             = 
             
               
                 ϖ 
                 k 
               
               - 
               
                 
                   ϖ 
                   ^ 
                 
                 k 
               
             
           
         
       
     
     Both the phase and the frequency estimates are used to generate the local carrier replica by the NCO: its phase varies linearly with time during each integration period, its initial value is the actual phase estimate and the rate of change is the frequency estimate. 
     Furthermore, the effect of L n  is not necessary to be considered for the carrier phase since it affects only the amplitude and also not used in the code since the Early and Late samples are taken at the same time. Additionally, the description provided here is sufficiently generic to apply to different GNSS signals such as GPS L1, or L2 or Galileo L1 or E5. 
     As to the remaining implementation of the KF, the process model and the state transition model is given by:
 
 {dot over (x)}=f ( x ,ε)
 
     In more detail, the basic form of the navigation ordinary differential equations (ODE) in ECEF reference frame for solving position (x e ), velocities (v e ) and attitude angles (in form of Euler matrix R b   e ) is:
 
{dot over (x)} e =v e  
 
 {dot over (v)}   e   =R   b   e ( R   wa   b (1 +S   a )( f   b +ω f   −b   a ))−2Ω ie   e   v   e   +g   e ( x   e )
 
 {dot over (R)}   b   e   =R   b   e (ω ei   b +ω e ( R   wo   b (1 +S   o )(ω ib   b +ω w   −b   o )))
 
 {dot over (b)}   o =−β b   b   o   +w   b     o    
 
 {dot over (b)}   a =−α b   b   a   +w   b     a    
 
 {dot over (s)}   o =−β .s   s   o   +w   s     a    
 
 {dot over (s)}   a =−α s   s   a   +w   s     a    
 
 {dot over (m)}   o =−β m   m   o   +w   m     o    
 
 {dot over (m)}   a =−α m   m   a   +w   m     a    
 
     Where the accelerometers and gyroscopes observations (f b  and Ω ib   b  respectively) are compensated with Earth rotation (Ω ci   b ), Coriolis Effect (−2Ω ic   e v e ) and gravity (g e (x e )) effect terms. 
     The units used in the equations depend of the reference frame and coordinate system chosen for the processing. However, assuming an ECEF reference frame using a Cartesian coordinate system, for the position and velocity and standard angular units for the angles, the units user are as follows: meters (m) for the position, meters per second (m/s) for the velocity and radians (rad) for the attitude angles. It should be taken into account that the angles may be processed as quaternions or elements of an Euler matrix (unitless parameters). All the parameters related with specific forces (accelerometer observations, gravity and Coriolis Effect) are expressed in meters per squared second (m/s 2 ) and the parameters related with turns (gyroscope observations and Earth rotation) are expressed in radians per second (rad/sec). In this case, the angular variations parameters are also processed as quaternions or elements of an Euler matrix. 
     The IMU calibration parameters are:
         w ω  is the gyroscope observation white noise (usually set as a spectral density as in [deg/sqrt(hr)] or [rad/sqrt(Hz)]);   w f  is the accelerometer observation white noise (usually set as a spectral density as [micro-g/sqrt(Hz)]);   S o  is the gyroscope scale factor matrix (usually set as unit less parameters or in parts per million (ppm));   S a  is the accelerometer scale factor matrix (usually set as unit less parameters or in ppm);   R ωo   b  is the gyroscope misalignment matrix [rad] or [micro-radians];   R ωa   b  is the accelerometer misalignment matrix [rad] or [micro-radians];   b o  is the gyroscope bias vector [deg/hr] or [rad/sec],   w b     o    is the bias white noise [deg/hr] or [rad/sec] and   β b  are the coefficients of the self-calibration parameter SDE [inverse of correlation time in seconds or hours for a 1 st  order Gauss-Markov (GM)];   b a  is the accelerometer bias vector [micro-g] or [m/s 2 ], w b     a    is the bias white noise [micro-g] or [m/s 2 ] and   α b  are the coefficients of the self-calibration parameter SDE [inverse of correlation time in seconds or hours for a 1 st  order GM];   s o  is the gyroscope scale factor vector (unlit less or ppm), w s     o    is the bias white noise and (unit less or ppm) β s  are the coefficients of the self-calibration parameter SDE [inverse of correlation time in seconds or hours for a 1 st  order GM];   s a  is the accelerometer scale factor vector, w s     a    is the bias white noise and α s  are the coefficients of the self-calibration parameter SDE (same units as for s o );   m o  is the gyroscope misalignment vector [rad] or [micro-rad], w m     o    is the bias white noise [rad] or [micro-rad] and β m  are the coefficients of the self-calibration parameter SDE [inverse of correlation time in seconds or hours for a 1 st  order GM];   m a  is the accelerometer misalignment vector, w m     a    is the bias white noise and α m  are the coefficients of the self-calibration parameter SDE (same units as for m o ).       

     It has been assumed that the calibration parameters follow a first order GM stochastic model and that the clock bias rate is a constant (only estimated in the filtering). 
     On the other hand, the predicted errors are computed through the transition matrix:
 
Φ=exp(Δ tF )
 
     That assumes F to be a constant matrix for small time intervals (Δt). 
     The predicted state vector computed through numerical methods for resolving the differential equations shown above and the predicted covariance is computed through the multiplication of the transition matrix with the previous known covariance matrix and the process noise matrix (Q k−1 ):
 
 P   k   − =Φ k   P   k−1   + Φ k   T   +Q   k−1  
 
     Once the prediction has been performed (through solving the navigation equations), and provided an observation update, the KF gain is:
 
 K   k   =P   k   −   H   k   T   [H   k   P   k   −   H   k   T   +R   k ] −1  
 
     And the corrected estimated state variables and covariance matrix:
 
 X   k   +   =X   k   −   K   k   [Z   k   −H   k   h   k ( X   k   − )] −1  
 
 P   k   +   =P   k   −   −K   k   H   k   P   k   − 
 
R is the measurement noise matrix and Q the process noise matrix that need to be adjusted and tuned for a possible realization of the invention. The high fidelity model is used in the measurement prediction that are also required to generate the Jacobian matrix (Extended Kalman Filter). The use of Galileo signal affects the Jacobian differently than, helping to improve filter stability. Furthermore the tracking is performed on the carrier errors, thus as long as it is kept under the GNSS signal wavelength the KF will be able to operate normally. The tracking of the code contributes to a more robust tracking and in case the phase carrier tracking is lost, due to, for example, excessive noise, it can still be possible to keep the code tracking as so the KF is prepared for such possibility.
 
     In this description the equivalent noise bandwidth of the filter is now intrinsically and optimally adjusted by the KF and not the PLL and DLL filters, thus depending on the KF implementation and also the measurement models employed within. 
     Since optimum lock detectors are very important to minimise the time between a signal lock loss and a loss of lock alert, and therefore, to reduce the re-acquisition times and to increase the availability of navigation, a different type of lock detector is required to allow operating in scenarios where the incoming signal strength is below the usual, only possible in the highly integrated receiver. For this a lock detector using the VE-VL part of the invention. 
     The VE-VL lock detector compares the Prompt correlator output with the VE-VL correlator outputs, to decide if signal is present. The main advantage of this method is that, after convergence is achieved, the signal power is compared with a noise-only reference. Thus, the reference noise floor can be estimated more precisely than for other classical techniques. Let Ii and Qi be the real and imaginary parts of the corresponding correlator output. The wide-band power of the k measurement, WBP(k), computed over M samples is given by: 
     
       
         
           
             
               WBP 
               k 
             
             = 
             
               
                 ( 
                 
                   
                     ∑ 
                     
                       i 
                       = 
                       1 
                     
                     M 
                   
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   
                     ( 
                     
                       
                         I 
                         i 
                         2 
                       
                       + 
                       
                         Q 
                         i 
                         2 
                       
                     
                     ) 
                   
                 
                 ) 
               
               k 
             
           
         
       
     
     The decision criterion is based on comparing the WBP values of the Prompt output with the WBP values of the VE-VL output multiplied by a constant (KTH). 
     The demodulator  110  is responsible for detecting and demodulating navigation data bits and also by the wipe-off of the changes in signal due to bit transition so these do not affect the Hi-Gi navigator operation. 
     The Hi-Gi navigator comprises furthermore the integer fix and pre-processing component. The pre-processing applies corrections to account for errors due to satellite to user signal propagation such as ionosphere using navigation data for that purpose. The navigation data is transmitted by the GNSS satellites and therefore can be obtained either internally by the terminal or provided externally by some system communicating with the receiver. This data can be in the case of GPS DGPS and in the case of Galileo local elements providing differential corrections or other type of aiding data. Additionally the pre-processing module could also perform smoothing of code with carrier phase. The integer fix function is required since in some cases the KF may not be able to track the incoming signal and therefore the measurements of carrier phase can be contaminated in an unknown error that requires to be fixed using widely know methods. 
     In this description the INS and the GNSS data are highly integrated allowing enhanced navigation performance, in the sense that the GNSS I and Q data are processed in the same filter where the inertial sensor is. The INS is implemented within the KF, where the numerical integration of inertial raw data occurs and numerically solving the differential equations integrated within the inertial navigation equations. This requires the inclusion of a model of the inertial sensor that includes parameters such as drift, bias and misalignment which are also an output of the KF. As soon at the state vectors are updated, by accumulating the successive epoch of the outputs of the filter, it is possible to determine the relative user-satellite dynamics that is used to feedback to the code and carrier tracking. In order to determine satellite positions and velocity, the Hi-Gi requires navigation data. When the lock detector signals a loss of lock, the feedback signal is computed even without GNSS data, relying only on inertial sensor, thus still aiding the code tracking. 
     The detailed descriptions provide before can be implemented in as software computer program that can be subsequently stored and run on any computer device able to operate at the required high rates of the GNSS tracking stage, as example at 250 Hz. 
     The invention is limited by the allowed claims and therefore the before provided description should be regarded as illustrating the essentials that may be applied in different possible embodiments.