✪ Apps & Software ✪

Now that you have your own ADS-B receiver, and you’re running ADS-B Radar on your Mac, perhaps it would be great to know what airplane is currently overhead when you’re getting a coffee 🙂

The Raspberry Pico W and the Pico Display from Pimoroni come to the rescue. Although the display is really small, it has a super low power consumption and you can easily place it somewhere discrete.

What will you need:

• Pico WH (WiFi version with header) – Approx. 9 EUR
• Pimoroni Pico Display Pack unit – Approx. 18 EUR

As we are already processing ADS-B signals with a Raspberry Pi Zero and dump1090, we will use this to pre-process the data we need for the Pico W. This will make it easier on the small Pico, which has limited capabilities.

There are two options, use FR24 or use a public API adsbdb.com.

#1: FR24:

To retrieve more interesting data, we need to use the FR24 API.
PS: It seems the API is offline or no longer for free.
Install like this on your Pi that feeds FR24:

pip3 install FlightRadar24

Then we create a little shell script named “overhead.sh” which we will run every two minutes once we’re ready:

#!/bin/bash
python3 /home/pi/overhead.py
chmod 777 /tmp/overhead.json

This will be the main Python script to process the JSON file from FR24, name it “overhead.py”. Make sure to enter the correct LAT & LON of your home receiver and figure out the search area, which is a rectangle defined by a top left and bottom right LAT/LON coordinate. You can use Apple Maps and drop a pin to get these:

#!/usr/bin/env python3
# Find closest airplane flying overhead
# (c) JF Nutbroek
# 08/10/2023

from FlightRadar24 import FlightRadar24API
from urllib.request import urlopen
from datetime import datetime
from datetime import timezone

import math
import json

# User defined

url     = "http://localhost/dump1090/data/aircraft.json"
lathome = 45.9  # Position ADS-B receiver
lonhome = 6.3   # Position ADS-B receiver
zone    = {"tl_y": 46.23, "tl_x": 5.93, "br_y": 45.66, "br_x": 6.83} # Search area topleft x bottomright

### Start

# Haversine formula example in Python
# Author: Wayne Dyck
def distance(origin, destination):
    lat1, lon1 = origin
    lat2, lon2 = destination
    radius = 6371 # km earth radius
    dlat = math.radians(lat2-lat1)
    dlon = math.radians(lon2-lon1)
    a = math.sin(dlat/2) * math.sin(dlat/2) + math.cos(math.radians(lat1)) \
        * math.cos(math.radians(lat2)) * math.sin(dlon/2) * math.sin(dlon/2)
    c = 2 * math.atan2(math.sqrt(a), math.sqrt(1-a))
    d = radius * c
    return d

# Convert timestamp to UTC
def process_timestamp(timestamp):
    if timestamp and timestamp != 0:
        date = datetime.fromtimestamp(timestamp, timezone.utc)
        utc = date.strftime("%H:%M")
    else:
        utc = ""
    return utc

# Find flights in specified zone
def find_flight(inzone, flightid):
    fr_api  = FlightRadar24API()
    bounds  = fr_api.get_bounds(inzone)
    flights = fr_api.get_flights(bounds=bounds)
    for thisflight in flights:
        if flightid in thisflight.callsign.replace(" ", "").upper():
            flightdetails = fr_api.get_flight_details(thisflight.id)
            return thisflight, flightdetails
    return None, None

# Write JSON for Pico W
def writeresult(flightdict):
    json_object = json.dumps(flightdict)
    with open("/tmp/overhead.json", "w", encoding="utf-8") as outfile:
        outfile.write(json_object)

### Find the closest airplane

aircraft = []

try:
    response = urlopen(url)
    data_json = json.loads(response.read())
    aircraft = data_json['aircraft']
except:
    exit()

closest       = 1000               # km distance of closest plane
closestflight = ''                 # Will hold flight number
dictionary    = {"flight":"none"}  # Empty dictionary
speed         = 0
vert_rate     = 0
altitude      = 0
compass       = ["N","NNE","NE","ENE","E","ESE","SE","SSE","S","SSW","SW","WSW","W","WNW","NW","NNW","N"]
track         = 0
heading       = ""
newflight     = True

