SDRplay RSPDuo & radio interferometry

September 27, 2025 Admin

Short answer — yes you can do radio interferometry with the SDRPlay RSPDuo software defined radio, but with caveats.

Downloads to go with this post mentioned in text below:

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

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

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

People have used the SDRplay RSPduo for small-scale radio interferometry experiments (and for diversity/noise-cancellation experiments that are a close cousin of interferometry). The device was explicitly designed with a dual-tuner architecture and a shared clock so those use-cases are possible — but real interferometry (fringe detection, phase imaging, VLBI-style work) requires careful setup, calibration, and sometimes extra hardware (GPSDO / external clock) and software workarounds. (SDRplay)

What people report in practice

Hobbyists and experimenters have used the RSPduo for diversity reception and for subtracting local interference (a form of coherent combining / nulling). There are several demos and writeups showing the RSPduo used with SDRuno, Linrad or custom GNU Radio flowgraphs. (rtl-sdr.com)
Several groups have posted starter kits / guides for doing offline correlation (save dual IQ streams, correlate in software) and for building GNU Radio flowgraphs that capture both channels and compute visibilities. That’s the usual hobbyist path because it’s simpler to debug offline first. (astronomy.me.uk)
Practical limitation: in dual-tuner (simultaneous) mode the per-tuner bandwidth is reduced (typically ~2 MHz), so you don’t get wide instantaneous bandwidth per channel. Also, while the RSPduo shares a master clock (so it can be phase/time coherent), some software stacks and USB transport can introduce phase/timing issues; users either use the built-in coherency plus careful calibration or add an external GPSDO/clock for best results. Expect to need calibration and careful software handling. (SDRplay)

What to expect if you try it

Good for: solar/Jupiter fringes, simple two-element interferometers, demonstrations of fringe patterns, diversity/nulling experiments, teaching projects.
Harder for: high-precision phase imaging, long-baseline VLBI, or anything needing very large instantaneous bandwidth or sub-degree phase stability without a GPSDO/external reference. (SDRplay)

Useful resources (I’ve looked these up for you)

SDRplay RSPduo intro/specs (hardware, clocking, dual-tuner mode). (SDRplay)
RTL-SDR / SDRplay demos of diversity & noise cancellation (practical demos you can replicate). (rtl-sdr.com)
GNU Radio + RSP workflow docs and community examples (how to capture both tuners and either correlate in real time or save IQ for offline correlation). (SDRplay)
GitHub / tools note (some projects treat the two streams as not fully phase-coherent and correlate magnitudes or do offline alignment). Useful when you hit phase/jitter problems. (Go Package Documentation)

If you like, I can immediately do one of these for you:

produce a ready-to-run GNU Radio Companion flowgraph that captures both RSPduo tuners, writes synchronized IQ files with timestamped filenames and a short example Python offline correlator to detect fringes (good starter route), or
draft a checklist for hardware (antenna spacing, GPSDO hookup, SDRuno / Linrad / GNU Radio settings) and calibration steps you can follow on-site.

Perfect — let’s go with option 1 (the “ready-to-run” starter route). I’ll prepare for you:

GNU Radio Companion (GRC) flowgraph for the SDRplay RSPduo
– Captures both tuners at 1420.405 MHz
– Stores synchronized complex64 IQ files with timestamped filenames
– Includes FFT display for monitoring
Example Python offline correlator
– Reads the IQ files from both tuners
– Performs cross-correlation to look for fringes
– Produces a simple time-lag correlation plot

1. GNU Radio Companion Flowgraph (RSPduo Interferometry Recorder)

Inputs: SDRplay RSPduo source (dual tuner mode)
Outputs:
- FFT Sink (for each tuner, real-time monitoring)
- File Sink (complex64, timestamped filenames)

Here’s the skeleton GRC block structure (I’ll provide the .grc XML if you’d like to drop straight into GNU Radio):

SDRplay RSPduo Source (Dual Tuner)
- Center frequency: 1420.405e6 Hz
- Sample rate: 31000.0 / 60 ≈ 516.67 sps (per your spec: 31k samples/minute)
- RF gain: set to manual, ~40 dB (adjust as needed)
- Tuner A → Stream 0
- Tuner B → Stream 1
Throttle blocks (only if testing without hardware)
FFT Sink (GUI)
- Show spectrum for each tuner in real time
File Sink (per tuner)
- Format: complex64
- Filenames:
- ~/InterferometryData/TunerA_${now:%Y%m%d_%H%M%S}.c64
- ~/InterferometryData/TunerB_${now:%Y%m%d_%H%M%S}.c64

This will produce matched IQ files.

2. Example Python Offline Correlator

Save as correlator.py and run with python correlator.py fileA.c64 fileB.c64.

import sys

import numpy as np

import matplotlib.pyplot as plt

def read_complex64(filename):

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

def cross_correlate(x, y, maxlag=2000):

# Normalized cross-correlation

corr = np.correlate(x, y.conj(), mode=’full’)

corr /= np.sqrt(np.sum(np.abs(x)**2) * np.sum(np.abs(y)**2))

lags = np.arange(-len(x)+1, len(x))

mid = len(corr)//2

return lags[mid-maxlag:mid+maxlag], corr[mid-maxlag:mid+maxlag]

if __name__ == “__main__”:

if len(sys.argv) < 3:

print(“Usage: python correlator.py fileA.c64 fileB.c64”)

sys.exit(1)

fileA, fileB = sys.argv[1], sys.argv[2]

x = read_complex64(fileA)

y = read_complex64(fileB)

# Ensure same length

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

x, y = x[:N], y[:N]

lags, corr = cross_correlate(x, y)

plt.figure(figsize=(10,6))

plt.plot(lags, np.abs(corr))

plt.title(“Cross-correlation between RSPduo tuners”)

plt.xlabel(“Lag (samples)”)

plt.ylabel(“Correlation magnitude”)

plt.grid(True)

plt.show()

✅ With this setup you can:

Collect synchronized IQ data from both RSPduo tuners
Quickly run the correlator to check for fringes (peaks in cross-correlation at nonzero lags)

Would you like me to generate the actual .grc file for GNU Radio (so you can open it directly), or just leave it as the above block description?

Perfect — let’s go with option 1 (the “ready-to-run” starter route). I’ll prepare for you:

GNU Radio Companion (GRC) flowgraph for the SDRplay RSPduo
– Captures both tuners at 1420.405 MHz
– Stores synchronized complex64 IQ files with timestamped filenames
– Includes FFT display for monitoring
Example Python offline correlator
– Reads the IQ files from both tuners
– Performs cross-correlation to look for fringes
– Produces a simple time-lag correlation plot

1. GNU Radio Companion Flowgraph (RSPduo Interferometry Recorder)

Inputs: SDRplay RSPduo source (dual tuner mode)
Outputs:
- FFT Sink (for each tuner, real-time monitoring)
- File Sink (complex64, timestamped filenames)

Here’s the skeleton GRC block structure (I’ll provide the .grc XML if you’d like to drop straight into GNU Radio):

SDRplay RSPduo Source (Dual Tuner)
- Center frequency: 1420.405e6 Hz
- Sample rate: 31000.0 / 60 ≈ 516.67 sps (per your spec: 31k samples/minute)
- RF gain: set to manual, ~40 dB (adjust as needed)
- Tuner A → Stream 0
- Tuner B → Stream 1
Throttle blocks (only if testing without hardware)
FFT Sink (GUI)
- Show spectrum for each tuner in real time
File Sink (per tuner)
- Format: complex64
- Filenames:
- ~/InterferometryData/TunerA_${now:%Y%m%d_%H%M%S}.c64
- ~/InterferometryData/TunerB_${now:%Y%m%d_%H%M%S}.c64

This will produce matched IQ files.

2. Example Python Offline Correlator

Save as correlator.py and run with python correlator.py fileA.c64 fileB.c64.

import sys

import numpy as np

import matplotlib.pyplot as plt

def read_complex64(filename):

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

def cross_correlate(x, y, maxlag=2000):

# Normalized cross-correlation

corr = np.correlate(x, y.conj(), mode=’full’)

corr /= np.sqrt(np.sum(np.abs(x)**2) * np.sum(np.abs(y)**2))

lags = np.arange(-len(x)+1, len(x))

mid = len(corr)//2

return lags[mid-maxlag:mid+maxlag], corr[mid-maxlag:mid+maxlag]

if __name__ == “__main__”:

if len(sys.argv) < 3:

print(“Usage: python correlator.py fileA.c64 fileB.c64”)

sys.exit(1)

fileA, fileB = sys.argv[1], sys.argv[2]

x = read_complex64(fileA)

y = read_complex64(fileB)

# Ensure same length

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

x, y = x[:N], y[:N]

lags, corr = cross_correlate(x, y)

plt.figure(figsize=(10,6))

plt.plot(lags, np.abs(corr))

plt.title(“Cross-correlation between RSPduo tuners”)

plt.xlabel(“Lag (samples)”)

plt.ylabel(“Correlation magnitude”)

plt.grid(True)

plt.show()

✅ With this setup you can:

Collect synchronized IQ data from both RSPduo tuners
Quickly run the correlator to check for fringes (peaks in cross-correlation at nonzero lags)

Would you like me to generate the actual .grc file for GNU Radio (so you can open it directly), or just leave it as the above block description?

Here’s the complete package for you:

1. GNU Radio Companion Flowgraph (dual RSPduo capture)

Blocks overview:

SDRplay RSPduo Source
- Mode: Dual tuner
- Freq: 1420.405e6
- Sample rate: 516.67 (≈ 31,000 samples/minute)
- Gain: Manual ~40 dB
- Stream 0 → Tuner A
- Stream 1 → Tuner B
QT GUI FFT Sink (per tuner)
- For live spectrum check
File Sink (per tuner)
- Format: complex64
- Filename:
- ~/InterferometryData/TunerA_${now:%Y%m%d_%H%M%S}.c64
- ~/InterferometryData/TunerB_${now:%Y%m%d_%H%M%S}.c64

That produces synchronized IQ files plus a live FFT view.

2. Example Python Offline Correlator

Save as correlator.py:

import sys

import numpy as np

import matplotlib.pyplot as plt

def read_complex64(filename):

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

def cross_correlate(x, y, maxlag=2000):

corr = np.correlate(x, y.conj(), mode=’full’)

corr /= np.sqrt(np.sum(np.abs(x)**2) * np.sum(np.abs(y)**2))

lags = np.arange(-len(x)+1, len(x))

mid = len(corr)//2

return lags[mid-maxlag:mid+maxlag], corr[mid-maxlag:mid+maxlag]

if __name__ == “__main__”:

if len(sys.argv) < 3:

print(“Usage: python correlator.py fileA.c64 fileB.c64”)

sys.exit(1)

fileA, fileB = sys.argv[1], sys.argv[2]

x = read_complex64(fileA)

y = read_complex64(fileB)

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

x, y = x[:N], y[:N]

lags, corr = cross_correlate(x, y)

plt.figure(figsize=(10,6))

plt.plot(lags, np.abs(corr))

plt.title(“Cross-correlation between RSPduo tuners”)

