The Goal

The Russian satellite Meteor M2-3 recently launched, following the premature failure of Meteor M2-2. It broadcasts "high quality" digital photos of Earth from space, unencrypted for anyone to recieve. Ideally our goal is to recieve these images and get a view of Earth from directly above!

Example image credit to @enzobecamel

Challenges

  • Signals from satellites are coming from far away, and thus not super strong
  • There is not a ton of information to guide us on this journey
  • Most SDR software is built for Windows or Linux, but I'm using an aarch64 Mac
  • I have no experience with radios or signal processing

Let's get started!

Design, Test, Refine

The basic pipeline of science and engineering is to design a prototype, test it, and refine it around problems found. Let's design our basic prototype.

  1. We use some kind of tool to find out when and where the satellite will pass overhead
  2. We recieve the signal using a software defined radio
  3. We interpret that signal using computer algorithms
    • We need to isolate the signal from background noise
    • We need to extract the data contained within this signal
    • We need to correct as much error as we can from this data
    • We need to analyse the data to get an image

Finding Satellite Passes

Introducing: gpredict!

This piece of FOSS software can help us find when satelites are next going to be overhead, and where they'll show up in our sky.
Installing is pretty easy, regardless of platform. I used brew.

> brew install gpredict

When you launch gpredict you should get a result that looks something like this:

example image of gpredict

Example image credit to csete, gpredict homepage

We can use this software to see the current position of our target satelites over the earth, the times of future passes, and the position in the horizon a passing sattelite occupies.

Eventually we'll use this to find our satellite passes. For now, we'll just remember that it's here.

Getting a Signal

So, we know when and where our target will be, but we need a reciever. Almost any SDR will do, I've heard good things about the RTL-SDR which seems inexpensive and effective. I'm using the much more expensive HackRF, since I intend to do other projects with it that require a wider range of frequencies.

We plug our SDR in and... Nothing. Well, we didn't really expect anything, but it's still a little disapointing! We can't expect to build everything without knowing if any of it works.

The Solution

The SDR ecosystem is built on the idea of doing multiple "passes" with one set of data. For example:

  1. Collect samples
  2. Demodulate samples to data
  3. Interpret and correct data

These could all be seperate programs that don't know anything about eachother. This allows us to start by replacing small parts of the process and verifying that our replacements work before putting it all together.

This post is getting long, so let's set our goal much lower for today: can we listen to some FM radio using just some FOSS software and our SDR?

Listening to Some Tunes

To listen to radio, we'll use GQRX as our tuner and interpreter. It can do a lot more than this, but this is all we need it for today!

Running GQRX prompts to select an SDR and then presents the following window:

example image of gqrx

Let's take inventory.

  • In the top left, there's a play/stop button for turning on and off our radio.
  • Just below our top left icons, we have a frequency indicator/tuner
  • On the right we have menus for adjusting our input and output
  • In the center we have a "waterfall" and a "panadapter"

Okay. Let's get started. In the right panel, we'll TODO set interpret mode set freq enable radio fine tuning dc offset

What's Next?

In the next post, we'll look at some of the ecosystem around SDRs in Rust and make our own naïve version of GQRX. Until next time!