for airplane in aircraft:
    if 'lat' in airplane:
        if 'lon' in airplane:
            if 'flight' in airplane:
                if 'altitude' in airplane:
                    altitude = int(airplane['altitude'])
                    if 'vert_rate' in airplane:
                        vert_rate = int(airplane['vert_rate'])
                    if 'speed' in airplane:
                        speed = int(airplane['speed'])
                    if 'track' in airplane:
                        track = int(airplane['track'])
                        heading =  str(track) + " degrees " + compass[min(round((track % 360) / 22.5), 16)]
                    flightdis = distance((lathome, lonhome), (airplane['lat'], airplane['lon']))
                    flighthgt = altitude * 0.0003048
                    dis = math.floor(math.sqrt(flightdis**2 + flighthgt**2))
                    if dis < closest:
                        closest = dis
                        closestflight = airplane['flight'].replace(" ", "").upper()

if closestflight != '':
    rangekm = distance((zone["tl_y"], zone["tl_x"]), (zone["br_y"], zone["br_x"])) / 2
    if closest < rangekm:
        flight, details = find_flight(zone, closestflight)
        if flight != None:
            dictionary = {
                "flight": flight.number,
                "airline": details["airline"]["name"],
                "altitude": str(altitude),
                "vert_rate": str(vert_rate),
                "speed": str(speed),
                "origin_iata": flight.origin_airport_iata,
                "destination_iata": flight.destination_airport_iata,
                "model": details["aircraft"]["model"]["text"],
                "origin": details["airport"]["origin"]["name"],
                "destination": details["airport"]["destination"]["name"],
                "departure": process_timestamp(details["time"]["real"]["departure"]),
                "eta": process_timestamp(details["time"]["other"]["eta"]),
                "distance": str(closest),
                "track": heading
                }
            writeresult(dictionary)
        else:
            writeresult(dictionary)
    else:
        writeresult(dictionary)
else:
    writeresult(dictionary)

#2 Use the adsbdb.com public API:

Independent on the FR24 API (which is not official), you can also use a public API called adsbdb.com. Create a little shell script named “overhead.sh” which we will run every two minutes once we’re ready:

#!/bin/bash
python3 /home/pi/overhead.py
chmod 777 /tmp/overhead.json

This will be the main Python script to process the JSON file from adsbdb.com, name it “overhead.py”:

#!/usr/bin/env python3
#!/usr/bin/env python3
# Find closest airplane flying overhead
# (c) JF Nutbroek
# 08/10/2023

from urllib.request import urlopen
from datetime import datetime
from datetime import timezone

import math
import json

# User defined

url     = "http://localhost/dump1090/data/aircraft.json"
lathome = 45.9  # Position ADS-B receiver
lonhome = 6.3   # Position ADS-B receiver

### Start

# Haversine formula example in Python
# Author: Wayne Dyck
def distance(origin, destination):
    lat1, lon1 = origin
    lat2, lon2 = destination
    radius = 6371 # km earth radius
    dlat = math.radians(lat2-lat1)
    dlon = math.radians(lon2-lon1)
    a = math.sin(dlat/2) * math.sin(dlat/2) + math.cos(math.radians(lat1)) \
        * math.cos(math.radians(lat2)) * math.sin(dlon/2) * math.sin(dlon/2)
    c = 2 * math.atan2(math.sqrt(a), math.sqrt(1-a))
    d = radius * c
    return d

# Find flights
def find_adsbdb(flightid, hex):
    try:
        if hex == "":
            response = urlopen("https://api.adsbdb.com/v0/callsign/" + flightid)
        else:
            response = urlopen("https://api.adsbdb.com/v0/aircraft/" + hex + "?callsign=" + flightid)
        data_json = json.loads(response.read())
        aircraft = data_json['response']
        if flightid in aircraft['flightroute']['callsign_icao']:
            return flightid, aircraft
        else:
            return None, None
    except:
        return None, None

