Introduction

The Galileo High Accuracy Service (HAS) is providing Precise Point Positioning (PPP) corrections enabling decimeter-level accuracy (EUSPA 2023). The corrections, which are mainly disseminated through the E6B Signal-in-Space (SIS), are also available for registered users through a dedicated Internet channel (EUSPA 2023b), making HAS accessible to a wider range of receivers without requiring the processing of the E6B signal.

The HAS corrections distributed through the E6B signal are encoded using a high-parity vertical Reed-Solomon (RS) code (Fernández-Hernández et al. 2020). The original HAS message pages are vertically stacked and multiplied by the Reed-Solomon encoding matrix. In this way, a new redundant set of pages is obtained. Each Galileo satellite broadcasts a subset of such pages. The properties of Reed-Solomon codes guarantee that any subset of K different pages can be used to reconstruct the original HAS message. Here, K is the size in pages of the original HAS message. The encoding and dissemination scheme adopted by the HAS reduces the Time-to-Retrieve Data (TTRD) (Borio et al. 2020) and improves the reception performance, owing to the redundancy introduced by the Reed-Solomon encoding scheme.

The recovery of the HAS corrections requires inverting the encoding scheme and interpreting the decoded bits. Details on the HAS encoding scheme and correction format can be found in the HAS Interface Control Document (ICD) (European Union, 2022) published by the European Space Programme Agency (EUSPA).

To facilitate the adoption of HAS corrections, HAS correction decoders have been developed (Gioia et al. 2022 and Horst et al. 2022). Both decoders provide a Python implementation of the processes needed to recover the HAS corrections from the raw E6B symbol stream obtained using, for instance, a high-end receiver such as the Septentrio PolaRx 5.