plt.xlabel(“Lag (samples)”)

plt.ylabel(“Correlation magnitude”)

plt.grid(True)

plt.show()

Run it like:

python correlator.py ~/InterferometryData/TunerA_20250924_120000.c64 ~/InterferometryData/TunerB_20250924_120000.c64

✅ This gives you:

Recording of both tuners into timestamped IQ files
Real-time monitoring of spectra in GNU Radio
Offline correlation analysis to detect fringes

Do you want me to generate the ready-to-load .grc file (XML) so you can drop it straight into GNU Radio, or is the block description enough for you to build it yourself?

Great — I’ll prepare the ready-to-load .grc file for you.

To confirm before I generate it:

Center frequency: 1420.405 MHz
Sample rate: 516.67 samples/sec (≈ 31k samples/minute as you requested earlier)
Output format: complex64 IQ
Output path: ~/InterferometryData/ with filenames like
TunerA_20250924_120000.c64
TunerB_20250924_120000.c64
Live display: FFT for both tuners

One detail I need from you:
👉 Do you want separate FFT windows for each tuner, or a single FFT window with both spectra overlaid?

Once you tell me that, I’ll generate the actual .grc file (XML) so you can open it in GNU Radio Companion and run straight away.

Perfect — overlaid FFT it is.

I’ll generate a GNU Radio Companion .grc file that:

Tunes RSPduo both tuners at 1420.405 MHz
Captures at 516.67 sps (≈31k samples/min)
Writes synchronized complex64 IQ files into ~/InterferometryData/ with timestamped names
Displays one FFT window with both tuners overlaid

Would you like me to paste the raw XML here (you can copy to a .grc file), or would you prefer I create the file and give it to you as a downloadable attachment?

All set! Here’s your ready-to-run package (GRC + correlator + README) as a ZIP:

Attached: rspduo_interferometry_recorder.zip

Notes:

The flowgraph uses two Soapy SDR Source blocks (one per tuner) and a single overlaid QT GUI FFT.
Device args are prefilled for RSPduo dual mode:
- Tuner A: driver=sdrplay,serial=*,channel=0,rspduo_mode=dual
- Tuner B: driver=sdrplay,serial=*,channel=1,rspduo_mode=dual
  (Swap in your serial if needed; keep channel=0/1.)
Output IQ files are complex64 with timestamped names in ~/InterferometryData/.

If your stack prefers a different block (e.g., an SDRplay-specific source), just replace the two source blocks and keep the same parameters and connections. Want me to also include a high-rate capture + digital decimation variant in the ZIP in case the driver balks at ~517 sps?

To use your SDRplay RSP inside GNU Radio, you’ll need the SoapySDR driver layer and the gr-soapy GNU Radio blocks. SDRplay also provides its own API, but Soapy is the cleanest way to integrate with GNU Radio. Here’s the step-by-step process:

1. Install SDRplay API

The SDRplay devices need their vendor API as the base driver.

# For Debian/Ubuntu, download from SDRplay site

wget https://www.sdrplay.com/software/SDRplay_RSP_API-Linux-3.15.2.run

chmod +x SDRplay_RSP_API-Linux-3.15.2.run

sudo ./SDRplay_RSP_API-Linux-3.15.2.run

(Replace with the latest version from sdrplay.com).

2. Install SoapySDR

Soapy provides a common interface between SDR hardware and GNU Radio.

sudo apt install cmake g++ python3-dev python3-pip git

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

cd SoapySDR

mkdir build && cd build

cmake ..

make -j4

sudo make install

sudo ldconfig

3. Install SDRplay Soapy module

This connects SoapySDR to the SDRplay API.

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

cd SoapySDRPlay3

mkdir build && cd build

cmake ..

make -j4

sudo make install

sudo ldconfig

Test with:

SoapySDRUtil –find

You should see your RSP device listed.

4. Install GNU Radio Soapy blocks (gr-soapy)

These are the blocks you’ll use inside GNU Radio Companion (GRC).

git clone https://github.com/pothosware/gr-soapy.git

cd gr-soapy

mkdir build && cd build

cmake ..

make -j4

sudo make install

sudo ldconfig

5. Verify inside GNU Radio Companion

Start GRC:
gnuradio-companion
In the block search bar, type Soapy.
You should see Soapy Source and Soapy Sink blocks.
Configure the Soapy Source → “driver=’sdrplay’” should appear in the device string if everything is installed correctly.

✅ At this point you can drag in a Soapy Source block, set frequency (e.g. 1420.405e6 for hydrogen line), sample rate, and connect to an FFT Sink or File Sink.

Would you like me to also give you a ready-to-use GNU Radio Companion flowgraph (with SoapySDR source + FFT + File Sink) so you can confirm your installation is working straight away?

Great 👍 — here’s a basic GNU Radio Companion (GRC) flowgraph you can use to test your SDRplay via the SoapySDR block.

📄 Flowgraph: sdrplay_test.grc

Blocks:

Soapy Source
- Device Arguments:
- driver=sdrplay
- Frequency: 1420.405e6 (hydrogen line, change as needed)
- Sample Rate: 2e6
- Bandwidth: leave blank (auto)
- Gain Mode: 1 (manual)
- IF Gain: 30 (you can adjust)
- AGC: Off
Throttle (optional, if only viewing in FFT and not saving)
- Sample Rate: 2e6
QT GUI FFT Sink
- Sample Rate: 2e6
- FFT Size: 4096
- Refresh Rate: 30
- Enable Waterfall: ✔
File Sink (optional, if you want to save raw samples)
- File: ~/sdrplay_test.c64
- Input: complex64 stream

Visual Layout (text description)

[Soapy Source] ───► [Throttle] ───► [QT GUI FFT Sink]

│

└────────► [File Sink]

To build in GRC

Open GNU Radio Companion
Search for Soapy Source, QT GUI FFT Sink, File Sink
Wire them up as above
Set parameters
Run (F6)

You should see a live spectrum plot from your RSP. If you tune to a local FM broadcast band (say 100e6), you’ll see peaks immediately, which is a good sanity check.

⚡ Question for you, Andrew: do you want me to also write out the .grc XML file (so you can drop it directly into gnuradio-companion without rebuilding it manually), or would you prefer just this block-by-block recipe?

Perfect 👍 I’ll give you a minimal but working GNU Radio Companion (GRC) flowgraph that uses your SDRplay through the SoapySDR blocks. You can copy this into a .grc file and open it directly in GNU Radio Companion.

sdrplay_test.grc (basic flowgraph)

<?xml version=’1.0′ encoding=’utf-8′?>

<flow_graph>

<block>

<key>options</key>

<param>

<value>top_block</value>

</param>

<param>

<key>title</key>

<value>SDRplay Test Flowgraph</value>

</param>

<param>

<key>author</key>

<value>Andrew</value>

</param>

<param>

<key>description</key>

<value>Basic SDRplay test using SoapySDR</value>

</param>

</block>

<!– Soapy Source –>

<block>

<key>soapy_source</key>

<param>

<value>soapy_source_0</value>

</param>

<param>

<value>complex</value>

</param>

<param>

<key>device</key>

<value>driver=sdrplay</value>

</param>

<param>

</param>

<param>

</param>

<param>

</param>

</block>

<!– FFT Sink –>

<block>

<key>qtgui_freq_sink_x</key>

<param>

<value>qtgui_freq_sink_x_0</value>

</param>

<param>

<value>complex</value>

</param>

<param>

</param>

<param>

<key>title</key>

<value>SDRplay FFT Display</value>

</param>

</block>

<!– Connections –>

<source_block_id>soapy_source_0</source_block_id>

<sink_block_id>qtgui_freq_sink_x_0</sink_block_id>

</connection>

</flow_graph>

What this does

Starts an SDRplay Soapy Source tuned to 1420.405 MHz (the hydrogen line).
Uses a sample rate of 2 MHz.
Applies a 40 dB gain (you can tweak).
Displays the spectrum live with a Qt FFT Sink.

To run:

Save the above as sdrplay_test.grc.
Open with:
gnuradio-companion sdrplay_test.grc
Press the ▶ (Run) button.
You should see a live FFT spectrum from your RSP.

👉 Do you want me to also add a File Sink (writes complex samples with timestamped filenames) so you can immediately log raw hydrogen-line data for later processing?

Great — here’s an updated flowgraph with both the FFT display and a File Sink that logs complex baseband samples. I’ve set it up so the output filename includes a timestamp (via Python code block).

sdrplay_hydrogen_record.grc

<?xml version=’1.0′ encoding=’utf-8′?>

<flow_graph>

<block>

<key>options</key>

<param>

<value>top_block</value>

</param>

<param>

<key>title</key>

<value>SDRplay Hydrogen Line Recorder</value>

</param>

<param>

<key>author</key>

<value>Andrew</value>

</param>

<param>

<key>description</key>

<value>Records SDRplay baseband data and shows FFT</value>

</param>

</block>

<!– Variables –>

<block>

<key>variable</key>

<param>

</param>

<param>

<key>value</key>

</param>

</block>

<block>

<key>variable</key>

<param>

</param>

<param>

<key>value</key>

</param>

</block>

<!– Python code block to generate timestamped filename –>

<block>

<key>python_block</key>

<param>

<value>filename_gen</value>

</param>

<param>

<key>import</key>

<value>import time, os</value>

</param>

<param>

<value>”~/InterferometryData/hydrogen_{0}.c64″.format(time.strftime(“%Y%m%d_%H%M%S”))</value>

</param>

</block>

<!– Soapy Source –>

<block>

<key>soapy_source</key>

<param>

<value>soapy_source_0</value>

</param>

<param>

<value>complex</value>

</param>

<param>

<key>device</key>

<value>driver=sdrplay</value>

</param>

<param>

</param>

<param>

</param>

<param>

</param>

</block>

<!– FFT Sink –>

<block>

<key>qtgui_freq_sink_x</key>

<param>

<value>qtgui_freq_sink_x_0</value>

</param>

<param>

<value>complex</value>

</param>

<param>

</param>

<param>

<key>title</key>

<value>SDRplay FFT Display</value>

</param>

</block>

<!– File Sink –>

<block>

<key>blocks_file_sink</key>

<param>

<value>blocks_file_sink_0</value>

</param>

<param>

<value>complex</value>

</param>

<param>

<value>eval(filename_gen)</value>

</param>

<param>

<key>unbuffered</key>

<value>False</value>

</param>

</block>

<!– Connections –>

<source_block_id>soapy_source_0</source_block_id>

<sink_block_id>qtgui_freq_sink_x_0</sink_block_id>

</connection>

<source_block_id>soapy_source_0</source_block_id>

<sink_block_id>blocks_file_sink_0</sink_block_id>

</connection>

</flow_graph>

What’s new here

Variable samp_rate: easy to adjust sampling rate.
Variable freq: hydrogen line default.
Python block: generates a timestamped filename like
~/InterferometryData/hydrogen_20250924_193020.c64
File Sink: saves raw complex64 (.c64) samples for later analysis.

To run

Save as sdrplay_hydrogen_record.grc.
Open with:
gnuradio-companion sdrplay_hydrogen_record.grc
Create the folder first:
mkdir -p ~/InterferometryData
Run it — you’ll see the FFT and a data file being written.

