Hack radar

Some time ago, I saw at one of the forums a discussion of the possibility of direction finding aircraft, receiving reflected radar signals. The idea seemed interesting, and the goal was unattainable for everyday use, until the appearance of an SDR receiver based on a cheap DVB-T dongle based on the RTL2832U chipset . Using the dongle, you can digitize the received signal at a speed sufficient to obtain a resolution on the terrain of the order of hundreds of meters, which is quite suitable for the experiment.

In fairness, I do not really believe in the ability to find aircraft in this way, but the signal reflected by large ground objects should be clearly visible. The second limitation is that the radar uses a highly directional antenna for radiation and it is for reception, with a weakly directional television antenna that was used during the experiment, you can not expect high resolution.

Experiment: we connect the SDR dongle to a television antenna, we get a radar from the bushes, fortunately, it is located at the airport only a few kilometers and works in a meter television range. The signal is recorded using SDR # in a wav file with a speed of 2M measurements per second, which will give a theoretical resolution on the terrain of about 75 meters. The fact that the emitter and receiver are separated in space is neglected.

After the signals are recorded and the best sample is selected, we write a script that simulates a scan of the radar and synchronization according to the first powerful pulse.

import os
from PIL import Image, ImageDraw
import wave
import math
dir = os.path.dirname(os.path.abspath(__file__))
image = Image.new("RGB", (1000, 1000), (0, 0, 0))
(w, h) = image.size
sync_level = 45
seconds_max = 40
px_from_center = 30
seconds_per_spin = 20
wav = wave.open(dir + "/samples/134201.wav", mode="r")
(nchannels, sampwidth, framerate, nframes, comptype, compname) = wav.getparams()
data = wav.readframes(nframes)
bytes = nframes * nchannels * sampwidth
seconds = float(nframes) / framerate
px_per_km = int(framerate / 300000.0 * 2)
print(str(bytes) + " bytes, " + str(seconds) + " seconds")
t = 0
avg = 0
synchronized = 0
i = 0
while i < bytes - 4:
  l = abs(128 - ord(data[i]))
  r = abs(128 - ord(data[i + 2]))
  avg = avg * .9 + l * .1
  level = l + r
  if not synchronized and avg > sync_level:
    synchronized = 1
  if synchronized:
    s = float(i) / bytes * seconds
    if s >= seconds_max:
      break
    if t % (10 * px_per_km) == 0:
      level += 20
    if t < 400:
      x = int(w/2 - (t + px_from_center) * math.cos(s / seconds_per_spin * 2 * math.pi))
      y = int(h/2 - (t + px_from_center) * math.sin(s / seconds_per_spin * 2 * math.pi))
      image.putpixel((x, y), (level, level, level))
    t += 1
    if t >= 400:
      t = 0
      synchronized = 0
      avg = 0
  i += 4
image.save(dir + "/radar.png", "PNG")

The radar makes one revolution in 20 seconds. We select the level of synchronization and get a picture that is steadily repeating with each revolution.



Which is what we needed. The picture is quite blurry, but nothing prevents it from being improved by experimenting with the parameters and using the best equipment.

Sources along with the digitized signal - 73M