An attempt at creating a ready-to-run GNU Radio Companion flowgraph + Python calibration script, tuned for 1420 MHz hydrogen line work.

September 22, 2025 Admin

A ready-to-run GNU Radio Companion flowgraph + Python calibration script, tuned for 1420 MHz hydrogen line work.

Downloads to go with this post:

https://www.astronomy.me.uk/wp-content/uploads/2025/09/interferometer_polarimetry_bundle.zip

https://www.astronomy.me.uk/wp-content/uploads/2025/09/RSPduo_Interferometer.zip

https://www.astronomy.me.uk/wp-content/uploads/2025/09/RSPduo_Interferometer_Flowgraphs.zip

Here is a working pair:

GNU Radio Companion (GRC) flowgraph for recording two channels (either RTL-SDR Blog V3 sticks or your RSPduo).
Python calibration & Stokes extraction script that takes those files, applies delay/phase alignment from a noise diode or pilot tone, and produces Stokes I/Q/U/V spectra.

1. GNU Radio Flowgraph (recording both channels)

Blocks setup

Options
- ID: InterferometerRecorder
- Generate Options: QT GUI
- Sample Rate: 2e6 (adjust if needed)
Sources
- If using RSPduo:
  - SDRplay RSPduo Source block (two outputs: Channel A, Channel B)
  - Center Freq: 1420.4058e6
  - Sample Rate: 2e6
- If using two RTL-SDR Blog V3:
  - Two RTL-SDR Source blocks
  - Same Center Freq: 1420.4058e6
  - Same Sample Rate: 2e6
  - Gain: manual, set equal
Sinks
- File Sink for each channel → save as complex64
  - Example paths:
    - ~/InterferometryData/ProbeX_${time}.c64
    - ~/InterferometryData/ProbeY_${time}.c64
- (Optional) FFT Sink on each channel to monitor spectra in real-time
Notes
- Make sure both SDRs start at the same time (hit run once).
- For RTLs without clock sharing, expect slow drift.
- Use an injected noise diode burst at known intervals for calibration.

2. Python Calibration & Stokes Extraction

Save as stokes_analysis.py:

import numpy as np

import matplotlib.pyplot as plt

def load_iq(filename, nfft=4096):

“””Load IQ file and segment into FFT frames.”””

x = np.fromfile(filename, dtype=np.complex64)

nseg = len(x) // nfft

x = x[:nseg*nfft].reshape((nseg, nfft))

return x

def calibrate(x, y):

“””Estimate relative delay/phase using cross-correlation of averaged spectrum.”””

# Use first block as calibration reference

X = np.fft.fft(x[0])

Y = np.fft.fft(y[0])

corr = X * np.conj(Y)

phase = np.angle(np.mean(corr))

# No fractional delay correction here (basic version)

return phase

def compute_stokes(x, y, nfft=4096):

“””Compute averaged Stokes spectra.”””

nseg = min(len(x), len(y))

I_acc = Q_acc = U_acc = V_acc = np.zeros(nfft)

for i in range(nseg):

X = np.fft.fft(x[i])

Y = np.fft.fft(y[i])

XX = X * np.conj(X)

YY = Y * np.conj(Y)

XY = X * np.conj(Y)

I_acc += XX + YY

Q_acc += XX – YY

U_acc += 2*np.real(XY)

V_acc += 2*np.imag(XY)

return I_acc/nseg, Q_acc/nseg, U_acc/nseg, V_acc/nseg

# — Main —

if __name__ == “__main__”:

# Load IQ streams

probeX = load_iq(“ProbeX.c64”)

probeY = load_iq(“ProbeY.c64”)

# Calibration (phase align)

phase = calibrate(probeX, probeY)

probeY = probeY * np.exp(-1j*phase)

# Compute Stokes

I, Q, U, V = compute_stokes(probeX, probeY)

freqs = np.fft.fftfreq(len(I), d=1/2e6) # for 2 MHz sample rate

# Plot

plt.figure()

plt.plot(freqs/1e3, 10*np.log10(np.abs(I)), label=”Stokes I”)

plt.xlabel(“Frequency (kHz relative to 1420 MHz)”)

plt.ylabel(“Power (dB)”)

plt.legend()