# Write JSON for Pico W
def writeresult(flightdict):
    json_object = json.dumps(flightdict)
    with open("/tmp/overhead.json", "w", encoding="utf-8") as outfile:
        outfile.write(json_object)

### Find the closest airplane

aircraft = []

try:
    response = urlopen(url)
    data_json = json.loads(response.read())
    aircraft = data_json['aircraft']
except:
    exit()

closest       = 1000               # km distance of closest plane
closestflight = ''                 # Will hold flight number
dictionary    = {"flight":"none"}  # Empty dictionary
speed         = 0
vert_rate     = 0
altitude      = 0
compass       = ["N","NNE","NE","ENE","E","ESE","SE","SSE","S","SSW","SW","WSW","W","WNW","NW","NNW","N"]
track         = 0
heading       = ""
newflight     = True
hex           = ""

for airplane in aircraft:
    if 'lat' in airplane:
        if 'lon' in airplane:
            if 'flight' in airplane:
                if 'altitude' in airplane:
                    altitude = int(airplane['altitude'])
                    if 'hex' in airplane:
                        hex = airplane['hex']
                    if 'vert_rate' in airplane:
                        vert_rate = int(airplane['vert_rate'])
                    if 'speed' in airplane:
                        speed = int(airplane['speed'])
                    if 'track' in airplane:
                        track = int(airplane['track'])
                        heading =  str(track) + " degrees " + compass[min(round((track % 360) / 22.5), 16)]
                    flightdis = distance((lathome, lonhome), (airplane['lat'], airplane['lon']))
                    flighthgt = altitude * 0.0003048
                    dis = math.floor(math.sqrt(flightdis**2 + flighthgt**2))
                    if dis < closest:
                        closest = dis
                        closestflight = airplane['flight'].replace(" ", "").upper()

if closestflight != '':
    #print(closestflight)
    #print(hex)
    flight, details = find_adsbdb(closestflight, hex)
    if flight != None:
        dictionary = {
            "flight": flight,
            "airline": details["flightroute"]["airline"]["name"],
            "altitude": str(altitude),
            "vert_rate": str(vert_rate),
            "speed": str(speed),
            "origin_iata": details["flightroute"]["origin"]["iata_code"],
            "destination_iata": details["flightroute"]["destination"]["iata_code"],
            "model": details["aircraft"]["type"],
            "origin": details["flightroute"]["origin"]["name"],
            "destination": details["flightroute"]["destination"]["name"],
            "departure": "",
            "eta": "",
            "distance": str(closest),
            "track": heading
        }
        writeresult(dictionary)
    else:
        writeresult(dictionary)
else:
    writeresult(dictionary)

The following is the same for either FR24 or adsbdb.com:

To create a 2 minute crontab use this (note: there is a limit on the amount of requests you can send, a 2 minute interval should keep you below it):

Nano /etc/crontab
*/2 *     * * *   root    sh /home/pi/overhead.sh

We need to make the JSON file we created accessible to the local internet for the Pico W to download:

cd /var/www/html/
sudo ln -s /tmp/overhead.json overhead.json

To prepare the Pico you can press the display on the header, do it gently and make sure the USB side is indeed on the USB side of the Pico.

Now we can connect the Pico W with Display and with an official USB Pico cable (most cables will not work!) to your Mac. Install Thonny for macOS and you will be able to connect to the Pico.

Download & install the Pimoroni custom MicroPython for the "Pico W" version (keep the boot select button pressed and then plug it into the Mac) - copy the file over and unplug & replug the Pico in the Mac. Then use Thonny to create two files on the Pico. The first one is named "secrets.py" and will hold your WiFi networks name and password:

SSID = "Your Wi-Fi Network"
PASS = "Your Password"

The next file should be named "main.py" and will run every time the Pico has power and boots up:

# (c) JF Nutbroek
# 08/10/2023

from picographics import PicoGraphics, DISPLAY_PICO_DISPLAY
from pimoroni import RGBLED

import network
import secrets
import urequests

