Build a Raspberry Pi Flight Tracker with Live OLED Telemetry

Project Overview & Difficulty Rating

A dedicated raspberry pi flight tracker receives Automatic Dependent Surveillance-Broadcast (ADS-B) signals from commercial aircraft at 1090 MHz, decodes the telemetry, and plots local air traffic. While most builders stop at installing the FlightAware PiAware software and viewing the web interface, true embedded enthusiasts want physical, at-a-glance telemetry. This guide walks you through building a headless ADS-B receiver with a live I2C OLED display that pulls real-time JSON data from dump1090 and renders aircraft counts, closest approaches, and system status.

Hardware Spec Sheet & Parts List

Sourcing the right RF components is where most DIY flight trackers fail. A generic VHF antenna and a cheap, unshielded SDR dongle will yield a 5-mile range. The parts below will push your reliable reception radius to 150+ miles (line-of-sight dependent).

Wiring the I2C OLED Telemetry Display

We are tapping into the Raspberry Pi's hardware I2C bus to communicate with the SSD1306 OLED. The Pi's internal pull-up resistors (1.8kΩ) are generally sufficient for a single OLED module on a short wire run. If you experience display flickering, you may need to add external 4.7kΩ pull-ups to the SDA and SCL lines.

Pin Mapping Table

Physical Assembly Steps

1. Flash the OS: Install Raspberry Pi OS Lite (64-bit, Bookworm) via Raspberry Pi Imager. Enable SSH and configure WiFi in the advanced settings.
2. Enable I2C: Boot the Pi, run sudo raspi-config, navigate to Interface Options > I2C, and enable it. Reboot.
3. Verify I2C Bus: Run sudo i2cdetect -y 1. You should see 3c in the grid, confirming the OLED is detected at address 0x3C.
4. Connect SDR: Plug the RTL-SDR V4 into one of the blue USB 3.0 ports. Connect the 1090MHz antenna and place it as high as possible (attic or roof peak).
5. Install PiAware: Follow the official FlightAware PiAware setup script to install dump1090-fa and claim your station.

Python Telemetry Code for dump1090

The dump1090-fa service runs a local web server that outputs a JSON file (aircraft.json) every second. The Python script below polls this endpoint, parses the JSON, calculates the closest aircraft, and renders it to the OLED.

Prerequisites: Install the required Python packages via terminal:
sudo apt install python3-pip i2c-tools
pip3 install adafruit-blinka adafruit-circuitpython-ssd1306 pillow requests --break-system-packages

import time
import json
import requests
import board
import digitalio
from PIL import Image, ImageDraw, ImageFont
import adafruit_ssd1306

# --- PIN DEFINITIONS & HARDWARE CONFIG ---
# SDA -> GPIO 2 (Physical Pin 3)
# SCL -> GPIO 3 (Physical Pin 5)
# Using hardware I2C bus 1
i2c = board.I2C()

# Initialize SSD1306 128x64 OLED at I2C address 0x3C
disp = adafruit_ssd1306.SSD1306_I2C(128, 64, i2c, addr=0x3C)
disp.fill(0)
disp.show()

# Create blank image for drawing
image = Image.new('1', (disp.width, disp.height))
draw = ImageDraw.Draw(image)

# Load default font (fallback to DejaVu if available)
try:
    font = ImageFont.truetype('/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf', 12)
    font_small = ImageFont.truetype('/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf', 10)
except IOError:
    font = ImageFont.load_default()
    font_small = font

DUMP1090_URL = "http://127.0.0.1:8080/data/aircraft.json"

def get_flight_data():
    """Fetch and parse aircraft JSON from dump1090-fa."""
    try:
        response = requests.get(DUMP1090_URL, timeout=2)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f"Data fetch error: {e}")
        return None

def calculate_closest(aircraft_list):
    """Find the aircraft with the lowest altitude/nearest distance."""
    if not aircraft_list:
        return None, 0
    # Filter for aircraft with valid altitude and distance data
    valid_ac = [ac for ac in aircraft_list if 'alt_baro' in ac and ac['alt_baro'] != 'ground']
    if not valid_ac:
        return None, len(aircraft_list)
    
    closest = min(valid_ac, key=lambda x: x.get('alt_baro', 99999))
    return closest, len(aircraft_list)

while True:
    data = get_flight_data()
    draw.rectangle((0, 0, disp.width, disp.height), outline=0, fill=0)
    
    if data and 'aircraft' in data:
        closest_ac, total_count = calculate_closest(data['aircraft'])
        
        # Draw Header
        draw.text((0, 0), f"Flights: {total_count}", font=font, fill=255)
        draw.line((0, 14, 128, 14), fill=255)
        
        if closest_ac:
            flight_id = closest_ac.get('flight', 'N/A').strip()
            alt = closest_ac.get('alt_baro', 'N/A')
            speed = closest_ac.get('gs', 'N/A')
            
            draw.text((0, 18), f"ID: {flight_id}", font=font_small, fill=255)
            draw.text((0, 30), f"ALT: {alt} ft", font=font_small, fill=255)
            draw.text((0, 42), f"SPD: {speed} kts", font=font_small, fill=255)
        else:
            draw.text((0, 25), "No airborne traffic", font=font_small, fill=255)
    else:
        draw.text((0, 20), "Waiting for", font=font, fill=255)
        draw.text((0, 35), "dump1090 data...", font=font, fill=255)

    disp.image(image)
    disp.show()
    time.sleep(2)  # Poll every 2 seconds to reduce CPU load

Debugging: Fixing "Connection Refused" & Hardware Faults

When integrating software-defined radio with physical displays, the failure modes usually fall into USB power starvation or service binding errors. If your OLED stays blank and the terminal throws an error, follow this decision path.