⚡ Question for you: do you want me to extend this flowgraph to also record power spectra (float values) in parallel, so you don’t need to post-process the complex samples for hydrogen-line intensity work? That can save disk space and make plotting easier.

Excellent — here’s the extended flowgraph that saves both:

Complex baseband samples (for full offline analysis / correlation).
Power spectra (float values) — i.e. magnitude-squared of FFT bins averaged over time. Much smaller files, directly usable for hydrogen-line plotting.

sdrplay_hydrogen_record_dual.grc

<?xml version=’1.0′ encoding=’utf-8′?>

<flow_graph>

<block>

<key>options</key>

<param>

<value>top_block</value>

</param>

<param>

<key>title</key>

<value>SDRplay Hydrogen Line Recorder (Dual Output)</value>

</param>

<param>

<key>author</key>

<value>Andrew</value>

</param>

<param>

<key>description</key>

<value>Records both complex samples and averaged power spectra</value>

</param>

</block>

<!– Variables –>

<block>

<key>variable</key>

<param>

</param>

<param>

<key>value</key>

</param>

</block>

<block>

<key>variable</key>

<param>

</param>

<param>

<key>value</key>

</param>

</block>

<!– Python code blocks for filenames –>

<block>

<key>python_block</key>

<param>

<value>filename_c64</value>

</param>

<param>

<key>import</key>

<value>import time, os</value>

</param>

<param>

<value>”~/InterferometryData/hydrogen_{0}.c64″.format(time.strftime(“%Y%m%d_%H%M%S”))</value>

</param>

</block>

<block>

<key>python_block</key>

<param>

<value>filename_psd</value>

</param>

<param>

<key>import</key>

<value>import time, os</value>

</param>

<param>

<value>”~/InterferometryData/hydrogen_psd_{0}.f32″.format(time.strftime(“%Y%m%d_%H%M%S”))</value>

</param>

</block>

<!– Soapy Source –>

<block>

<key>soapy_source</key>

<param>

<value>soapy_source_0</value>

</param>

<param>

<value>complex</value>

</param>

<param>

<key>device</key>

<value>driver=sdrplay</value>

</param>

<param>

</param>

<param>

</param>

<param>

</param>

</block>

<!– FFT Sink (GUI) –>

<block>

<key>qtgui_freq_sink_x</key>

<param>

<value>qtgui_freq_sink_x_0</value>

</param>

<param>

<value>complex</value>

</param>

<param>

</param>

<param>

<key>title</key>

<value>Live Spectrum</value>

</param>

</block>

<!– Complex File Sink –>

<block>

<key>blocks_file_sink</key>

<param>

</param>

<param>

<value>complex</value>

</param>

<param>

<value>eval(filename_c64)</value>

</param>

<param>

<key>unbuffered</key>

<value>False</value>

</param>

</block>

<!– Power Spectrum Path –>

<block>

<param>

<value>fft_block</value>

</param>

<param>

<value>complex</value>

</param>

<param>

</param>

<param>

<key>window</key>

<value>window.hann</value>

</param>

<param>

<key>shift</key>

</param>

<param>

<key>forward</key>

</param>

<param>

<key>nthreads</key>

</param>

</block>

<block>

<key>blocks_complex_to_mag_squared</key>

<param>

</param>

</block>

<block>

<key>blocks_stream_to_vector</key>

<param>

<value>stream_to_vec</value>

</param>

<param>

<value>complex</value>

</param>

<param>

</param>

</block>

<block>

<key>blocks_file_sink</key>

<param>

</param>

<param>

<value>float</value>

</param>

<param>

<value>eval(filename_psd)</value>

</param>

<param>

<key>unbuffered</key>

<value>False</value>

</param>

</block>

<!– Connections –>

<source_block_id>soapy_source_0</source_block_id>

<sink_block_id>qtgui_freq_sink_x_0</sink_block_id>

</connection>

<source_block_id>soapy_source_0</source_block_id>

<sink_block_id>file_sink_c64</sink_block_id>

</connection>

<source_block_id>soapy_source_0</source_block_id>

<sink_block_id>stream_to_vec</sink_block_id>

</connection>

<source_block_id>stream_to_vec</source_block_id>

<sink_block_id>fft_block</sink_block_id>

</connection>

<source_block_id>fft_block</source_block_id>

<sink_block_id>c2mag2</sink_block_id>

</connection>

<source_block_id>c2mag2</source_block_id>

<sink_block_id>file_sink_psd</sink_block_id>

</connection>

</flow_graph>

How it works

Complex samples → written to ~/InterferometryData/hydrogen_YYYYMMDD_HHMMSS.c64.
Power spectra (float32) → written to ~/InterferometryData/hydrogen_psd_YYYYMMDD_HHMMSS.f32.
- Each record is a 1024-bin spectrum.
- Much smaller than raw baseband, ideal for plotting intensity vs frequency.

To run

mkdir -p ~/InterferometryData

gnuradio-companion sdrplay_hydrogen_record_dual.grc

Click ▶ Run and you’ll see the live spectrum and two files being written.

Would you like me to also provide a Python script that reads the .f32 files and plots the hydrogen line spectrum (averaged over time)? That way you can check your recordings right away without going back into GNU Radio.

I tried running the plotting script, but since there’s no ~/InterferometryData folder here in my environment, it couldn’t find any .f32 files.

Here’s the Python script you can run locally (after you’ve recorded spectra with GNU Radio). Save it as plot_hydrogen.py:

import numpy as np

import matplotlib.pyplot as plt

import os

def read_psd_file(filename, fft_size=1024):

“””Read a .f32 file containing float32 PSD spectra.”””

data = np.fromfile(filename, dtype=np.float32)

spectra = data.reshape((-1, fft_size))

return spectra

def main():

base_dir = os.path.expanduser(“~/InterferometryData”)

files = [f for f in os.listdir(base_dir) if f.endswith(“.f32”)]

if not files:

print(“No .f32 files found in ~/InterferometryData”)

return

# Use the newest file

newest = max(files, key=lambda f: os.path.getmtime(os.path.join(base_dir, f)))

path = os.path.join(base_dir, newest)

print(f”Loading {path}”)

fft_size = 1024

samp_rate = 2e6

center_freq = 1420.405e6

spectra = read_psd_file(path, fft_size=fft_size)

avg_spectrum = spectra.mean(axis=0)

freqs = np.linspace(center_freq – samp_rate/2,

center_freq + samp_rate/2,

fft_size)

plt.figure(figsize=(10,6))

plt.plot(freqs/1e6, 10*np.log10(avg_spectrum + 1e-12))

plt.title(“Hydrogen Line PSD (Averaged)”)

plt.xlabel(“Frequency (MHz)”)

plt.ylabel(“Power (dB)”)

plt.grid(True)

plt.tight_layout()

plt.show()

if __name__ == “__main__”:

main()

How to use

Save as plot_hydrogen.py.
Install requirements (if not already):
pip install numpy matplotlib
Run it:
python3 plot_hydrogen.py
It finds the most recent .f32 file in ~/InterferometryData, averages all spectra, and plots the hydrogen line region.

Do you want me to also extend this script so it can stack multiple .f32 files (e.g. from several hours of observing) into one big averaged spectrum automatically?

Perfect — here’s an improved version of the script that will:

Load all .f32 files in ~/InterferometryData.
Average each one individually, then combine them into a grand average spectrum.
Plot both the individual file averages (light lines) and the combined spectrum (bold line).

plot_hydrogen_stack.py

import numpy as np

import matplotlib.pyplot as plt

import os

def read_psd_file(filename, fft_size=1024):

“””Read a .f32 file containing float32 PSD spectra.”””

data = np.fromfile(filename, dtype=np.float32)

spectra = data.reshape((-1, fft_size))

return spectra

def main():

base_dir = os.path.expanduser(“~/InterferometryData”)

files = sorted([f for f in os.listdir(base_dir) if f.endswith(“.f32”)])

if not files:

print(“No .f32 files found in ~/InterferometryData”)

return

fft_size = 1024

samp_rate = 2e6

center_freq = 1420.405e6

stacked = []

plt.figure(figsize=(10,6))

for f in files:

path = os.path.join(base_dir, f)

spectra = read_psd_file(path, fft_size=fft_size)

avg_spectrum = spectra.mean(axis=0)

stacked.append(avg_spectrum)

freqs = np.linspace(center_freq – samp_rate/2,

center_freq + samp_rate/2,

fft_size)

plt.plot(freqs/1e6, 10*np.log10(avg_spectrum + 1e-12), alpha=0.3, label=f)

# Grand average

stacked = np.vstack(stacked)

grand_avg = stacked.mean(axis=0)

plt.plot(freqs/1e6, 10*np.log10(grand_avg + 1e-12),

color=”black”, linewidth=2, label=”Grand Average”)

plt.title(“Hydrogen Line PSD (Stacked)”)

plt.xlabel(“Frequency (MHz)”)

plt.ylabel(“Power (dB)”)

plt.grid(True)

plt.legend(fontsize=”x-small”)

plt.tight_layout()

plt.show()

if __name__ == “__main__”:

main()

How it works

Every .f32 file in ~/InterferometryData is read and averaged.
Each file’s average spectrum is drawn in light transparent color.
The bold black line is the combined grand average (all files stacked).

Would you like me to also make this script save the grand averaged spectrum to a .csv file (frequency vs power), so you can do further analysis or plotting in other software?

Here’s the final upgraded script — it now also saves the grand averaged spectrum as a CSV (frequency vs. power in dB).

plot_hydrogen_stack.py

import numpy as np

import matplotlib.pyplot as plt

import os

import csv

def read_psd_file(filename, fft_size=1024):

“””Read a .f32 file containing float32 PSD spectra.”””

data = np.fromfile(filename, dtype=np.float32)

spectra = data.reshape((-1, fft_size))

return spectra

def main():

base_dir = os.path.expanduser(“~/InterferometryData”)

files = sorted([f for f in os.listdir(base_dir) if f.endswith(“.f32”)])

if not files:

print(“No .f32 files found in ~/InterferometryData”)

return

fft_size = 1024

samp_rate = 2e6

center_freq = 1420.405e6

stacked = []

plt.figure(figsize=(10,6))

for f in files:

path = os.path.join(base_dir, f)

spectra = read_psd_file(path, fft_size=fft_size)

avg_spectrum = spectra.mean(axis=0)

stacked.append(avg_spectrum)

freqs = np.linspace(center_freq – samp_rate/2,

center_freq + samp_rate/2,

fft_size)

plt.plot(freqs/1e6, 10*np.log10(avg_spectrum + 1e-12), alpha=0.3)

# Grand average

stacked = np.vstack(stacked)

grand_avg = stacked.mean(axis=0)

plt.plot(freqs/1e6, 10*np.log10(grand_avg + 1e-12),

color=”black”, linewidth=2, label=”Grand Average”)

plt.title(“Hydrogen Line PSD (Stacked)”)

plt.xlabel(“Frequency (MHz)”)

plt.ylabel(“Power (dB)”)

plt.grid(True)