from time import sleep
from math import floor, pi, sin, cos
from machine import Timer, WDT

# User defined input

# URL to local json file using http
url = "http://192.168.68.120/overhead.json"

pollinterval = 10    # Interval in seconds for a new JSON poll
brightness   = 0.5   # Brightness of the display
sleepafter   = 10    # Number of JSON polls without aircraft

# ********* Start

display = PicoGraphics(display=DISPLAY_PICO_DISPLAY, rotate=0)
display.set_font("bitmap8")
display.set_backlight(brightness)

# Colors
BLACK  = display.create_pen(0, 0, 0)
GREEN  = display.create_pen(50, 205, 50)
RED    = display.create_pen(200, 0, 0)
BLUE   = display.create_pen(0, 191, 255)
WHITE  = display.create_pen(255, 255, 255)
ORANGE = display.create_pen(255, 140, 0)
YELLOW = display.create_pen(255, 255, 0)    
    
# Switch LED off
led = RGBLED(6, 7, 8)
led.set_rgb(0, 0, 0)

# Overhead info
flightinfo       = {"flight":"none"}
flight           = ""
airline          = ""
altitude         = ""
vert_rate        = ""
speed            = ""
origin_iata      = ""
destination_iata = ""     
model            = ""
origin           = ""
destination      = ""
departure        = ""
eta              = ""
distradar        = ""
heading          = ""
xpos             = 20
textpos          = 0
infopos          = 0
timedout         = 0

# Write text centered or right aligned
def writetext(text, y, center, size, color):
    width = display.measure_text(text, size)
    display.set_pen(color)
    if center:
        display.text(text, floor((240 - width) / 2), y, 300, size)
    else:
        display.text(text, 240 - width, y, 240, size)        

def radar(steps, rounds, message):
    for _ in range(rounds):
        for n in range(0, steps):
            display.set_pen(BLACK)
            display.clear()
            for y in range(60, 0, -10):
                display.set_pen(GREEN)
                display.circle(120, 68, y)
                display.set_pen(BLACK)
                display.circle(120, 68, y - 3)
            x1 = 120 + (cos(2 * pi * (n / steps)) * 65)
            y1 = 68 + (sin(2 * pi * (n / steps)) * 65)    
            display.line(120, 68, int(x1), int(y1), 5)
            if message != "":
                display.set_pen(WHITE)
                display.text(message, 0, 0, 240, 2)
            display.update()

# Read JSON
def readjson():
    global flightinfo, timedout
    flightinfo = {"flight":"none"}
    led.set_rgb(138, 43, 226)
    try:
        if wlan.isconnected():
            flightinfo = urequests.get(url).json()
            led.set_rgb(0, 0, 0)
        else:
            led.set_rgb(255, 0, 0)
            radar(180, 1)
    except:
        led.set_rgb(255, 0, 0)
    if 'flight' in flightinfo:
        if flightinfo['flight'] == "none":
            timedout += 1
        else:
            timedout = 0

def resetwdTimer(wdTimer):
    global wd
    wd.feed()
    
# Read JSON
def update_display(myTimer):
    if timedout < sleepafter:
        readjson()
    
# Startup
radar(180, 1, "v1.1")

# Connect to WiFi
wlan = network.WLAN(network.STA_IF)
wlan.active(True)
wlan.connect(secrets.SSID, secrets.PASS)
sleep(1)

# First JSON download
if wlan.isconnected():
    readjson()
else:
    radar(180, 5, "No WiFi")
    readjson()

# Start the timers
myTimer = Timer()
myTimer.init(period = pollinterval * 1000, mode = Timer.PERIODIC, callback = update_display)
wdTimer = Timer()
wdTimer.init(period = 5000, mode = Timer.PERIODIC, callback = resetwdTimer)
# Automatic reboot after 6 seconds of inactivity
wd = WDT(timeout = 6000)