The Exact Error String

If the script crashes immediately upon execution, you will likely see this exact traceback:

requests.exceptions.ConnectionError: HTTPConnectionPool(host='127.0.0.1', port=8080): Max retries exceeded with url: /data/aircraft.json (Caused by NewConnectionError('<urllib3.connection.HTTPConnection object at 0x...>: Failed to establish a new connection: [Errno 111] Connection refused'))

The First Three Things to Check

1. Is the dump1090-fa service actually running?
   Run systemctl status dump1090-fa. If it is dead or failed, the JSON endpoint doesn't exist. Restart it with sudo systemctl restart dump1090-fa and check the journal logs (journalctl -u dump1090-fa -e) for USB disconnects.
2. Is the RTL-SDR dongle recognized and unclaimed?
   Run lsusb to ensure the Pi sees the Realtek RTL2838UHIDIR. Then run rtl_test. If you get Kernel driver is active, trying to detach... or a failure to claim the interface, another process (like a stale rtl_tcp instance) is hogging the USB endpoint. Reboot the Pi to clear the lock.
3. Did the web server port change?
   By default, dump1090-fa serves its internal web interface on port 8080. However, if you installed the full PiAware lighttpd proxy stack, the JSON might only be accessible via port 80 at http://127.0.0.1/dump1090-fa/data/aircraft.json. Test both URLs in the Pi's terminal using curl.

Ranked Causes for Intermittent USB Drops

If your tracker runs for 12 hours and then stops decoding, the RTL-SDR has likely dropped off the USB bus. Ranked from most to least likely:

• Cause 1: Inadequate Power Supply. The RTL-SDR V4 draws up to 280mA during heavy decoding. If you are using a cheap phone charger instead of the official Raspberry Pi 27W USB-C PSU, the Pi's brownout detector will throttle the USB ports. Fix: Use the official PSU.
• Cause 2: Thermal Throttling of the R820T2 Chip. The tuner IC inside the dongle gets hot. If enclosed in a tight 3D-printed case without ventilation, it will overheat and crash. Fix: Add a small aluminum heatsink to the metal shielding of the SDR.
• Cause 3: USB Cable RF Interference. The USB cable acts as an antenna for the 1090MHz signals, causing common-mode noise that desensitizes the tuner. Fix: Use a short, shielded USB cable with a ferrite choke near the Pi connection.

Extending and Simplifying Your Tracker Build

Once the baseline raspberry pi flight tracker is stable, you can tailor the hardware to your specific environment and budget.

How to Extend (Maximize Range)

To push your range beyond 200 miles, you need to improve your Signal-to-Noise Ratio (SNR). Add a 1090MHz Surface Acoustic Wave (SAW) Filter and a Low Noise Amplifier (LNA) between the antenna and the SDR. The RTL-SDR V4 has a built-in bias-tee; you can enable it in the dump1090-fa configuration file (/etc/default/dump1090-fa) by adding --enable-rtlsdr-bias-tee to the RECEIVER_OPTIONS string. This sends 4.5V up the coaxial cable to power an external LNA at the antenna base, minimizing cable loss.

How to Simplify (Reduce Cost & Power)

If you want to deploy this in an attic or remote shed where power is limited, swap the Pi 4B for a Raspberry Pi Zero 2 W. The Zero 2 W has the same quad-core Cortex-A53 architecture as the Pi 3B+ and can comfortably run dump1090-fa and the Python OLED script. You will need a micro-USB to USB-OTG adapter for the SDR dongle, and you must ensure your power supply delivers a clean 5V/2.5A, as the Zero's power management IC is highly sensitive to voltage droop.

Raspberry Pi Flight Tracker FAQ

Can I use a Raspberry Pi Zero 2 W for this flight tracker build?

Yes. The Raspberry Pi Zero 2 W has sufficient CPU overhead to run dump1090-fa and render the OLED telemetry. However, it only has 512MB of RAM. You must disable the PiAware MLAT (Multilateration) client if you experience out-of-memory crashes, as MLAT calculations are highly memory-intensive. The standard ADS-B decoding and JSON generation will work flawlessly.

Why is my RTL-SDR dongle getting hot and dropping the USB connection?

The R820T2 tuner and RTL2832U demodulator ICs inside the dongle dissipate significant heat, especially when sampling at the 2.4 MSPS rate required for ADS-B. If the dongle is inside an unventilated enclosure, it will exceed its thermal limit (typically around 75°C) and the internal voltage regulator will shut it down. Attach a 14x14x6mm aluminum heatsink to the flat metal shield of the dongle and ensure your Pi case has active airflow.

Do I need a 1090MHz specific antenna, or will a standard VHF whip work?

You absolutely need a 1090MHz specific antenna. ADS-B signals are transmitted at a very low power (typically 125W to 250W at the aircraft transmitter, which is weak by the time it reaches the ground). A standard VHF/UHF whip is tuned for 144-450 MHz. Using it at 1090 MHz results in a high Standing Wave Ratio (SWR), meaning the antenna will reject the signal and reflect it back. A dedicated 1090MHz dipole or ground-plane antenna is physically cut to ~5.1 inches per element, providing the necessary resonance to pull in weak, distant aircraft.

How do I map the physical OLED display to a different I2C address?

Most SSD1306 128x64 modules default to I2C address 0x3C. If you bought a variant with a different address (usually 0x3D), or if you have multiple devices on the I2C bus causing a collision, check the address by running sudo i2cdetect -y 1. Once confirmed, update the initialization line in the Python code to: disp = adafruit_ssd1306.SSD1306_I2C(128, 64, i2c, addr=0x3D).