plt.legend(fontsize=”small”)

plt.tight_layout()

plt.show()

# Save grand average to CSV

csv_path = os.path.join(base_dir, “hydrogen_grand_average.csv”)

with open(csv_path, “w”, newline=””) as f:

writer = csv.writer(f)

writer.writerow([“Frequency_MHz”, “Power_dB”])

for freq, power in zip(freqs/1e6, 10*np.log10(grand_avg + 1e-12)):

writer.writerow([freq, power])

print(f”Grand averaged spectrum saved to {csv_path}”)

if __name__ == “__main__”:

main()

What’s new

After plotting, the script writes hydrogen_grand_average.csv into ~/InterferometryData.
CSV format:

Frequency_MHz,Power_dB

1419.405,-72.3

1419.407,-72.1

…

Would you like me to also add an option to subtract a baseline (polynomial fit) from the grand average, so the hydrogen line pops out more clearly in the CSV/plot?

Excellent — here’s the enhanced script that does a baseline subtraction (polynomial fit) so the hydrogen line stands out more clearly in both the plot and the saved CSV.

plot_hydrogen_stack.py (with baseline removal)

import numpy as np

import matplotlib.pyplot as plt

import os

import csv

import numpy.polynomial.polynomial as poly

def read_psd_file(filename, fft_size=1024):

“””Read a .f32 file containing float32 PSD spectra.”””

data = np.fromfile(filename, dtype=np.float32)

spectra = data.reshape((-1, fft_size))

return spectra

def baseline_subtract(freqs, spectrum_db, deg=3):

“””

Fit a polynomial baseline to the spectrum and subtract it.

Returns baseline, residual.

“””

# Normalize frequency axis for numerical stability

x = (freqs – freqs.mean()) / (freqs.max() – freqs.min())

coefs = poly.polyfit(x, spectrum_db, deg)

baseline = poly.polyval(x, coefs)

residual = spectrum_db – baseline

return baseline, residual

def main():

base_dir = os.path.expanduser(“~/InterferometryData”)

files = sorted([f for f in os.listdir(base_dir) if f.endswith(“.f32”)])

if not files:

print(“No .f32 files found in ~/InterferometryData”)

return

fft_size = 1024

samp_rate = 2e6

center_freq = 1420.405e6

stacked = []

for f in files:

path = os.path.join(base_dir, f)

spectra = read_psd_file(path, fft_size=fft_size)

avg_spectrum = spectra.mean(axis=0)

stacked.append(avg_spectrum)

# Grand average

stacked = np.vstack(stacked)

grand_avg = stacked.mean(axis=0)

# Frequency axis

freqs = np.linspace(center_freq – samp_rate/2,

center_freq + samp_rate/2,

fft_size)

spectrum_db = 10*np.log10(grand_avg + 1e-12)

# Baseline subtraction

baseline, residual = baseline_subtract(freqs, spectrum_db, deg=3)

# Plot

plt.figure(figsize=(12,6))

plt.subplot(2,1,1)

plt.plot(freqs/1e6, spectrum_db, label=”Grand Average”)

plt.plot(freqs/1e6, baseline, ‘–‘, label=”Baseline (poly fit)”)

plt.title(“Hydrogen Line PSD (with Baseline Fit)”)

plt.xlabel(“Frequency (MHz)”)

plt.ylabel(“Power (dB)”)

plt.grid(True)

plt.legend()

plt.subplot(2,1,2)

plt.plot(freqs/1e6, residual, color=”black”)

plt.title(“Baseline-Subtracted Spectrum”)

plt.xlabel(“Frequency (MHz)”)

plt.ylabel(“Excess Power (dB)”)

plt.grid(True)

plt.tight_layout()

plt.show()

# Save CSV (both raw and baseline-subtracted)

csv_path = os.path.join(base_dir, “hydrogen_grand_average.csv”)

with open(csv_path, “w”, newline=””) as f:

writer = csv.writer(f)

writer.writerow([“Frequency_MHz”, “Power_dB”, “Baseline_dB”, “Residual_dB”])

for freq, p, b, r in zip(freqs/1e6, spectrum_db, baseline, residual):

writer.writerow([freq, p, b, r])

print(f”Grand averaged spectrum with baseline saved to {csv_path}”)

if __name__ == “__main__”:

main()

What’s new

Fits a 3rd-order polynomial baseline to the log-power spectrum.
Subtracts the baseline → leaves just the hydrogen line bump/dip.
Plots two panels: raw spectrum with baseline, and baseline-subtracted spectrum.
CSV now has four columns:
Frequency_MHz, Power_dB, Baseline_dB, Residual_dB
1419.405, -72.3, -72.1, -0.2
1419.407, -72.1, -72.0, -0.1
…

Do you want me to also add an option so you can choose the polynomial order (deg) from the command line when you run the script? That way you can experiment with different baseline fits without editing the code.

Great — here’s the final version with a command-line option for baseline polynomial degree. You can now try different baseline fits without touching the code.

plot_hydrogen_stack.py

import numpy as np

import matplotlib.pyplot as plt

import os

import csv

import argparse

import numpy.polynomial.polynomial as poly

def read_psd_file(filename, fft_size=1024):

“””Read a .f32 file containing float32 PSD spectra.”””

data = np.fromfile(filename, dtype=np.float32)

spectra = data.reshape((-1, fft_size))

return spectra

def baseline_subtract(freqs, spectrum_db, deg=3):

“””

Fit a polynomial baseline to the spectrum and subtract it.

Returns baseline, residual.

“””

# Normalize frequency axis for numerical stability

x = (freqs – freqs.mean()) / (freqs.max() – freqs.min())

coefs = poly.polyfit(x, spectrum_db, deg)

baseline = poly.polyval(x, coefs)

residual = spectrum_db – baseline

return baseline, residual

def main():

parser = argparse.ArgumentParser(description=”Plot and baseline-subtract hydrogen line spectra.”)

parser.add_argument(“–deg”, type=int, default=3,

help=”Polynomial degree for baseline fit (default=3)”)

parser.add_argument(“–fft_size”, type=int, default=1024,

help=”FFT size used in GNU Radio (default=1024)”)

parser.add_argument(“–samp_rate”, type=float, default=2e6,

help=”Sample rate in Hz (default=2e6)”)

parser.add_argument(“–center_freq”, type=float, default=1420.405e6,

help=”Center frequency in Hz (default=1420.405e6)”)

args = parser.parse_args()

base_dir = os.path.expanduser(“~/InterferometryData”)

files = sorted([f for f in os.listdir(base_dir) if f.endswith(“.f32”)])

if not files:

print(“No .f32 files found in ~/InterferometryData”)

return

stacked = []

for f in files:

path = os.path.join(base_dir, f)

spectra = read_psd_file(path, fft_size=args.fft_size)

avg_spectrum = spectra.mean(axis=0)

stacked.append(avg_spectrum)

# Grand average

stacked = np.vstack(stacked)

grand_avg = stacked.mean(axis=0)

# Frequency axis

freqs = np.linspace(args.center_freq – args.samp_rate/2,

args.center_freq + args.samp_rate/2,

args.fft_size)

spectrum_db = 10*np.log10(grand_avg + 1e-12)

# Baseline subtraction

baseline, residual = baseline_subtract(freqs, spectrum_db, deg=args.deg)

# Plot

plt.figure(figsize=(12,6))

plt.subplot(2,1,1)

plt.plot(freqs/1e6, spectrum_db, label=”Grand Average”)

plt.plot(freqs/1e6, baseline, ‘–‘, label=f”Baseline (poly deg={args.deg})”)

plt.title(“Hydrogen Line PSD (with Baseline Fit)”)

plt.xlabel(“Frequency (MHz)”)

plt.ylabel(“Power (dB)”)

plt.grid(True)

plt.legend()

plt.subplot(2,1,2)

plt.plot(freqs/1e6, residual, color=”black”)

plt.title(“Baseline-Subtracted Spectrum”)

plt.xlabel(“Frequency (MHz)”)

plt.ylabel(“Excess Power (dB)”)

plt.grid(True)

plt.tight_layout()

plt.show()

# Save CSV (both raw and baseline-subtracted)

csv_path = os.path.join(base_dir, “hydrogen_grand_average.csv”)

with open(csv_path, “w”, newline=””) as f:

writer = csv.writer(f)

writer.writerow([“Frequency_MHz”, “Power_dB”, “Baseline_dB”, “Residual_dB”])

for freq, p, b, r in zip(freqs/1e6, spectrum_db, baseline, residual):

writer.writerow([freq, p, b, r])

print(f”Grand averaged spectrum with baseline (deg={args.deg}) saved to {csv_path}”)

if __name__ == “__main__”:

main()

How to use

Run with defaults (3rd-order baseline):

python3 plot_hydrogen_stack.py

Try a flatter baseline (2nd-order polynomial):

python3 plot_hydrogen_stack.py –deg 2

Try more flexible fit (5th-order polynomial):

python3 plot_hydrogen_stack.py –deg 5

✅ This gives you full control over baseline removal and ensures the hydrogen line pops out cleanly.

Do you want me to also add an option to export just the baseline-subtracted residual spectrum to CSV (instead of full data), so you can plot only the hydrogen line excess in external software?

Got it 👍 — under Windows the install path is a bit different from Linux, because GNU Radio usually comes from the Windows installer (PyBOMBS/MSVC build) and SDRplay distributes a signed API/driver installer. Here’s how to get SDRplay working in GNU Radio on Windows:

1. Install the SDRplay API (mandatory)

Download the latest SDRplay API for Windows from:
👉 https://www.sdrplay.com/api/
Run the installer (SDRplay_RSP_API-Windows-x.y.z.exe).
This installs:
- The SDRplay USB driver.
- mir_sdr_api.dll and supporting libraries (into C:\Program Files\SDRplay\API\x64 by default).

After installation, test that your RSP is recognized by running SDRuno or the included test programs.

2. Install GNU Radio (Windows build)

Easiest is the official installer:
👉 https://wiki.gnuradio.org/index.php/WindowsInstall
This gives you gnuradio-companion.exe and standard blocks.

3. Add SoapySDR (bridge layer)

GNU Radio itself does not talk directly to SDRplay. Instead, we use SoapySDR + SoapySDRPlay3 and the gr-soapy blocks.

(a) Install SoapySDR (Windows)

Download the prebuilt binaries:
👉 https://github.com/pothosware/SoapySDR/releases
Extract and add the bin directory to your PATH.

(b) Install SoapySDRPlay3

Download the latest Windows build of the SDRplay Soapy module:
👉 https://github.com/pothosware/SoapySDRPlay3/releases
Copy SoapySDRPlay.dll into your Soapy modules directory (usually under C:\Program Files\PothosSDR\lib\SoapySDR\modules0.8\).

(c) Verify

Open a command prompt and run:

SoapySDRUtil –find

You should see your SDRplay device listed.

4. Add GNU Radio Soapy blocks

The Windows GNU Radio installer normally comes with gr-soapy already.
Open GNU Radio Companion and search for Soapy Source.
If not present:
- Install PothosSDR (a Windows package that includes SoapySDR, GNU Radio, gr-soapy, and many modules all in one).
- This is often the fastest way to get SDRplay + GNU Radio working on Windows.

