Gr-leo is a GNU Radio Out-of-Tree module [1] that simulates the telecommunication channel between orbiting satellites and Ground Stations.
Telecommunication systems are affected by a plethora of impairments imposed from the wireless channel. The development, debugging and evaluation of such systems should be performed under realistic channel conditions, that are difficult to be simulated on the lab. This prerequisite becomes even more crucial in the case of satellite missions. GNU Radio provides a variety of channel estimation blocks that however cannot be used efficiently for the purposes of a space telecommunication channel.
Gr-leo aspires to fill this gap with the implementation of a GNU Radio module that simulates the operation of an Earth-Satellite system and a variety of impairments that my occur during the space channel communication. For example, frequency shift due to the Doppler effect, the variable path loss due to the satellite's trajectory or the atmospheric effects along the path are proven to pose significant degradation on the communication channel.
The gr-leo module is written in C++ and follows the block-programming notion of GNU Radio. More specifically, it divides its implementation into different processing blocks that simulate each one of the different components of the space channel communication system. These blocks, that are also available through the GNU Radio Companion, can be combined appropriately with the existing built-in processing blocks of GNU Radio. The architecture of the gr-leo module is presented graphically in Figure 1. Below, there is a description of the blocks provided by gr-leo.
The channel model block is implemented as a GNU Radio synchronous block and accepts as a parameter a channel model definition. The main task of this block is to appropriately pass the signal from its input port to the worker function of the channel model definition, alongside with a pointer to its output buffer, for as long as the satellite observation lasts. In addition, there is the possibility to tune the noise-floor of the communication channel by adding white Gaussian noise of predefined power. Finally, an optional message port that outputs logging information in CSV format exists.
Fig 2. A GRC flowgraph that contains the channel model block.
Channel model definitions are the heart of gr-leo, as they link the different components that constitute the Earth-space communication system in a single GNU Radio variable block. More specifically, a channel model block accepts a list of required parameters, such as the Earth ground station tracker, an option that defines the transmission mode (downlink or uplink) and a series of other options that describe the specific impairments that will be taken into account at the channel simulation.
As regards to the implementation, every model definition block is described by a C++ class that extends the generic_model parent class and must implement the pure virtual generic_work function. The generic_work function is called by the channel model block, appropriately manipulates the input signal and writes the resulting signal to the output buffer.
The Earth-based ground station is represented in gr-leo, as an instance of the Tracker class. It holds parameters for all the required information to fully describe a ground station tracking an orbiting satellite, such as:
- the satellite object of interest
- the ground station's coordinates (Latitude, Longitude and Altitude)
- the operating TX/RX frequencies
- the TX/RX antenna objects
- the observation timeframe in ISO-8601 UTC format
- the observation time resolution in us
Moreover, the Tracker class is responsible to appropriately call the API of C++ SGP4 [2] for Two-Line-Element (TLE) [3] parsing and every calculation that is required to obtain orbit specific information (i.e distance from ground station, velocity etc).
A satellite is represented in gr-leo, as an instance of the Satellite class. It holds parameters for all the required information to describe an orbiting satellite, such as:
- the TLE that describes the orbit
- the satellite's operating TX/RX frequencies
- the TX/RX antenna objects
Different types of antennas are taken into consideration by gr-leo, including yagi, helix, quadrifilar helix, monopole, dipole, parabolic reflector and custom. Each one is described by a C++ class that extends the parent generic_antenna and appropriately implements the pure virtual functions get_gain, get_beamwidth, get_rolloff_gain. In addition, each class accepts different parameters and may implement various functions, based on the corresponding type.
The AMSAT-IARU Link Mοdel spreadsheet [4] is used as a reference for the calculation of the gain, beamwidth and roll-off gain for each of the antenna types.
For use in the GNU Radio companion, the antenna is represented with a GNU Radio variable block, that is instantiated appropriately, based on the value of the "Type" dropdown. An example is show in Fig 6.
Fig 6. An example of different types of antennas shown in GRC
A transmission from a satellite to a ground station and vice versa may be subject to a variety of impairments. The relative motion of the orbiting satellite, the operating frequencies, the antenna setup of the telecommunication system and the various atmospheric phenomena are factors that significantly affect the performance of the communication.
In gr-leo, a variety of such impairments is taken into consideration and is included in the simulation of the space telecommunication channel. Knowing the exact position of the satellite on a specific observation timeframe, by taking advantage of the tracker class, gr-leo calculates each one of the impairments that are described below.
Every phenomenon that induces attenuation on a transmission through the space telecommunication channel is described by C++ class, that extends the generic_attenuation parent class. The generic_attenuation class has some static variables that are shared among the derived attenuation classes and hold information about:
- the operationg frequency of the system
- the elevation angle of the satellite at a given time instance
- the distance between the ground station and the satellite at a given time instance
A channel model definition declares the appropriate types of attenuation and calculates the total loss by summing up the returned value from the pure virtual method get_attenuation from each one of the derived classes.
The ITU recommendation P.619-3 [5] describes a formula to calculate the free-space path loss, the most basic form of attenuation assuming the complete radio path is in a vacuum with no obstruction. It depends only on the operating frequency
From the above formula we subtract the receiving and transmitting antenna gains
Attenuation on the transmitted signal through the Earth-space telecommunication channel is induced by the atmospheric gases absorption. Atmospheric absorption depends strongly upon the distribution of molecules along the path between the satellite and the ground station and is nearly insignificant for frequencies below 2 GHz. In gr-leo, this attenuation is implemented following:
- the method described in the Annex 1 of the ITU recommendation P.676-11 [6]
- the method described in Radiowave Propagation in Satellite Communications by Louis J. Ippolito Jr [7]
The loss due to precipitation in the transmission path is a major concern associated with the Earth-space communication systems, especially for operating frequencies above 5 GHz. Gr-leo follows the general method described in the ITU recommendation P.618-13 [8] to estimate the amplitude degradation due to heavy rainfall along the path. The method is dependent to :
- the point rainfall rate for the location for 0.01% of an average year
$R_{001}$ (mm/h) - the height above mean sea level of the earth station
$h_s$ (km) - the satellite elevation angle
$\theta$ (degrees) - the latitude of the earth station
$\phi$ (degrees) - the operating frequency
$f$ (GHz)
If there is local data, an option to provide custom value for
When a satellite orbits the Earth its relative distance from a ground station varies. Due to this variation of the relative distance, the receiver accepts the frequency of radio wave transmitted on the link with an apparent increase or decrease. This phenomenon is called Doppler effect and is dependent to the operating frequency
where
- GNU Radio ( > 3.8 )
- CMake ( > 3.8)
- G++ (with C++11 support)
- Boost C++ Libraries ( > 1.35.0 )
- VOLK
- SWIG
- C++ SGP4 Satellite Library ( 1.0 ) (will be automatically installed if not present)
sudo add-apt-repository ppa:gnuradio/gnuradio-releases
sudo apt-get update
sudo apt-get install gnuradio python3-packaging
After that you can install GNU-RADIO-LEO according to the Usage Manual https://librespacefoundation.gitlab.io/gr-leo/build_guide.html
git clone https://gitlab.com/librespacefoundation/gr-leo
cd gr-leo
mkdir build
cd build
cmake ../
make
sudo make install
sudo ldconfig
After building the GNU RADIO environment, you can open graphical operation interface
gnuradio-companion
You can open the example file for learning.
By default, the gr-leo module will use the default installation prefix.
This highly depends on the Linux distribution. You can use the CMAKE_INSTALL_PREFIX
variable to alter the default installation path.
E.g:
cmake -DCMAKE_INSTALL_PREFIX=/usr ..
Another common control option is the library sugffix of the Linux distribution.
There are distributions like Fedora, openSUSE, e.t.c that the their 64-bit version
use the lib64 folder to store the 64-bit versions of their dynamic libraries.
On the other hand, distributions like Ubuntu do the exact opposite. They use
lib directory for the libraries of the native architecture and place the 32-bit versions
on the lib32 directory. In any case the correct library directory suffix
can be specified with the LIB_SUFFIX variable. For example:
cmake -DLIB_SUFFIX=64 -DCMAKE_INSTALL_PREFIX=/usr -DINCLUDE_DEBUG_BLOCKS=OFF ..
will install the libraries at the /usr/lib64 directory.
Please mind the example GNU Radio flowgraphs that exist under the /examples directory.
For more information about gr-leo implementation, visit the Doxygen HTML pages here.
gr-leo module is implemented in the scope of SDR Makerspace, an initiative of the European Space Agency and Libre Space Foundation.
© 2018 Libre Space Foundation under the GPLv3.