while True:
        
    # Sleep Mode when no new data is received
    if timedout == sleepafter:
        display.set_pen(BLACK)
        display.clear()
        display.update()
        display.set_backlight(0.0)
    if timedout >= sleepafter:
        sleep(pollinterval * 10)
        readjson()
        if timedout == 0:
            display.set_backlight(brightness)
        else:
            continue
    
    # Start drawing
    display.set_pen(BLACK)
    display.clear()
        
    if 'flight' in flightinfo:
      flight = flightinfo['flight']
      
    if flight == "none":
        radar(180, 4, "Nothing")
        continue
    
    if 'airline' in flightinfo:
      airline = flightinfo['airline']
    
    if 'altitude' in flightinfo:
      altitude = flightinfo['altitude']
      
    if 'vert_rate' in flightinfo:
      vert_rate = flightinfo['vert_rate']
      
    if 'speed' in flightinfo:
      speed = flightinfo['speed']
      
    if 'origin_iata' in flightinfo:
      origin_iata = flightinfo['origin_iata']
      
    if 'destination_iata' in flightinfo:
      destination_iata = flightinfo['destination_iata']      
      
    if 'model' in flightinfo:
      model = flightinfo['model']
      
    if 'origin' in flightinfo:
      origin = flightinfo['origin']
      
    if 'destination' in flightinfo:
      destination = flightinfo['destination']
      
    if 'departure' in flightinfo:
      departure = flightinfo['departure']
      
    if 'eta' in flightinfo:
      eta = flightinfo['eta']
      
    if 'distance' in flightinfo:
        distradar = flightinfo['distance']
          
    if 'track' in flightinfo:
        heading = flightinfo['track']
            
    # Show main flight info
    display.set_pen(YELLOW)
    display.text(origin_iata, 0, 0, 240, 3)
    writetext(destination_iata, 0, False, 3, YELLOW)
    display.set_pen(ORANGE)
    display.text(departure, 0, 48, 240, 2)
    writetext(eta, 48, False, 2, ORANGE)
    if flight != "N/A":
        writetext(flight, 0, True, 3, ORANGE)
    
    # Draw animation
    if xpos < 220:
        xpos += 1
    else:
        xpos = 20
    display.set_pen(BLUE)
    display.line(20, 35, xpos, 35, 2)
    display.circle(25, 35, 8)
    if xpos > 210:
        display.set_pen(WHITE)    
    display.circle(225, 35, 8)
    display.set_pen(GREEN)
    display.triangle(xpos, 25, xpos, 45, xpos + 10, 35)

    # Write airline name - shorten if it is too long
    airline_width = display.measure_text(airline, 2)
    timing_width = display.measure_text(departure + eta, 2)
    if (airline_width + timing_width) > 230:
        shorten = airline_width / (230 - timing_width) 
        stripped = min(12, len(airline) - int(len(airline) * shorten) - 3)
        writetext(airline[0:stripped] + "..", 48, True, 2, WHITE)
    else:
        writetext(airline, 48, True, 2, WHITE)
    
    # Write scrolling text for full airport names
    longname = origin + " to " + destination
    longwidth = display.measure_text(longname, 2)
    display.set_pen(GREEN)
    display.text(origin + " -> " + destination, 240 - textpos, 78, 1000, 2)
    textpos += 2
    if textpos > (longwidth + 240):
        textpos = 0
       
    # Write scrolling text for all other details  
    longinfo = model + ", Altitude " + str(int(int(altitude) * 0.0003048)) + " km, Speed " + str(int(int(speed) * 1.852)) + " kmh, "
    if ((int(vert_rate) > -64) and (int(vert_rate) < 64)):
        longinfo += "Level Flight, "
    elif int(vert_rate) < -64:
        longinfo += "Descending, "
    else:
        longinfo += "Ascending, "
    longinfo += distradar + " km distance, " + heading 
    longinfowidth = display.measure_text(longinfo, 3)
    display.set_pen(BLUE)
    display.text(longinfo, 240 - infopos, 111, 5000, 3)
    infopos += 3
    if infopos > (longinfowidth + 240):
        infopos = 0

    # Update everything to the screen
    display.update()
    sleep(0.01)

That should be it, now you need to find a place for your new Pico Display with real-time flight info!

Success!