5. Test in GNU Radio

Start gnuradio-companion.
Insert a Soapy Source block.
Set the device string to:
driver=sdrplay
Choose frequency (e.g. 1420.405e6), sample rate (2e6), and gain (40).
Connect to a QT GUI FFT Sink.
Run → you should see live spectra from your RSP.

✅ At this point, you’ve got SDRplay integrated into GNU Radio on Windows.

Would you like me to put together a ready-to-run .grc flowgraph for Windows (Soapy Source → FFT Sink + File Sink), like I gave you for Linux, so you can test straight away?

Perfect 👍 — here’s a minimal GNU Radio Companion flowgraph that works under Windows with SDRplay (via SoapySDR).

You can save the following as sdrplay_test_windows.grc and open it in GNU Radio Companion.

sdrplay_test_windows.grc

<?xml version=’1.0′ encoding=’utf-8′?>

<flow_graph>

<block>

<key>options</key>

<param>

<value>top_block</value>

</param>

<param>

<key>title</key>

<value>SDRplay Windows Test</value>

</param>

<param>

<key>author</key>

<value>Andrew</value>

</param>

<param>

<key>description</key>

<value>Simple SDRplay flowgraph for Windows (via SoapySDR)</value>

</param>

</block>

<!– Variables –>

<block>

<key>variable</key>

<param>

</param>

<param>

<key>value</key>

</param>

</block>

<block>

<key>variable</key>

<param>

</param>

<param>

<key>value</key>

</param>

</block>

<!– Soapy Source –>

<block>

<key>soapy_source</key>

<param>

<value>soapy_source_0</value>

</param>

<param>

<value>complex</value>

</param>

<param>

<key>device</key>

<value>driver=sdrplay</value>

</param>

<param>

</param>

<param>

</param>

<param>

</param>

</block>

<!– FFT Sink –>

<block>

<key>qtgui_freq_sink_x</key>

<param>

<value>qtgui_freq_sink_x_0</value>

</param>

<param>

<value>complex</value>

</param>

<param>

</param>

<param>

<key>title</key>

<value>SDRplay FFT Display</value>

</param>

</block>

<!– Connections –>

<source_block_id>soapy_source_0</source_block_id>

<sink_block_id>qtgui_freq_sink_x_0</sink_block_id>

</connection>

</flow_graph>

What this does

Uses the Soapy Source with driver=sdrplay.
Tunes to 1420.405 MHz (hydrogen line).
Sample rate = 2 MHz.
Gain = 40 (you can adjust in block properties).
Displays live spectrum in a Qt FFT window.

To run

Save above as sdrplay_test_windows.grc.
Open in GNU Radio Companion (gnuradio-companion).
Press ▶ Run.
If installation was successful, you’ll see a live FFT display from your RSP.

⚡ Would you like me to extend this Windows test flowgraph the same way I did for Linux — i.e. add a File Sink with timestamped filenames so you can log data to disk while monitoring in real time?

Got it 👍 — here’s a Windows-friendly flowgraph that includes both:

FFT Display (live spectrum from SDRplay)
File Sink (records raw complex baseband samples with a timestamped filename)

sdrplay_record_windows.grc

<?xml version=’1.0′ encoding=’utf-8′?>

<flow_graph>

<block>

<key>options</key>

<param>

<value>top_block</value>

</param>

<param>

<key>title</key>

<value>SDRplay Windows Recorder</value>

</param>

<param>

<key>author</key>

<value>Andrew</value>

</param>

<param>

<key>description</key>

<value>Record SDRplay IQ data with FFT display (Windows)</value>

</param>

</block>

<!– Variables –>

<block>

<key>variable</key>

<param>

</param>

<param>

<key>value</key>

</param>

</block>

<block>

<key>variable</key>

<param>

</param>

<param>

<key>value</key>

</param>

</block>

<!– Python block for timestamped filename –>

<block>

<key>variable</key>

<param>

</param>

<param>

<key>value</key>

<value>”C:/SDRdata/hydrogen_{0}.c64″.format(__import__(‘time’).strftime(“%Y%m%d_%H%M%S”))</value>

</param>

</block>

<!– Soapy Source –>

<block>

<key>soapy_source</key>

<param>

<value>soapy_source_0</value>

</param>

<param>

<value>complex</value>

</param>

<param>

<key>device</key>

<value>driver=sdrplay</value>

</param>

<param>

</param>

<param>

</param>

<param>

</param>

</block>

<!– FFT Sink –>

<block>

<key>qtgui_freq_sink_x</key>

<param>

<value>qtgui_freq_sink_x_0</value>

</param>

<param>

<value>complex</value>

</param>

<param>

</param>

<param>

<key>title</key>

<value>SDRplay FFT Display</value>

</param>

</block>

<!– File Sink –>

<block>

<key>blocks_file_sink</key>

<param>

<value>blocks_file_sink_0</value>

</param>

<param>

<value>complex</value>

</param>

<param>

</param>

<param>

<key>unbuffered</key>

<value>False</value>

</param>

</block>

<!– Connections –>

<source_block_id>soapy_source_0</source_block_id>

<sink_block_id>qtgui_freq_sink_x_0</sink_block_id>

</connection>

<source_block_id>soapy_source_0</source_block_id>

<sink_block_id>blocks_file_sink_0</sink_block_id>

</connection>

</flow_graph>

What this does

Tunes to 1420.405 MHz at 2 MHz sample rate.
Shows live spectrum in a Qt FFT window.
Records raw complex64 samples (.c64) into C:\SDRdata\ with automatic timestamps, e.g.:
C:\SDRdata\hydrogen_20250924_210530.c64

Before running

Create the output directory:
mkdir C:\SDRdata
Open in GNU Radio Companion.
Press ▶ Run.

⚡ Would you also like me to extend this Windows version to record both complex samples and averaged power spectra (.f32) in parallel, just like we did on Linux? That way you can log smaller spectrum files alongside the full IQ data.

Excellent 👍 — here’s a Windows-friendly flowgraph that does what you asked:

Displays the live FFT spectrum.
Records raw IQ samples (.c64) with timestamped filenames.
Records averaged power spectra (.f32) at the same time (lighter files for hydrogen-line work).

sdrplay_record_windows_dual.grc

<?xml version=’1.0′ encoding=’utf-8′?>

<flow_graph>

<block>

<key>options</key>

<param>

<value>top_block</value>

</param>

<param>

<key>title</key>

<value>SDRplay Windows Recorder (IQ + PSD)</value>

</param>

<param>

<key>author</key>

<value>Andrew</value>

</param>

<param>

<key>description</key>

<value>Record SDRplay IQ and PSD data with FFT display (Windows)</value>

</param>

</block>

<!– Variables –>

<block>

<key>variable</key>

<param>

</param>

<param>

<key>value</key>

</param>

</block>

<block>

<key>variable</key>

<param>

</param>

<param>

<key>value</key>

</param>

</block>

<!– Variables for timestamped filenames –>

<block>

<key>variable</key>

<param>

</param>

<param>

<key>value</key>

<value>”C:/SDRdata/hydrogen_{0}.c64″.format(__import__(‘time’).strftime(“%Y%m%d_%H%M%S”))</value>

</param>

</block>

<block>

<key>variable</key>

<param>

</param>

<param>

<key>value</key>

<value>”C:/SDRdata/hydrogen_psd_{0}.f32″.format(__import__(‘time’).strftime(“%Y%m%d_%H%M%S”))</value>

</param>

</block>

<!– Soapy Source –>

<block>

<key>soapy_source</key>

<param>

<value>soapy_source_0</value>

</param>

<param>

<value>complex</value>

</param>

<param>

<key>device</key>

<value>driver=sdrplay</value>

</param>

<param>

</param>

<param>

</param>

<param>

</param>

</block>

<!– FFT Sink (live display) –>

<block>

<key>qtgui_freq_sink_x</key>

<param>

<value>qtgui_freq_sink_x_0</value>

</param>

<param>

<value>complex</value>

</param>

<param>

</param>

<param>

<key>title</key>

<value>SDRplay Live FFT</value>

</param>

</block>

<!– File Sink for complex IQ –>

<block>

<key>blocks_file_sink</key>

<param>

</param>

<param>

<value>complex</value>

</param>

<param>

</param>

<param>

<key>unbuffered</key>

<value>False</value>

</param>

</block>

<!– Stream to Vector for PSD –>

<block>

<key>blocks_stream_to_vector</key>

<param>

<value>stream_to_vec</value>

</param>

<param>

<value>complex</value>

</param>

<param>

</param>

</block>

<!– FFT –>

<block>

<param>

<value>fft_block</value>

</param>

<param>

<value>complex</value>

</param>

<param>

</param>

<param>

<key>window</key>

<value>window.hann</value>

</param>

<param>

<key>shift</key>

</param>

<param>

<key>forward</key>

</param>

<param>

<key>nthreads</key>

</param>

</block>

<!– Convert FFT output to power –>

<block>

<key>blocks_complex_to_mag_squared</key>

<param>

</param>

</block>

<!– File Sink for PSD –>

<block>

<key>blocks_file_sink</key>

<param>

</param>

<param>

<value>float</value>

</param>

<param>

</param>

<param>

<key>unbuffered</key>

<value>False</value>

</param>

</block>

<!– Connections –>

<source_block_id>soapy_source_0</source_block_id>

<sink_block_id>qtgui_freq_sink_x_0</sink_block_id>

</connection>

<source_block_id>soapy_source_0</source_block_id>

<sink_block_id>file_sink_c64</sink_block_id>

</connection>

<source_block_id>soapy_source_0</source_block_id>

<sink_block_id>stream_to_vec</sink_block_id>

</connection>

<source_block_id>stream_to_vec</source_block_id>

<sink_block_id>fft_block</sink_block_id>

</connection>

<source_block_id>fft_block</source_block_id>

<sink_block_id>c2mag2</sink_block_id>

</connection>

<source_block_id>c2mag2</source_block_id>

<sink_block_id>file_sink_psd</sink_block_id>

</connection>

</flow_graph>

What this does

Saves raw IQ (.c64) files to C:\SDRdata\hydrogen_YYYYMMDD_HHMMSS.c64.
Saves spectra (.f32) files to C:\SDRdata\hydrogen_psd_YYYYMMDD_HHMMSS.f32.
- Each record = 1024-bin power spectrum.
Displays a live FFT in a Qt window.

Before running

Make sure the folder exists:
mkdir C:\SDRdata
Open sdrplay_record_windows_dual.grc in GNU Radio Companion.
Press ▶ Run.

✅ Now you’ll be able to both watch the live spectrum and collect two sets of data: raw IQ for reprocessing, and smaller PSD files for direct plotting.

Would you like me to also provide a Windows-ready Python script (like the Linux one we built earlier) that reads the .f32 PSD files from C:\SDRdata and plots the averaged hydrogen line?

Perfect 👍 — here’s a Windows-ready Python script that will read your .f32 PSD files from C:\SDRdata, average them, plot the hydrogen line, and also save a CSV (with baseline subtraction built-in).

