Late July 2019, Galileo, “the European GPS” suffered from a week long outage. I’m a proud European, and I think we should have our own well-functioning navigation system, so I tried to figure out what was going on. Surely someone was monitoring this stuff in public? I come from the internet where we monitor all the things, if someone asked for it or not.

This led me on a journey to monitor Galileo, but quickly also GPS, the Russian GLONASS and Chinese BeiDou systems. Along the way, I found out out how positioning satellites really work. This also helped me understand what went wrong with Galileo, more about which later.

In this post, I want to share what I learned, firstly because it is fascinating, but secondly because it serves as documentation of what the monitoring website “galmon.eu” is actually showing.

Galmon, which we should really rename to Navmon, is a lot like the RIPE Atlas Probes, but then for space. Based on a network of volunteers literally around the world, we monitor the output of each and every navigation satellite and make the results openly available as a pretty website, JSON but also as raw data (messages). Galmon is GPL licensed open source and lives on GitHub. //

How do navigation satellites work?

Let’s imagine we launch a bunch of metronomes, musical devices that tick at a precise frequency. We’ll make them tick precisely once a second and, unlike a regular metronome, we’ll also make them tick exactly on “whole seconds”. So they emit a tick at 0 seconds past the hour, 1 second past the hour etc, one tick every second, on the second.

We put the metronomes in different orbits around the earth, so at any time, some of them are further away than others. Then, we listen to their ticks, which are conveniently transmitted over radio.

Because of the speed of light, a metronome that is 30000 km away will send out its tick on a whole second, but it will arrive with us 100 milliseconds later. A metronome that is closer to us, say 25000 km, will have its tick arrive slightly earlier. These differences are large enough that if we would put the ticks on a loudspeaker we could hear the difference.

Because we can measure the precise delay, we can tell exactly how far away each satellite is from us. In itself however, this does not help us determine our location, because we don’t know where the metronomes are! //

In two dimensions, we only need two satellites to do this, assuming we already had an accurate clock that also ticks once a second, on the second. In three dimensions, we need three satellites ticking away at us.

(Note that in the figure above, we could also be in a second position where the circles intersect - we can rule out that solution by assuming we are not actually in space ourselves).

But, at a very elementary level, this is how GNSS works: satellites tell us where they are, and they send out a ‘tick’ exactly every second (and on the second), and by timing how late that tick is in arriving at our location, we know how far away the satellite is. And by drawing some circles (actually spheres), we can discover where we are. This technique is called multilateration.

What if we don’t have an accurate clock?

We want to use GNSS to figure out where we are, even if we aren’t dragging an accurate clock with us. The speed of light means that for every nanosecond that we get our clocks wrong, our position will be off by 30 centimeters. Nanosecond accurate clocks are delicate machines that do not fit in phones.

Luckily, through some clever math, it is possible to use the satellites themselves as an accurate clock - to do so, we do need an additional satellite and a guess of the time. Such a guess could be derived by taking the average of all GNSS clocks received combined with a rough knowledge how how far away such a satellite could be. Armed with this rough guess, we might end up with:

Note that the three circles do not all cross in a single point. Because our rough clock estimate was wrong (let’s say it runs late a bit), all satellites appear to be a little bit further away than they actually are. Or in other words, all the circles are a little bit too big, causing them not to intersect in one point.

A receiver can based on this observation adjust its internal clock until all circles intersect in one point:

Once this happens, we know that the correct time has been derived.