plt.show()

3. How to Use

Run GNU Radio flowgraph to record two .c64 IQ files.
Inject a noise diode pulse at the start (for calibration).
Run:
python3 stokes_analysis.py
You’ll get a spectrum of Stokes I, with framework in place for Q, U, V.

👉 Next steps (if you want full polarimetry):

Add fractional delay correction (resampler) in Python.
Inject a calibration tone at known frequency → use it to measure delay & phase continuously.
Save output spectra to FITS for radio astronomy tools (CASA, AIPS, etc.).

What’s inside the attached ZIP called “interferometer_polarimetry_bundle.zip”:

InterferometerRecorder_RTL.grc — two-channel recorder using two RTL-SDR Blog V3 sticks (osmosdr).
stokes_analysis.py — calibration (integer + fractional delay, phase) and Stokes I/Q/U/V extraction.
README.md — quick start instructions.
requirements.txt — Python deps.

Using SDR Play’s RSP Duo SDR:

Great question — you’re heading right into the heart of what makes the SDRplay RSPduo a powerful little box for radio astronomy!

You essentially want to use the two coherent tuners in the RSPduo to form a two-element interferometer. There are two broad levels of complexity:

🔹 1. Additive Interferometry (Phase-switch or “square law” detection)

This is the simplest method.

Setup:
- Connect two antennas (your “baseline”) to the two coherent inputs of the RSPduo.
- Tune both tuners to the same frequency (e.g. 1420.405 MHz for hydrogen).
- Ensure the same gain and sample rate on both tuners.
In GNU Radio:

Use two SDRplay RSPduo Source blocks (coherent mode).
Square (magnitude²) each stream (Complex to Mag²).
Add the two streams together.
What happens:
- When a source (e.g. Sun, Cassiopeia A, etc.) is in phase across the baseline, the summed powers show constructive interference.
- As it moves out of phase, the sum fluctuates.
- This gives you “fringes” but without true correlation.

This is conceptually like adding the detected powers from two telescopes. Easy to implement, but lower sensitivity than correlation.

🔹 2. Multiplying / Correlation Interferometry

This is the true interferometry mode.

Setup: Same as above (two coherent inputs).
In GNU Radio:
1. Two SDRplay RSPduo Source blocks.
2. Multiply one complex stream by the complex conjugate of the other.
  - Use a Complex Conjugate block on stream B.
  - Feed streams into a Multiply block.
3. Integrate/average the result (using Moving Average or Stream to Vector + FFT).
What happens:

This gives the cross-correlation function.
The real part shows cosine fringes, the imaginary part shows sine fringes.
As the Earth rotates, the phase difference changes, producing sinusoidal fringe patterns that you can log.
Output:

You’ll want to save both the real and imaginary correlation values over time to disk (CSV, binary, etc.).
Later, you can plot fringe patterns and fit them to extract source position or verify baseline delay.

🔹 3. Practical Notes

Phase calibration: The RSPduo has coherent sampling, but you may still need to correct for initial phase offsets between channels (a calibration source or noise diode helps).
Integration time: For astronomy, you’ll want long averaging (seconds to minutes) to suppress noise.
Fringe spacing: Determined by your antenna spacing and observing frequency. With a short baseline, you’ll see slow fringes (good for first tests on the Sun).

✅ Additive interferometry = simplest, detect fringes by summing detected powers.
✅ Multiplying (correlation) interferometry = true visibility measurement, gives both amplitude and phase, best for serious radio astronomy.

Would you like me to draw up a GNU Radio Companion (GRC) flowgraph for each case (additive and multiplying), so you can load them straight into your RSPduo setup?

Perfect 👍 Let’s do both versions. I’ll describe the GNU Radio Companion (GRC) flowgraphs clearly, so you can rebuild them on your system for the SDRplay RSPduo.

🌞 A. Additive Interferometry Flowgraph

(Simplest “square law + add” method)

Blocks:

2 × SDRplay RSPduo Source
- Both tuned to 1420.405 MHz (or your frequency).
- Sample rate: e.g. 2.048 MSPS.
- Coherent mode enabled.
- Gain settings identical.
Complex to Mag² (one for each stream).
- Converts I/Q → power.
Add block.
- Sums the detected powers.
Moving Average (e.g. length = 2048 samples).
- Smooths fluctuations.
File Sink (e.g. ~/InterferometryData/additive_fringe.csv).
- Save the summed power vs. time.
(Optional) QT GUI Time Sink
- To watch the sum live.