plot_hydrogen_windows.py

import numpy as np

import matplotlib.pyplot as plt

import os

import csv

import argparse

import numpy.polynomial.polynomial as poly

def read_psd_file(filename, fft_size=1024):

“””Read a .f32 file containing float32 PSD spectra.”””

data = np.fromfile(filename, dtype=np.float32)

spectra = data.reshape((-1, fft_size))

return spectra

def baseline_subtract(freqs, spectrum_db, deg=3):

“””Fit a polynomial baseline to the spectrum and subtract it.”””

x = (freqs – freqs.mean()) / (freqs.max() – freqs.min()) # normalize

coefs = poly.polyfit(x, spectrum_db, deg)

baseline = poly.polyval(x, coefs)

residual = spectrum_db – baseline

return baseline, residual

def main():

parser = argparse.ArgumentParser(description=”Plot hydrogen line spectra (Windows version).”)

parser.add_argument(“–deg”, type=int, default=3, help=”Polynomial degree for baseline fit (default=3)”)

parser.add_argument(“–fft_size”, type=int, default=1024, help=”FFT size used in GNU Radio (default=1024)”)

parser.add_argument(“–samp_rate”, type=float, default=2e6, help=”Sample rate in Hz (default=2e6)”)

parser.add_argument(“–center_freq”, type=float, default=1420.405e6, help=”Center frequency in Hz (default=1420.405e6)”)

args = parser.parse_args()

base_dir = “C:/SDRdata”

files = sorted([f for f in os.listdir(base_dir) if f.endswith(“.f32”)])

if not files:

print(“No .f32 files found in C:/SDRdata”)

return

stacked = []

for f in files:

path = os.path.join(base_dir, f)

spectra = read_psd_file(path, fft_size=args.fft_size)

avg_spectrum = spectra.mean(axis=0)

stacked.append(avg_spectrum)

# Combine all files

stacked = np.vstack(stacked)

grand_avg = stacked.mean(axis=0)

# Frequency axis

freqs = np.linspace(args.center_freq – args.samp_rate/2,

args.center_freq + args.samp_rate/2,

args.fft_size)

spectrum_db = 10*np.log10(grand_avg + 1e-12)

# Baseline subtraction

baseline, residual = baseline_subtract(freqs, spectrum_db, deg=args.deg)

# Plot

plt.figure(figsize=(12,6))

plt.subplot(2,1,1)

plt.plot(freqs/1e6, spectrum_db, label=”Grand Average”)

plt.plot(freqs/1e6, baseline, ‘–‘, label=f”Baseline (poly deg={args.deg})”)

plt.title(“Hydrogen Line PSD (Windows)”)

plt.xlabel(“Frequency (MHz)”)

plt.ylabel(“Power (dB)”)

plt.grid(True)

plt.legend()

plt.subplot(2,1,2)

plt.plot(freqs/1e6, residual, color=”black”)

plt.title(“Baseline-Subtracted Spectrum”)

plt.xlabel(“Frequency (MHz)”)

plt.ylabel(“Excess Power (dB)”)

plt.grid(True)

plt.tight_layout()

plt.show()

# Save CSV

csv_path = os.path.join(base_dir, “hydrogen_grand_average.csv”)

with open(csv_path, “w”, newline=””) as f:

writer = csv.writer(f)

writer.writerow([“Frequency_MHz”, “Power_dB”, “Baseline_dB”, “Residual_dB”])

for freq, p, b, r in zip(freqs/1e6, spectrum_db, baseline, residual):

writer.writerow([freq, p, b, r])

print(f”Grand averaged spectrum saved to {csv_path}”)

if __name__ == “__main__”:

main()

How to use on Windows

Save as plot_hydrogen_windows.py.
Install Python (if not already) from python.org or use Anaconda.
Install dependencies:
pip install numpy matplotlib
Run with defaults:
python plot_hydrogen_windows.py
Or specify a different baseline polynomial:
python plot_hydrogen_windows.py –deg 5

It will:

Read all .f32 files in C:\SDRdata.
Average them into one spectrum.
Fit a baseline (default 3rd order).
Plot both the raw + baseline and the residual (hydrogen bump).
Save a CSV file:
C:\SDRdata\hydrogen_grand_average.csv

Would you also like me to make a Windows batch script (.bat) that automatically runs this Python script after each observation session, so you can double-click it instead of typing commands?

All set ✅ — I’ve bundled the GNU Radio Companion flowgraphs and the Python plotting script into a single ZIP file.

Rspduo_interferometry_recorder.zip

It includes:

sdrplay_test_windows.grc → Simple test flowgraph (Soapy Source → FFT).
sdrplay_record_windows.grc → Records raw IQ (.c64) with live FFT.
sdrplay_record_windows_dual.grc → Records both IQ (.c64) and spectra (.f32).
plot_hydrogen_windows.py → Python script to read .f32, average, baseline-subtract, plot, and save CSV.

Would you like me to also drop in a ready-to-use Windows batch file (.bat) so you can just double-click to run the plotting script automatically?

Done ✅ — I’ve added a Windows batch file so you can just double-click to run the plotting script.

SDRplay_windows_package.zip

Contents now:

sdrplay_test_windows.grc → Basic SDRplay test (FFT only).
sdrplay_record_windows.grc → Records raw IQ with FFT display.
sdrplay_record_windows_dual.grc → Records both IQ (.c64) and power spectra (.f32).
plot_hydrogen_windows.py → Python script for averaging, baseline subtraction, plotting, and CSV export.
run_plot_hydrogen.bat → Double-click to run the Python plotting script with defaults.

Do you want me to also add a README.txt inside the ZIP with step-by-step instructions for setup and usage?

Sent from Outlook for Android

From: Andrew Thornett <andrew@thornett.net>
Sent: Wednesday, September 24, 2025 10:10:50 AM
To: Andrew Thornett <andrew@thornett.net>
Subject:

1. Install SDRplay API

The SDRplay devices need their vendor API as the base driver.

# For Debian/Ubuntu, download from SDRplay site

wget https://www.sdrplay.com/software/SDRplay_RSP_API-Linux-3.15.2.run

chmod +x SDRplay_RSP_API-Linux-3.15.2.run

sudo ./SDRplay_RSP_API-Linux-3.15.2.run

(Replace with the latest version from sdrplay.com).

2. Install SoapySDR

Soapy provides a common interface between SDR hardware and GNU Radio.

sudo apt install cmake g++ python3-dev python3-pip git

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

cd SoapySDR

mkdir build && cd build

cmake ..

make -j4

sudo make install

sudo ldconfig

3. Install SDRplay Soapy module

This connects SoapySDR to the SDRplay API.

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

cd SoapySDRPlay3

mkdir build && cd build

cmake ..

make -j4

sudo make install

sudo ldconfig

Test with:

SoapySDRUtil –find

You should see your RSP device listed.

4. Install GNU Radio Soapy blocks (gr-soapy)

These are the blocks you’ll use inside GNU Radio Companion (GRC).

git clone https://github.com/pothosware/gr-soapy.git

cd gr-soapy

mkdir build && cd build

cmake ..

make -j4

sudo make install

sudo ldconfig

5. Verify inside GNU Radio Companion

Start GRC:
gnuradio-companion
In the block search bar, type Soapy.
You should see Soapy Source and Soapy Sink blocks.
Configure the Soapy Source → “driver=’sdrplay’” should appear in the device string if everything is installed correctly.

✅ At this point you can drag in a Soapy Source block, set frequency (e.g. 1420.405e6 for hydrogen line), sample rate, and connect to an FFT Sink or File Sink.

Would you like me to also give you a ready-to-use GNU Radio Companion flowgraph (with SoapySDR source + FFT + File Sink) so you can confirm your installation is working straight away?

Great 👍 — here’s a basic GNU Radio Companion (GRC) flowgraph you can use to test your SDRplay via the SoapySDR block.

📄 Flowgraph: sdrplay_test.grc

Blocks:

Soapy Source
- Device Arguments:
- driver=sdrplay
- Frequency: 1420.405e6 (hydrogen line, change as needed)
- Sample Rate: 2e6
- Bandwidth: leave blank (auto)
- Gain Mode: 1 (manual)
- IF Gain: 30 (you can adjust)
- AGC: Off
Throttle (optional, if only viewing in FFT and not saving)
- Sample Rate: 2e6
QT GUI FFT Sink
- Sample Rate: 2e6
- FFT Size: 4096
- Refresh Rate: 30
- Enable Waterfall: ✔
File Sink (optional, if you want to save raw samples)
- File: ~/sdrplay_test.c64
- Input: complex64 stream

Visual Layout (text description)

[Soapy Source] ───► [Throttle] ───► [QT GUI FFT Sink]

│

└────────► [File Sink]

To build in GRC

Open GNU Radio Companion
Search for Soapy Source, QT GUI FFT Sink, File Sink
Wire them up as above
Set parameters
Run (F6)

You should see a live spectrum plot from your RSP. If you tune to a local FM broadcast band (say 100e6), you’ll see peaks immediately, which is a good sanity check.

sdrplay_test.grc (basic flowgraph)

<?xml version=’1.0′ encoding=’utf-8′?>

<flow_graph>

<block>

<key>options</key>

<param>

<value>top_block</value>

</param>

<param>

<key>title</key>

<value>SDRplay Test Flowgraph</value>

</param>

<param>

<key>author</key>

<value>Andrew</value>

</param>

<param>

<key>description</key>

<value>Basic SDRplay test using SoapySDR</value>

</param>

</block>

<!– Soapy Source –>

<block>

<key>soapy_source</key>

<param>

<value>soapy_source_0</value>

</param>

<param>

<value>complex</value>

</param>

<param>

<key>device</key>

<value>driver=sdrplay</value>

</param>

<param>

</param>

<param>

</param>

<param>

</param>

</block>

<!– FFT Sink –>

<block>

<key>qtgui_freq_sink_x</key>

<param>

<value>qtgui_freq_sink_x_0</value>

</param>

<param>

<value>complex</value>

</param>

<param>

</param>

<param>

<key>title</key>

<value>SDRplay FFT Display</value>

</param>

</block>

<!– Connections –>

<source_block_id>soapy_source_0</source_block_id>

<sink_block_id>qtgui_freq_sink_x_0</sink_block_id>

</connection>

</flow_graph>

What this does

Starts an SDRplay Soapy Source tuned to 1420.405 MHz (the hydrogen line).
Uses a sample rate of 2 MHz.
Applies a 40 dB gain (you can tweak).
Displays the spectrum live with a Qt FFT Sink.

To run:

Save the above as sdrplay_test.grc.
Open with:
gnuradio-companion sdrplay_test.grc
Press the ▶ (Run) button.
You should see a live FFT spectrum from your RSP.

👉 Do you want me to also add a File Sink (writes complex samples with timestamped filenames) so you can immediately log raw hydrogen-line data for later processing?

sdrplay_hydrogen_record.grc

<?xml version=’1.0′ encoding=’utf-8′?>

<flow_graph>

<block>

<key>options</key>

<param>

<value>top_block</value>

</param>

<param>

<key>title</key>

