Radar using Red Pitaya for RF and Raspberry Pi 3 / 4 for quad-core signal processing. Initially used for ionospheric imaging at HF but via frequency translation could be used at microwave and other frequencies. Also can be used at low-band VHF for short-range compact radar work.
::: {.contents} :::
To connect over Ethernet from GNU Radio to the Red Pitaya, setup an image on the Red Pitaya's micro SD card and setup GNU Radio on your Linux laptop.
This assumes a brand new Red Pitaya with blank micro SD card.
-
format a micro SD card to FAT32
-
unzip Pavel Demins SD Card GNU Radio image (Under "getting started with GNU Radio") to this SD card:
unzip ecosystem-0.95-1-6deb253-sdr-transceiver.zip -d /media/sd-cardwhere
/media/sd-cardis the mounted SD card path to the FAT32-formatted SD card on your laptop. You can find this path with the commanddf. -
boot the Red Pitaya with this micro SD card. login/password
root
On your laptop:
mkdir ~/code
cd ~/code
git clone https://github.com/pavel-demin/red-pitaya-notes
On your laptop, create an executable file ~/rpgr with contents:
#!/bin/bash
export GRC_BLOCKS_PATH=$HOME/code/red-pitaya-notes/projects/sdr_transceiver/gnuradio
gnuradio-companion
Then in the future to startup GNU Radio with the modules for the Red Pitaya, just type on your laptop:
~/rpgr
CW_Doppler.pymodels beat frequency vs. radar frequency and target radial velocity.CW_red-pitaya.grcdemos a CW radar using Red Pitaya.
Beat frequency estimation demonstration:
python CWsubspace.py
python CWsubspace.py
The program FMCW_sim.grc is a simulation of FMCW radar, as simple as
possible. It leaves the receive signal glitches inherent to the
resetting of the sawtooth and triangle waveforms. These would be
eliminated by dropping those samples in post-processing as an easy
solution.
The program FMCW_red-pitaya.grc operates at low-band VHF in the
license-free bands available globally.
You can just generate the DSSS waveforms in memory or to disk on your PC. You don't actually need the Red Pitaya to work with these offline, to test your algorithms in the computer alone.
To run the Red Pitaya radar with DSSS on the bench, you need to
- generate a binary file containing a psuedorandom phase modulated
signal with
create_waveform - use GNU Radio to read that file and transmit it
- either on the same or separate Red Pitaya, receive the transmitted waveform and save it to file
- use a Python (or whatever) script to process the transmit and receive waveforms together e.g. cross-correlation, estimate number of lags to peak.
To transmit these waveforms with the Red Pitaya, tell GNU Radio to read the waveform file you generated and transmit it with the appropriate block diagram.
if no options specified, it plots only:
python create_waveform.py
-o directory saves binary psuedorandom phase modulated signal to directory for use with GNU Radio -q quiet, no plotting --filter smoothes transmit waveform, reducing splatter --fs fsampleHz sample frequency in Hz of baseband waveform
The following option is for Raspberry Pi only; no longer used
-f frequencyMHz center frequency in MHz to transmit from Raspberry Pi GPIO
This is to get started with GRC, to see how it reads/writes files
generated in an offline program such as create_waveform.py:
~/rpgr PM_sim.grc
variable dist_m is adjusted to make a simulated point target.
The output is processed with receive.py, which should match the
distance specified in dist_m in PM_sim.grc.
NOTE: there may be a bug with GRC Delay Block in GNU Radio 3.7.9; it seems to truncate the file causing a 120 km bias. We can just workaround this for now, because maybe it was fixed in GNU Radio 3.7.10.
Now we put the psuedorandom PM on the hardware transmitter/receiver with the Red Pitaya DAC and ADC respectively:
~/rpgr PM_red-pitaya.grc
This info is for Red Pitaya, but not necessarily what will be used for PiRadar. Just informational.
Note, this is not the CDMA waveform, just for testing/understanding how to send/receive phase modulated signals:
~/rpgr PSK_sim.grc
This saves the received packets to a file. They should match the transmitted packets. Again, this is not the actual on-air format we'll use:
~/rpgr PSK_red-pitaya.grc
The .grc are for GNU Radio Companion (GRC), the graphical IDE.
Currently we are using GRC 3.7.9 on Ubuntu 16.04 for bench development.
Of course, GNU Radio also runs on
Of course, the actual fielded system will be on the Red Pitaya without the GUI.
- "signal source" is simulating a DDS
- "multiply" is simulating DUC (with the DDS).
- "rational resampler" controls how fast the bits are played back and hence the instantaneous bandwidth of the signal.
- "multiply const" controls the transmitter power. It would need to be like 0.01 or less to avoid overloading the Red Pitaya input if connecting output to input.
NOTE: you must have a softlink to red_pitaya.py in your project
directory where
the .grc files are, or you will get
ImportError: module red_pitaya not found.
These paths are for GNU radio 3.7.9 on Ubuntu 16.04.
- Graphical block based on .xml in
/usr/share/gnuradio/grc/blocks - Corresponding Python code in
/usr/lib/python2.7/dist-packages/gnuradio - Python code calls C++ code under
/usr/include/gnuradiocompiled with SWIG
When using GNU Radio without GRC from Python, you are using #2 and #3.
Transponder (acts as a frequency-translating, amplifying target back to the radar source) [xpond_red-pitaya.grc]{.title-ref}
The material in this section is for using Raspberry Pi as the transmitter, which we no longer use.
- Raspberry Pi module has been added to https://github.com/jvierine/digital_rf
- can use https://github.com/jvierine/gr-drf
We use the Red Pitaya to transmit instead. The program below uses Rpi GPIO to transmit waveforms, but we found the jitter way too high to use for radar.
On your Raspberry Pi (it will ask for sudo password):
./setup_raspberrypi.sh
python install -e .
Or on your PC:
python install -e .
centered @ 100.1MHz:
./create_waveform.py -f 100.1