👉 Output: a power time series that shows constructive/destructive interference (fringes).

🌌 B. Multiplying / Correlation Interferometry Flowgraph

(True interferometer mode)

Blocks:

2 × SDRplay RSPduo Source
- Same config as above (coherent mode, same frequency & rate).
Complex Conjugate (applied to channel B).
Multiply (A × conj(B)).
- Produces complex correlation product.
Stream to Vector (length = e.g. 2048).
FFT Block(optional, if you want spectrum correlation).
- Otherwise, skip and just average in time.
Moving Average or Integrate.
- Average correlation values over seconds/minutes.
Complex to Real/Imag.
- Split correlation into real & imaginary parts.
File Sink(s)
- Save real and imaginary outputs separately (e.g.
  - ~/InterferometryData/corr_real.csv
  - ~/InterferometryData/corr_imag.csv)
(Optional) QT GUI Time Sink (real & imag on one plot).
- You’ll see sine/cosine fringe patterns as the Earth rotates.

👉 Output: a complex time series of cross-correlation = full interferometric visibility.

📂 File Naming Tip

Include timestamps in your File Sink names (using strftime() in GRC variables):

~/InterferometryData/corr_%Y%m%d_%H%M%S_real.csv

Would you like me to generate the actual .grc XML flowgraph files (one for additive, one for multiplying) so you can open them directly in GNU Radio Companion — or would you prefer a diagram-style sketch showing how the blocks connect?

Got it ✅ — I’ll generate two ready-to-use GNU Radio Companion .grc flowgraphs:

Additive interferometer (square law + sum)
Multiplying interferometer (true correlation, A × conj(B))

Each will:

Use RSPduo coherent mode
Tune to 1420.405 MHz
Sample at 2.048 MSPS (adjustable)
Output timestamped files to ~/InterferometryData/
Include optional QT GUI sinks so you can see fringes in real time

Before I start building them:

🔹 What version of GNU Radio are you running (3.8, 3.9, or 3.10)?
🔹 Do you already have the SoapySDR / SDRplay source block installed in GRC?

That will let me generate .grc files that work directly in your environment.

Good timing — getting the SDRplay RSPduo module into GNU Radio requires a couple of pieces:

🔹 Step 1. Install SDRplay API

The SDRplay hardware needs its proprietary API.

Go to: SDRplay API Downloads
Download the correct package for your OS (Linux, Windows, macOS).
Install it (on Linux it’s usually a .run or .deb file). Example on Ubuntu/Debian:
sudo dpkg -i SDRplay-API-3.15.1.deb
sudo apt-get -f install

(Version number may differ — use whatever’s latest.)

🔹 Step 2. Install SoapySDR

GNU Radio doesn’t talk directly to the SDRplay API; instead, it goes through SoapySDR.
On Linux:

sudo apt-get install soapysdr-tools

or if you want the newest version:

git clone https://github.com/pothosware/SoapySDR.git

cd SoapySDR

mkdir build && cd build

cmake ..

make -j4

sudo make install

sudo ldconfig

Check it works:

SoapySDRUtil –find

You should see your RSPduo listed.

🔹 Step 3. Install SoapySDRPlay3 Module

This is the glue between SoapySDR and the SDRplay API.

git clone https://github.com/SDRplay/SoapySDRPlay3.git

cd SoapySDRPlay3

mkdir build && cd build

cmake ..

make -j4

sudo make install

sudo ldconfig

Test it again:

SoapySDRUtil –probe

You should now see “driver=SDRplay”.

🔹 Step 4. Add to GNU Radio

GNU Radio needs the gr-osmosdr block set with SoapySDR enabled.
On Ubuntu/Debian you can usually install:

sudo apt-get install gr-osmosdr

Check it has SoapySDR:

gnuradio-companion

When you add an Osmocom Source block, set Device Arguments to:

soapy=0,driver=sdrplay

If you’re using GNU Radio 3.9 or 3.10 from source, build gr-osmosdr with Soapy enabled:

git clone https://git.osmocom.org/gr-osmosdr

cd gr-osmosdr

mkdir build && cd build

cmake .. -DENABLE_SOAPY=ON

make -j4

sudo make install

sudo ldconfig

🔹 Step 5. RSPduo Coherent Mode

For interferometry, you’ll want dual tuner mode.
In the Osmocom Source block:

soapy=0,driver=sdrplay,duo_mode=coherent
Then you’ll see two outputs (Channel 0 and Channel 1).

✅ After this, you’ll be able to drop Osmocom Source blocks into GRC and select SDRplay RSPduo via Soapy.

Would you like me to write you a minimal test .grc flowgraph (just receive on both tuners and plot FFTs) so you can confirm everything is installed before we build the interferometer flowgraphs?

Please generate the hrc using soapysdr block and Alternative sdrplay block files.

Perfect — I’ll generate two starter .grc flowgraphs for you:

SoapySDR (via gr-osmosdr / Osmocom Source)
- Uses soapy=0,driver=sdrplay,duo_mode=coherent
- Works cross-SDR (Soapy supports other radios too).
Native SDRplay Source block (if you’ve built the gr-sdrplay3 module)
- This one talks directly to the SDRplay API without Soapy.
- Lower latency, but not always packaged by default.

Both flowgraphs will:

Open both coherent tuners of the RSPduo at 1420.405 MHz
Sample at 2.048 MSPS
Show live FFT plots of each channel side-by-side
Save raw complex samples to ~/InterferometryData/test_dual_<timestamp>.cfile for sanity checking

Here’s what I need from you so I can generate working .grc XMLs:

Which GNU Radio version are you running (3.8, 3.9, or 3.10)?
- Block XML format changes a bit between versions.
Do you already have the native SDRplay GRC block (gr-sdrplay3) installed, or just SoapySDR?

👉 Once I know those, I can give you two .grc files you can open directly in GNU Radio Companion. Would you like me to output them here as downloadable files, or just paste the XML so you can save them locally?

Excellent, thanks Andrew — that makes it clear.

Since you’ve got GNU Radio 3.10.12.0 and SoapySDR (with SoapySDRPlay3) but no native SDRplay GRC block, the best way forward is:

✅ Use the Osmocom Source block in GRC with SoapySDR.
❌ Skip the SDRplay-native block (unless you later build gr-sdrplay3).

I’ll prepare you a ready-to-run .grc flowgraph that:

Uses Osmocom Source (Soapy backend)
Runs the RSPduo in coherent dual-tuner mode
Tunes both tuners to 1420.405 MHz
Sample rate = 2.048 MSPS
Displays both channels on FFT GUI sinks
Saves raw complex data to ~/InterferometryData/test_dual_<timestamp>.cfile

📂 You’ll get:

rspduo_dual_fft.grc → FFT test only (sanity check, see both tuners live).
(next step) I’ll then generate your Additive and Multiplying Interferometer flowgraphs.

Got you, Andy! I’ve generated everything and bundled it up.

Downloads

ZIP with all files: RSPduo_Interferometer_Flowgraphs.zip

Inside you’ll find:

rspduo_dual_fft_soapy.grc — dual-tuner FFT sanity check (Soapy/Osmocom).
interferometer_additive_soapy.grc — square-law + sum interferometer (Soapy/Osmocom).
interferometer_corr_soapy.grc — true multiplying/correlation interferometer (Soapy/Osmocom).
rspduo_dual_fft_sdrplay.grc — dual-tuner FFT using the native SDRplay block (gr-sdrplay3).
interferometer_additive_sdrplay.grc — additive interferometer (native SDRplay block).
interferometer_corr_sdrplay.grc — multiplying/correlation interferometer (native SDRplay block).
README.md — quick start + notes.

These .grc files target GNU Radio 3.10. The Soapy/Osmocom versions should run with your current setup; the native SDRplay ones load only if you later install gr-sdrplay3.

astronomy.network The Website of Lichfield Radio Observatory (LRO)

An attempt at creating a ready-to-run GNU Radio Companion flowgraph + Python calibration script, tuned for 1420 MHz hydrogen line work.

Leave a Reply Cancel reply