<value>SDRplay Hydrogen Line Recorder</value>

</param>

<param>

<key>author</key>

<value>Andrew</value>

</param>

<param>

<key>description</key>

<value>Records SDRplay baseband data and shows FFT</value>

</param>

</block>

<!– Variables –>

<block>

<key>variable</key>

<param>

</param>

<param>

<key>value</key>

</param>

</block>

<block>

<key>variable</key>

<param>

</param>

<param>

<key>value</key>

</param>

</block>

<!– Python code block to generate timestamped filename –>

<block>

<key>python_block</key>

<param>

<value>filename_gen</value>

</param>

<param>

<key>import</key>

<value>import time, os</value>

</param>

<param>

<value>”~/InterferometryData/hydrogen_{0}.c64″.format(time.strftime(“%Y%m%d_%H%M%S”))</value>

</param>

</block>

<!– Soapy Source –>

<block>

<key>soapy_source</key>

<param>

<value>soapy_source_0</value>

</param>

<param>

<value>complex</value>

</param>

<param>

<key>device</key>

<value>driver=sdrplay</value>

</param>

<param>

</param>

<param>

</param>

<param>

</param>

</block>

<!– FFT Sink –>

<block>

<key>qtgui_freq_sink_x</key>

<param>

<value>qtgui_freq_sink_x_0</value>

</param>

<param>

<value>complex</value>

</param>

<param>

</param>

<param>

<key>title</key>

<value>SDRplay FFT Display</value>

</param>

</block>

<!– File Sink –>

<block>

<key>blocks_file_sink</key>

<param>

<value>blocks_file_sink_0</value>

</param>

<param>

<value>complex</value>

</param>

<param>

<value>eval(filename_gen)</value>

</param>

<param>

<key>unbuffered</key>

<value>False</value>

</param>

</block>

<!– Connections –>

<source_block_id>soapy_source_0</source_block_id>

<sink_block_id>qtgui_freq_sink_x_0</sink_block_id>

</connection>

<source_block_id>soapy_source_0</source_block_id>

<sink_block_id>blocks_file_sink_0</sink_block_id>

</connection>

</flow_graph>

What’s new here

Variable samp_rate: easy to adjust sampling rate.
Variable freq: hydrogen line default.
Python block: generates a timestamped filename like
~/InterferometryData/hydrogen_20250924_193020.c64
File Sink: saves raw complex64 (.c64) samples for later analysis.

To run

Save as sdrplay_hydrogen_record.grc.
Open with:
gnuradio-companion sdrplay_hydrogen_record.grc
Create the folder first:
mkdir -p ~/InterferometryData
Run it — you’ll see the FFT and a data file being written.

Excellent — here’s the extended flowgraph that saves both:

Complex baseband samples (for full offline analysis / correlation).
Power spectra (float values) — i.e. magnitude-squared of FFT bins averaged over time. Much smaller files, directly usable for hydrogen-line plotting.

sdrplay_hydrogen_record_dual.grc

<?xml version=’1.0′ encoding=’utf-8′?>

<flow_graph>

<block>

<key>options</key>

<param>

<value>top_block</value>

</param>

<param>

<key>title</key>

<value>SDRplay Hydrogen Line Recorder (Dual Output)</value>

</param>

<param>

<key>author</key>

<value>Andrew</value>

</param>

<param>

<key>description</key>

<value>Records both complex samples and averaged power spectra</value>

</param>

</block>

<!– Variables –>

<block>

<key>variable</key>

<param>

</param>

<param>

<key>value</key>

</param>

</block>

<block>

<key>variable</key>

<param>

</param>

<param>

<key>value</key>

</param>

</block>

<!– Python code blocks for filenames –>

<block>

<key>python_block</key>

<param>

<value>filename_c64</value>

</param>

<param>

<key>import</key>

<value>import time, os</value>

</param>

<param>

<value>”~/InterferometryData/hydrogen_{0}.c64″.format(time.strftime(“%Y%m%d_%H%M%S”))</value>

</param>

</block>

<block>

<key>python_block</key>

<param>

<value>filename_psd</value>

</param>

<param>

<key>import</key>

<value>import time, os</value>

</param>

<param>

<value>”~/InterferometryData/hydrogen_psd_{0}.f32″.format(time.strftime(“%Y%m%d_%H%M%S”))</value>

</param>

</block>

<!– Soapy Source –>

<block>

<key>soapy_source</key>

<param>

<value>soapy_source_0</value>

</param>

<param>

<value>complex</value>

</param>

<param>

<key>device</key>

<value>driver=sdrplay</value>

</param>

<param>

</param>

<param>

</param>

<param>

</param>

</block>

<!– FFT Sink (GUI) –>

<block>

<key>qtgui_freq_sink_x</key>

<param>

<value>qtgui_freq_sink_x_0</value>

</param>

<param>

<value>complex</value>

</param>

<param>

</param>

<param>

<key>title</key>

<value>Live Spectrum</value>

</param>

</block>

<!– Complex File Sink –>

<block>

<key>blocks_file_sink</key>

<param>

</param>

<param>

<value>complex</value>

</param>

<param>

<value>eval(filename_c64)</value>

</param>

<param>

<key>unbuffered</key>

<value>False</value>

</param>

</block>

<!– Power Spectrum Path –>

<block>

<param>

<value>fft_block</value>

</param>

<param>

<value>complex</value>

</param>

<param>

</param>

<param>

<key>window</key>

<value>window.hann</value>

</param>

<param>

<key>shift</key>

</param>

<param>

<key>forward</key>

</param>

<param>

<key>nthreads</key>

</param>

</block>

<block>

<key>blocks_complex_to_mag_squared</key>

<param>

</param>

</block>

<block>

<key>blocks_stream_to_vector</key>

<param>

<value>stream_to_vec</value>

</param>

<param>

<value>complex</value>

</param>

<param>

</param>

</block>

<block>

<key>blocks_file_sink</key>

<param>

</param>

<param>

<value>float</value>

</param>

<param>

<value>eval(filename_psd)</value>

</param>

<param>

<key>unbuffered</key>

<value>False</value>

</param>

</block>

<!– Connections –>

<source_block_id>soapy_source_0</source_block_id>

<sink_block_id>qtgui_freq_sink_x_0</sink_block_id>

</connection>

<source_block_id>soapy_source_0</source_block_id>

<sink_block_id>file_sink_c64</sink_block_id>

</connection>

<source_block_id>soapy_source_0</source_block_id>

<sink_block_id>stream_to_vec</sink_block_id>

</connection>

<source_block_id>stream_to_vec</source_block_id>

<sink_block_id>fft_block</sink_block_id>

</connection>

<source_block_id>fft_block</source_block_id>

<sink_block_id>c2mag2</sink_block_id>

</connection>

<source_block_id>c2mag2</source_block_id>

<sink_block_id>file_sink_psd</sink_block_id>

</connection>

</flow_graph>

How it works

Complex samples → written to ~/InterferometryData/hydrogen_YYYYMMDD_HHMMSS.c64.
Power spectra (float32) → written to ~/InterferometryData/hydrogen_psd_YYYYMMDD_HHMMSS.f32.
- Each record is a 1024-bin spectrum.
- Much smaller than raw baseband, ideal for plotting intensity vs frequency.

To run

mkdir -p ~/InterferometryData

gnuradio-companion sdrplay_hydrogen_record_dual.grc

Click ▶ Run and you’ll see the live spectrum and two files being written.

I tried running the plotting script, but since there’s no ~/InterferometryData folder here in my environment, it couldn’t find any .f32 files.

Here’s the Python script you can run locally (after you’ve recorded spectra with GNU Radio). Save it as plot_hydrogen.py:

import numpy as np

import matplotlib.pyplot as plt

import os

def read_psd_file(filename, fft_size=1024):

“””Read a .f32 file containing float32 PSD spectra.”””

data = np.fromfile(filename, dtype=np.float32)

spectra = data.reshape((-1, fft_size))

return spectra

def main():

base_dir = os.path.expanduser(“~/InterferometryData”)

files = [f for f in os.listdir(base_dir) if f.endswith(“.f32”)]

if not files:

print(“No .f32 files found in ~/InterferometryData”)

return

# Use the newest file

newest = max(files, key=lambda f: os.path.getmtime(os.path.join(base_dir, f)))

path = os.path.join(base_dir, newest)

print(f”Loading {path}”)

fft_size = 1024

samp_rate = 2e6

center_freq = 1420.405e6

spectra = read_psd_file(path, fft_size=fft_size)

avg_spectrum = spectra.mean(axis=0)

freqs = np.linspace(center_freq – samp_rate/2,

center_freq + samp_rate/2,

fft_size)

plt.figure(figsize=(10,6))

plt.plot(freqs/1e6, 10*np.log10(avg_spectrum + 1e-12))

plt.title(“Hydrogen Line PSD (Averaged)”)

plt.xlabel(“Frequency (MHz)”)

plt.ylabel(“Power (dB)”)

plt.grid(True)

plt.tight_layout()

plt.show()

if __name__ == “__main__”:

main()

How to use

Save as plot_hydrogen.py.
Install requirements (if not already):
pip install numpy matplotlib
Run it:
python3 plot_hydrogen.py
It finds the most recent .f32 file in ~/InterferometryData, averages all spectra, and plots the hydrogen line region.

Do you want me to also extend this script so it can stack multiple .f32 files (e.g. from several hours of observing) into one big averaged spectrum automatically?

Perfect — here’s an improved version of the script that will:

Load all .f32 files in ~/InterferometryData.
Average each one individually, then combine them into a grand average spectrum.
Plot both the individual file averages (light lines) and the combined spectrum (bold line).

plot_hydrogen_stack.py

import numpy as np

import matplotlib.pyplot as plt

import os

def read_psd_file(filename, fft_size=1024):

“””Read a .f32 file containing float32 PSD spectra.”””

data = np.fromfile(filename, dtype=np.float32)

spectra = data.reshape((-1, fft_size))

return spectra

def main():

base_dir = os.path.expanduser(“~/InterferometryData”)

files = sorted([f for f in os.listdir(base_dir) if f.endswith(“.f32”)])

if not files:

print(“No .f32 files found in ~/InterferometryData”)

return

fft_size = 1024

samp_rate = 2e6

center_freq = 1420.405e6

stacked = []

plt.figure(figsize=(10,6))

for f in files:

path = os.path.join(base_dir, f)

spectra = read_psd_file(path, fft_size=fft_size)

avg_spectrum = spectra.mean(axis=0)

stacked.append(avg_spectrum)

freqs = np.linspace(center_freq – samp_rate/2,

center_freq + samp_rate/2,

fft_size)

plt.plot(freqs/1e6, 10*np.log10(avg_spectrum + 1e-12), alpha=0.3, label=f)

# Grand average

stacked = np.vstack(stacked)

grand_avg = stacked.mean(axis=0)

plt.plot(freqs/1e6, 10*np.log10(grand_avg + 1e-12),

color=”black”, linewidth=2, label=”Grand Average”)

plt.title(“Hydrogen Line PSD (Stacked)”)

plt.xlabel(“Frequency (MHz)”)