Horst et. al. (2022) developed the HASlib, which supports only the processing of Septentrio Binary Files (SBF). HASlib code is available open source in GitHub (https://github.com/nlsfi/HASlib) and can convert HAS corrections into the RTCM 3 or the International GNSS Service (IGS) State-Space Representation (SSR) formats (Hirokawa et al. 2021, IGS 2020), which are directly supported by some open-source PPP software.

In parallel, the authors developed a Python HAS decoder that was used for several analyses (Gioia et al. 2022), including the assessment of the HAS demodulation performance at high-latitudes (Susi et al. 2021). While the basic functioning and architecture of the decoder were described in (Gioia et al. 2022), the related code was never published open source. In this paper, we describe the latest version of the HAS decoder introduced in (Gioia et al. 2022) that is now provided open source and available under the GPSToolbox repository and in GitHub (https://github.com/borioda/HAS-decoding). With respect to the version used in Gioia et al. (2022), the software has been enriched by several functionalities including the support to several receiver formats, a Graphical User Interface (GUI), plotting capabilities and the possibility to evaluate the Allan Deviation (ADEV) from the clock corrections.

The decoder developed in this context is denoted as GHASP, a Galileo HAS Parser. With respect to the version described in (Gioia et al. 2022) and to HASlib, additional input data formats are supported including Septentrio SBF, Javad and NovAtel raw data.

The decoder features a simplified GUI provided as a Python Jupyter notebook (https://jupyter.org/). Exploiting the GUI, the decoder can be operated in a easier and more intuitive way.

Differently from HASlib, corrections are saved into four Comma-Separated Values (CSV) files containing the four different correction types: orbit corrections, clock corrections, phase and code biases. This choice has been adopted in order to simplify the access to the corrections, which can be directly loaded, without any additional parsing operations, using any data-science language, such as Matlab, Python or R. In this way, HAS corrections can be directly plotted, analysed and included in customized navigation software. For instance, HAS clock corrections can be directly used for estimating the ADEV of the corresponding satellite. This possible application is briefly discussed in the following.

The remainder of this article is organized as follows: the architecture of the code is first described. The user interface, input and output data are then introduced. Some use cases are briefly discussed before the conclusions.

Architecture of the code

The overall architecture of GHASP is presented in Fig. 1: core elements are represented by grey boxes, whereas GUI modules are depicted as blue boxes.

Fig. 1
figure 1

Overall architecture of GHASP. Grey boxes represent core elements, whereas blue boxes indicate GUI elements

Full size image

The main processing loop is implemented in the “process_cnav.py” module, which contains the parse_data() function and a main routine that can be modified, for example, to implement batch processing, i.e. the processing of several input files. The parse_data() function is also called by the “has_widgets.py” module, which implements the different graphical elements used by the Jupyter notebook GUI, whose use is briefly described in the next section.

The parse_data() function loads the different input files using the functions available in the “data_loading” module and instantiates a “has_decoder” object, which is responsible for the different decoding operations. The decoder has a list of HAS messages that are progressively decoded. Reed-Solomon decoding is performed in the “has_message” module.

Messages are converted into corrections: four correction types are currently supported and correspond to the four HAS correction types currently described into the HAS ICD (European Union, 2022). Each correction type has been implemented as a separate class. In this respect, the code features a flexible object-oriented structure and can be easily extended to support additional correction types. A description of the base correction class and its four derived classes can be found in (Gioia et al. 2022).

In addition to the four correction classes, a “mask” class has also been implemented. It is used to process and store the information broadcast into the mask field of the HAS message.

Using the different objects described, GHASP can parse different input data files and extract the corresponding HAS corrections.

User interface, supported data and output format

As indicated above, a simple GUI, implemented as a Jupyter notebook, was developed to facilitate the use of GHASP. A screenshot of the GUI is shown in Fig. 2: parsing HAS corrections from receiver raw data can be performed in a few simple steps. First, the required Python libraries are loaded, then the user is asked to choose the input file containing the raw E6B bits. This is done through the Python FileChooser() widget that opens a pop-up window allowing the selection of the input file. Several data formats are supported including:

  • Septentrio binary and parsed data

  • Javad raw data

  • NovAtel raw data.

Fig. 2
figure 2

Screenshot of the Jupyter notebook developed to simplify the user interaction with the HAS decoder

Full size image

Figure 2 shows the widgets allowing the user to specify the input format. A dropdown menu allows one to select the receiver type, in the example Septentrio. Following the receiver selection, additional options are prompted. For the Septentrio case, different options are available including binary SBF files or converted data. Septentrio receivers are shipped with conversion tools that allow one to convert SBF files into text files. Depending on the version of the Septentrio conversion tool, E6B data can be parsed into decimal or hexadecimal formats. GHASP supports both formats and the different options can be selected through the GUI. After setting the input file and format, data parsing and decoding can start. This action is triggered by the “Parse” button visible at the bottom of Fig. 2.

In addition to the Jupyter notebook, it is possible to parse data by directly modifying the “process_cnav.py” script. As discussed above, this Python script calls the main function of the GHASP library and performs the same operations available through the Jupyter notebook.

As already mentioned, the output of the parser is a set of four CSV files, one for each type of correction. The different columns of the CSV files are described in the related header and include the Time of Week (ToW), the Week Number (WN) and the Time of Hour (ToH). Each field corresponds to the different elements described in the HAS ICD (European Union, 2022).

Detailed information of the structure of the output CSV files can be found in the GHASP user manual (Borio et al. 2023).

Data processing: examples

In addition to the core library, the GHASP library is provided with simple plotting routines that can be used to display and analyse the different corrections. In the following, data extracted from a Septentrio SBF file are displayed. The dataset is from October 20th, 2022. While only results for Galileo satellites are presented, the same kind of plot can be produced for the GPS case as well. Additional sample plots can be found in the GHASP user manual (Borio et al. 2023).

Figure 3 shows the corrections broadcast by the HAS service for the different Galileo satellites on October 20th, 2022. The HAS orbit corrections are expressed with respect to the radial, tangential (along track) and normal (cross-track) components of the Satellite Coordinate System (SCS) centred into the satellite’s ionosphere-free antenna phase centres (European Union, 2022) that are the E1-E5b and L1- L2C phase centres for Galileo and GPS, respectively. The time series displayed in three different subplots are zero mean and assume amplitudes lower than one metre. As detailed in (European Union, 2022), the orbit corrections, after a conversion into the broadcast Earth Centred Earth Fixed (ECEF) frame, have to be added to the satellite position computed from the broadcast data.

Fig. 3
figure 3

The three components of the orbit corrections broadcast by the HAS service for the different Galileo satellites. Corrections for the whole day of October 20th, 2022

Full size image

The time series of the corresponding Galileo clock corrections are shown in Fig. 4. Also in this case, the time series have a nominal behaviour with a zero-mean value. The HAS clock corrections are provided in metres, and after conversion in seconds, must be added as delta offset to the broadcast ionosphere-free clock offset (European Union, 2022).

Fig. 4
figure 4

Clock corrections broadcast by the HAS service for the different Galileo satellites. Corrections for the whole day of October 20th, 2022

Full size image

The clock corrections can be used to compute the ADEV, which quantifies the stability of the clock corrections.

A sample plot showing the overlapping ADEVs for the different Galileo satellites is provided in Fig. 5.

Fig. 5
figure 5

Overlapping ADEV computed using the clock corrections broadcast by the HAS service for the different Galileo satellites. Corrections for the whole day of October 20th, 2022

Full size image

Routines for plotting code and carrier phase biases are also provided as part of GHASP. Sample plots for the code and carrier phase biases can be found in the GHASP user manual (Borio et al. 2023).

Conclusions

A library for parsing Galileo HAS corrections from different receiver files containing the E6B navigation message in binary format has been developed. The parser allows one to experiment with the Galileo HAS corrections. A simple GUI facilitates the usage of the parser and the configuration of the different options. The parser is shipped with routines for plotting the parsed corrections and demonstrating operations such as the computation of the ADEV for the different corrected satellites.