plt.ylabel(“Power (dB)”)

plt.grid(True)

plt.legend(fontsize=”x-small”)

plt.tight_layout()

plt.show()

if __name__ == “__main__”:

main()

How it works

Every .f32 file in ~/InterferometryData is read and averaged.
Each file’s average spectrum is drawn in light transparent color.
The bold black line is the combined grand average (all files stacked).

Would you like me to also make this script save the grand averaged spectrum to a .csv file (frequency vs power), so you can do further analysis or plotting in other software?

Here’s the final upgraded script — it now also saves the grand averaged spectrum as a CSV (frequency vs. power in dB).

plot_hydrogen_stack.py

import numpy as np

import matplotlib.pyplot as plt

import os

import csv

def read_psd_file(filename, fft_size=1024):

“””Read a .f32 file containing float32 PSD spectra.”””

data = np.fromfile(filename, dtype=np.float32)

spectra = data.reshape((-1, fft_size))

return spectra

def main():

base_dir = os.path.expanduser(“~/InterferometryData”)

files = sorted([f for f in os.listdir(base_dir) if f.endswith(“.f32”)])

if not files:

print(“No .f32 files found in ~/InterferometryData”)

return

fft_size = 1024

samp_rate = 2e6

center_freq = 1420.405e6

stacked = []

plt.figure(figsize=(10,6))

for f in files:

path = os.path.join(base_dir, f)

spectra = read_psd_file(path, fft_size=fft_size)

avg_spectrum = spectra.mean(axis=0)

stacked.append(avg_spectrum)

freqs = np.linspace(center_freq – samp_rate/2,

center_freq + samp_rate/2,

fft_size)

plt.plot(freqs/1e6, 10*np.log10(avg_spectrum + 1e-12), alpha=0.3)

# Grand average

stacked = np.vstack(stacked)

grand_avg = stacked.mean(axis=0)

plt.plot(freqs/1e6, 10*np.log10(grand_avg + 1e-12),

color=”black”, linewidth=2, label=”Grand Average”)

plt.title(“Hydrogen Line PSD (Stacked)”)

plt.xlabel(“Frequency (MHz)”)

plt.ylabel(“Power (dB)”)

plt.grid(True)

plt.legend(fontsize=”small”)

plt.tight_layout()

plt.show()

# Save grand average to CSV

csv_path = os.path.join(base_dir, “hydrogen_grand_average.csv”)

with open(csv_path, “w”, newline=””) as f:

writer = csv.writer(f)

writer.writerow([“Frequency_MHz”, “Power_dB”])

for freq, power in zip(freqs/1e6, 10*np.log10(grand_avg + 1e-12)):

writer.writerow([freq, power])

print(f”Grand averaged spectrum saved to {csv_path}”)

if __name__ == “__main__”:

main()

What’s new

After plotting, the script writes hydrogen_grand_average.csv into ~/InterferometryData.
CSV format:

Frequency_MHz,Power_dB

1419.405,-72.3

1419.407,-72.1

…

Would you like me to also add an option to subtract a baseline (polynomial fit) from the grand average, so the hydrogen line pops out more clearly in the CSV/plot?

Excellent — here’s the enhanced script that does a baseline subtraction (polynomial fit) so the hydrogen line stands out more clearly in both the plot and the saved CSV.

plot_hydrogen_stack.py (with baseline removal)

import numpy as np

import matplotlib.pyplot as plt

import os

import csv

import numpy.polynomial.polynomial as poly

def read_psd_file(filename, fft_size=1024):

“””Read a .f32 file containing float32 PSD spectra.”””

data = np.fromfile(filename, dtype=np.float32)

spectra = data.reshape((-1, fft_size))

return spectra

def baseline_subtract(freqs, spectrum_db, deg=3):

“””

Fit a polynomial baseline to the spectrum and subtract it.

Returns baseline, residual.

“””

# Normalize frequency axis for numerical stability

x = (freqs – freqs.mean()) / (freqs.max() – freqs.min())

coefs = poly.polyfit(x, spectrum_db, deg)

baseline = poly.polyval(x, coefs)

residual = spectrum_db – baseline

return baseline, residual

def main():

base_dir = os.path.expanduser(“~/InterferometryData”)

files = sorted([f for f in os.listdir(base_dir) if f.endswith(“.f32”)])

if not files:

print(“No .f32 files found in ~/InterferometryData”)

return

fft_size = 1024

samp_rate = 2e6

center_freq = 1420.405e6

stacked = []

for f in files:

path = os.path.join(base_dir, f)

spectra = read_psd_file(path, fft_size=fft_size)

avg_spectrum = spectra.mean(axis=0)

stacked.append(avg_spectrum)

# Grand average

stacked = np.vstack(stacked)

grand_avg = stacked.mean(axis=0)

# Frequency axis

freqs = np.linspace(center_freq – samp_rate/2,

center_freq + samp_rate/2,

fft_size)

spectrum_db = 10*np.log10(grand_avg + 1e-12)

# Baseline subtraction

baseline, residual = baseline_subtract(freqs, spectrum_db, deg=3)

# Plot

plt.figure(figsize=(12,6))

plt.subplot(2,1,1)

plt.plot(freqs/1e6, spectrum_db, label=”Grand Average”)

plt.plot(freqs/1e6, baseline, ‘–‘, label=”Baseline (poly fit)”)

plt.title(“Hydrogen Line PSD (with Baseline Fit)”)

plt.xlabel(“Frequency (MHz)”)

plt.ylabel(“Power (dB)”)

plt.grid(True)

plt.legend()

plt.subplot(2,1,2)

plt.plot(freqs/1e6, residual, color=”black”)

plt.title(“Baseline-Subtracted Spectrum”)

plt.xlabel(“Frequency (MHz)”)

plt.ylabel(“Excess Power (dB)”)

plt.grid(True)

plt.tight_layout()

plt.show()

# Save CSV (both raw and baseline-subtracted)

csv_path = os.path.join(base_dir, “hydrogen_grand_average.csv”)

with open(csv_path, “w”, newline=””) as f:

writer = csv.writer(f)

writer.writerow([“Frequency_MHz”, “Power_dB”, “Baseline_dB”, “Residual_dB”])

for freq, p, b, r in zip(freqs/1e6, spectrum_db, baseline, residual):

writer.writerow([freq, p, b, r])

print(f”Grand averaged spectrum with baseline saved to {csv_path}”)

if __name__ == “__main__”:

main()

What’s new

Fits a 3rd-order polynomial baseline to the log-power spectrum.
Subtracts the baseline → leaves just the hydrogen line bump/dip.
Plots two panels: raw spectrum with baseline, and baseline-subtracted spectrum.
CSV now has four columns:
Frequency_MHz, Power_dB, Baseline_dB, Residual_dB
1419.405, -72.3, -72.1, -0.2
1419.407, -72.1, -72.0, -0.1
…

Great — here’s the final version with a command-line option for baseline polynomial degree. You can now try different baseline fits without touching the code.

plot_hydrogen_stack.py

import numpy as np

import matplotlib.pyplot as plt

import os

import csv

import argparse

import numpy.polynomial.polynomial as poly

def read_psd_file(filename, fft_size=1024):

“””Read a .f32 file containing float32 PSD spectra.”””

data = np.fromfile(filename, dtype=np.float32)

spectra = data.reshape((-1, fft_size))

return spectra

def baseline_subtract(freqs, spectrum_db, deg=3):

“””

Fit a polynomial baseline to the spectrum and subtract it.

Returns baseline, residual.

“””

# Normalize frequency axis for numerical stability

x = (freqs – freqs.mean()) / (freqs.max() – freqs.min())

coefs = poly.polyfit(x, spectrum_db, deg)

baseline = poly.polyval(x, coefs)

residual = spectrum_db – baseline

return baseline, residual

def main():

parser = argparse.ArgumentParser(description=”Plot and baseline-subtract hydrogen line spectra.”)

parser.add_argument(“–deg”, type=int, default=3,

help=”Polynomial degree for baseline fit (default=3)”)

parser.add_argument(“–fft_size”, type=int, default=1024,

help=”FFT size used in GNU Radio (default=1024)”)

parser.add_argument(“–samp_rate”, type=float, default=2e6,

help=”Sample rate in Hz (default=2e6)”)

parser.add_argument(“–center_freq”, type=float, default=1420.405e6,

help=”Center frequency in Hz (default=1420.405e6)”)

args = parser.parse_args()

base_dir = os.path.expanduser(“~/InterferometryData”)

files = sorted([f for f in os.listdir(base_dir) if f.endswith(“.f32”)])

if not files:

print(“No .f32 files found in ~/InterferometryData”)

return

stacked = []

for f in files:

path = os.path.join(base_dir, f)

spectra = read_psd_file(path, fft_size=args.fft_size)

avg_spectrum = spectra.mean(axis=0)

stacked.append(avg_spectrum)

# Grand average

stacked = np.vstack(stacked)

grand_avg = stacked.mean(axis=0)

# Frequency axis

freqs = np.linspace(args.center_freq – args.samp_rate/2,

args.center_freq + args.samp_rate/2,

args.fft_size)

spectrum_db = 10*np.log10(grand_avg + 1e-12)

# Baseline subtraction

baseline, residual = baseline_subtract(freqs, spectrum_db, deg=args.deg)

# Plot

plt.figure(figsize=(12,6))

plt.subplot(2,1,1)

plt.plot(freqs/1e6, spectrum_db, label=”Grand Average”)

plt.plot(freqs/1e6, baseline, ‘–‘, label=f”Baseline (poly deg={args.deg})”)

plt.title(“Hydrogen Line PSD (with Baseline Fit)”)

plt.xlabel(“Frequency (MHz)”)

plt.ylabel(“Power (dB)”)

plt.grid(True)

plt.legend()

plt.subplot(2,1,2)

plt.plot(freqs/1e6, residual, color=”black”)

plt.title(“Baseline-Subtracted Spectrum”)

plt.xlabel(“Frequency (MHz)”)

plt.ylabel(“Excess Power (dB)”)

plt.grid(True)

plt.tight_layout()

plt.show()

# Save CSV (both raw and baseline-subtracted)

csv_path = os.path.join(base_dir, “hydrogen_grand_average.csv”)

with open(csv_path, “w”, newline=””) as f:

writer = csv.writer(f)

writer.writerow([“Frequency_MHz”, “Power_dB”, “Baseline_dB”, “Residual_dB”])

for freq, p, b, r in zip(freqs/1e6, spectrum_db, baseline, residual):

writer.writerow([freq, p, b, r])

print(f”Grand averaged spectrum with baseline (deg={args.deg}) saved to {csv_path}”)

if __name__ == “__main__”:

main()

How to use

Run with defaults (3rd-order baseline):

python3 plot_hydrogen_stack.py

Try a flatter baseline (2nd-order polynomial):

python3 plot_hydrogen_stack.py –deg 2

Try more flexible fit (5th-order polynomial):

python3 plot_hydrogen_stack.py –deg 5

✅ This gives you full control over baseline removal and ensures the hydrogen line pops out cleanly.

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

SDRplay RSPDuo & radio interferometry

Leave a Reply Cancel reply