Introduction
Webhook/API
Query
Raspberry Pi Relay
Photon 2 Programming
Parsing Data
Sorting the Planes
Turning On the Lights
Conclusion

Published January 21, 2026 © GPL3+

Aircraft Approach Visualization

This uses a short LED strip to show where planes are on an approach and their altitude in real time.

IntermediateShowcase (no instructions)8 hours79

Things used in this project

Hardware components

Digilent WS2812 Addressable LED Strip

Any individually addressable LED strip works. You should probably know how to solder to make the exact length you want.

Particle Photon 2

Software apps and online services

opensky API

Story

Introduction

This project was made for the data visualization project for my Physical Computing class. The whole idea is for the LED strip to represent where planes are in the sky with each LED light. The lights move and change color based on the plane's activities.

I used a Particle Photon 2 for the project because it is super neat and easy to connect this microcontroller to the internet. 10/10 microcontroller, would recommend (I bought 2 more).

All runways are in reference to Chicago O'Hare International Airport (ORD).

Webhook/API

Query

This was done using the OpenSky Network and their REST API which has extensive documentation here.

The easiest and most demonstratable example of how this API works can be done with an anonymous API request following the basic query setup and putting that into a web browser. For example, a query to find all aircraft in a rectangle around 28C/10C would look like this:

https://opensky-network.org/api/states/all?lamin=41.96414&lomin=-88.22404&lamax=41.96850&lomax=-87.59579

A visual representation of the area the query looks at

Raspberry Pi Relay

Now ideally, one should be able to put that into a GET request service, such as the Particle one. However it never seemed to work for me. No matter what authentication I tried. No matter what access token. Parameters. Headers. Response template. NOTHING would get me past the ETIMEDOUT error (the particle error when the API took too long to respond). I put it in the OpenSky discord and Particle Forum and nothing worked. If you find a way, please let me know; that would make this all so much simpler.

To get around this, I used an old Raspberry Pi 3 that I had laying around to pull from the OpenSky API, then push that data to my particle using Particle.publish(). The code can be seen in the "code" section of this project.

Pi just acts as a middle man and doesn't actually filter any data.

One good thing is this relay method works. Another good thing is that it can use OAuth2 client credentials for me so that I can get 4000 API credits per day. One bad thing is that if I ever want to change the geo-fence for the runway, I have to go into the raspberry pi and change the code myself.

Photon 2 Programming

This is where all the fun begins. I'm going to provide visualizations on how each step is done, and not really get into the programming itself. For more info, go look at the "Main" code down below on this project. I documented it pretty well with in-line comments so you can follow along with the actual code if you'd like. I will reference lines so its easier to follow.

Parsing Data

Firstly, the JSON file returned by OpenSky API has all the planes in the imaginary box. ALL the planes. Cruising, departures, ground...everything is there. So first we have to sort them! I used this to get each data value, and this handy tool to make my life easier. Here is how I did it (Line 45):

Its important to note that after I determine the plane is one that I want, I take all of its data and put it into an airplane object so I never need to touch the JSON again. The plane object looks like this:

class Airplane {
public:
    float lon;
    int alt;
    String callsign;
    
    Airplane(float pLon, int pAlt, const char* pClsgn) {
        lon = pLon;
        alt = pAlt * 3.281;
        callsign = String(pClsgn);
    }

    //dont worry about what I just deleted//
};

These objects are added into an array so I can store and sort them easily.

Sorting the Planes

I'm not sure what the OpenSky API sorts its planes by when it returns the JSON, but its definitely not distance from ORD. Therefore, I have to take the jumbled array of objects and put them into an array that will turn on the lights.

Its important to note that the length of the array that holds the jumbled airplane objects will always be less than the length of the array that represents the lights. I had 8 lights, so it was represented by an array that was 7 indexes long. Each light represented 1.5 miles of airspace. So it looked like this:

Each light represents 1.5 miles of airspace. There is also an array representing the lights so the computer can tell whats going on.

There will never be more than 4 planes because if there were, an Air Traffic Controller really messed up because according to FAA JO 7110.65 5-5-4, traffic must be separated by 3 miles. That means at most there should be 1 plane every other space.

Now how to sort them? Its pretty simple. Its between lines 100 and lines 156 where it happens with a bunch of "if" statements. Every plane gets its longitude checked and placed into the correct array slot for that position. If there is no plane there, a fake one is made with -1000 m of altitude to make it obvious to pick out. Thats all the explanation your getting :).

Turning On the Lights

Pretty simple. First, go turn off all the lights that dont have a plane corresponding to them. Then, if the light does have a plan, turn it on and set the color to represent the altitude the plane is at. I used a switch-case because I'm cool (Lines 182-219).

Conclusion

Shows lights corresponding with the planes on FlightRadar24

And thats really it! When you break it down its pretty simple, but programming it from the ground up was no easy task! There's still a couple problems with mystery planes and weird geo-fence errors, but overall the project is 98% functional.

The data updates every 10 seconds per the last line of the Rasp Pi code and the lights respond accordingly as the Photon is always looping. Even at this rate, my 4000 API Credits per day will take ~12 hours of continuous use to run out. My Pi is connected to a smart outlet so that I can turn it off and on from home and it doesn't use up my credits when I dont need it to.

I hope you enjoyed reading about my project, and dont hesitate to ask any questions or suggestions! In the future, I want to make 8 runways so I can fully map out all ORD approaches on my bedroom wall!

Code

#include "Particle.h"
#include <vector>
#include <array>
#include <neopixel.h>
#include <ArduinoJson.h>
SYSTEM_MODE(AUTOMATIC);

Adafruit_NeoPixel strip(8, SPI, WS2812B);

class Airplane { //airplane object is created to make my life simpler
public:
    float lon;
    int alt;
    String callsign;

    Airplane(float pLon, int pAlt, const char* pClsgn) { //only stores the 2 needed values
        lon = pLon;
        alt = pAlt * 3.281;
        callsign = String(pClsgn);
    }

    Airplane() { //really obscure object thats not possible. Makes it super obvious its not real (important later)
        lon = -1;
        alt = -1000;
        callsign = "None";
    }
};

std::vector<Airplane> planes; //creates a vector of planes. This will be used to hold all plane object before sorting. Important this is dynamic because more or less planes might come
bool flow = true; //True if ORD is in west flow
StaticJsonDocument<10000> doc; //creates a json thingy that is later given pourpose
std::array<Airplane, 8> lights; //creates a vector for the lights with set size. This will hold planes after sorting and represent the light strip digitally
String tempArray[8]; //Just for testing pourpses to act like the lights. 


std::vector<Airplane> objectify(JsonDocument& docu){ //takes every airplane that comes from the JSON (that i want) and makes it an object
    JsonArray states = doc["states"];
    std::vector<Airplane> tempPlanes;
    bool something = false;

    if (states.isNull()){
        Serial.println("No states!");
    } else {
        for (int i = 0; i < states.size(); i++){
            if (states[i][7] < 1524 && states[i][7] > 230 && states[i][8] == false && states[i][11] < 0){  //makes sure its not an over-flight or on the ground
                const char* clsgn = states[i][1].as<const char*>(); //DELETE EVENTUALLY
                Airplane temp(states[i][5], states[i][7], clsgn); //creates the object
                tempPlanes.push_back(temp);  //adds it to the temp array
    
                something = true;
                Serial.print("Filled ");
                Serial.println(states[i][1].as<const char*>());
            }
        }
        if (something == false) {
            strip.clear();
        }
    }
    
    Serial.print("Size: ");
    Serial.println(tempPlanes.size());
        
    return tempPlanes; //makes the temp the actual array
}


void extractInfo(const char *event, const char *data){ //extracts the data from the hook response
    Serial.println("Handler starting...");
    
    Serial.print("JSON Capacity Used: ");
    Serial.println(doc.memoryUsage());

    DeserializationError error = deserializeJson(doc, data);

    if (error) {
        Serial.print("deserializeJson() failed: "); //handles errors
        Serial.println(error.c_str());
        return;
    }

    planes = objectify(doc); //makes all of them objects
}

/** This is going to sort all of the planes into an imaginary 1.5mi grid so that 
 * all the planes are displayed in the correct order as they are in the air this 
 * is important because openSky doesnt sort them in the way I want so I have to 
 * sort them myself. It takes the longitude and just places it in the right array
 * spot that corresponds with that longitude. **/


std::array<Airplane,8> fill(const std::vector<Airplane>& planez){
    Serial.println("sorting planes");
    
    std::array<Airplane,8> arr;
    bool count[8] = { false }; //just is going to count which has a plane in it, will be useful later
    
    for (int i = 0; i < planez.size(); i++){
        Serial.println("Sorting plane");
        Airplane plane = planez[i];
        
        if (flow) {
            if (plane.lon < -87.86127 && plane.lon > -87.90042) { //if the plane is less than this longitude, then put it in the array slot for that longitude
                arr[0] = plane;
                count[0] = true; //indicates a plane has been placed in this slot
            } else if (plane.lon < -87.83208) {
                arr[1] = plane;
                count[1] = true;
            } else if (plane.lon < -87.80288) {
                arr[2] = plane;
                count[2] = true;
            } else if (plane.lon < -87.77372) {
                arr[3] = plane;
                count[3] = true;
            } else if (plane.lon < -87.74453) {
                arr[4] = plane;
                count[4] = true;
            } else if (plane.lon < -87.71526) {
                arr[5] = plane;
                count[5] = true;
            } else if (plane.lon < -87.68595) {
                arr[6] = plane;
                count[6] = true;
            } else {
                arr[7] = plane;
                count[7] = true;
            }
        }
        else {
            if (plane.lon > -87.96222 && plane.lon < -87.92343) {
                arr[7] = plane;
                count[7] = true;
            } else if (plane.lon > -87.99143) {
                arr[6] = plane;
                count[6] = true;
            } else if (plane.lon > -88.02056) {
                arr[5] = plane;
                count[5] = true;
            } else if (plane.lon > -88.04988) {
                arr[4] = plane;
                count[4] = true;
            } else if (plane.lon > -88.07914) {
                arr[3] = plane;
                count[3] = true;
            } else if (plane.lon > -88.10827) {
                arr[2] = plane;
                count[2] = true;
            } else if (plane.lon > -88.13742) {
                arr[1] = plane;
                count[1] = true;
            } else {
                arr[0] = plane;
                count[0] = true;
            }
        }
    }
    
    for (int i = 0; i < 8; i++){
        if (count[i] == false){  //checks for all empty slots
            arr[i] = Airplane(); //makes a super obscure airplane object
        }
    }
    
    Serial.print("Sorted array: ");
    
    for (int i = 0; i < planez.size(); i++){
        Serial.print(planez[i].lon);
        Serial.print(", ");
    }
    
    Serial.println();
    
    Serial.println("Sorted all planes");
    return arr;
}

void checkFlow(Airplane plane){ //checks if the passed plane is on the east or west side of airport and updates flow variable accordingly
    flow = (plane.lon > -87.9090);
    Serial.print("West flow? ");
    Serial.println(flow);
}

void lightHandler() {
    for (int i = 0; i < 8; i++) {
        int altKey = lights[i].alt / 1000;

        // Handle empty/null planes first
        if (lights[i].alt <= -1000) {
            tempArray[i] = "OFF";
            strip.setPixelColor(i, 0, 0, 0);
            continue;
        }

        switch (altKey) {
            case 0:
                tempArray[i] = lights[i].callsign;
                strip.setPixelColor(i, 245, 237, 7); // Yellow
                break;
            case 1:
                tempArray[i] = lights[i].callsign;
                strip.setPixelColor(i, 250, 137, 0); // Orange
                break;
            case 2:
                tempArray[i] = lights[i].callsign;
                strip.setPixelColor(i, 252, 82, 3);  // Deep Orange
                break;
            case 3:
            default: // This catches case 3 AND anything higher (4, 5, etc.)
                if (altKey >= 3) {
                    tempArray[i] = lights[i].callsign;
                    strip.setPixelColor(i, 255, 0, 0); // Red
                } else {
                    tempArray[i] = "ERR";
                    strip.setPixelColor(i, 0, 0, 0);
                }
                break;
        }
    }
    strip.show();
}


void setup() {
    Serial.begin(9600);
    
    while(Particle.disconnected()); //stalls the particle until its on and able to subscribe to something
    
    Serial.println("Particle connected to cloud!");
    Particle.subscribe("RawOpenSkyData", extractInfo); //subscribes to get flights and calls the extract function
    
    strip.begin();
    strip.show();
    strip.setBrightness(50);
}

void loop() {
    //Serial.println("Published event");
    
    if (planes.size() > 0) { //makes sure theres something there to use
        checkFlow(planes[0]);
        lights = fill(planes);
        lightHandler();
        
        for (int i = 0; i < 8; i++){
            Serial.print(tempArray[i]);
            Serial.print(", ");
        }
        
        Serial.println();
        
        Serial.println("Operations complete");
        
        Serial.println();
        
        delay(5000); //waits a minute. Might wanna decrease
    } else {
        strip.clear();
        //Serial.println("No planes returned!");
    }
    
    delay(1000); //stops API spamming at a stupid rate. (No longer needed because pi limits it, just keeping it in here to stop any problem with particle looping)
}

Raspberry Pi API Relay Python

Python

For some reason unknown to me, the Particle webservice gets blocked by OpenSky. Therefore, I cant call the API from just my Particle and need to call it from the Pi which then pushes it to the particle. I posted on multiple forums about this problem and got nothing. If anyone figures it out let me know.

Make sure to use a webservice on your pi. I honestly dont know how this works and just used Gemini because adding a 3rd language to my project seemed excessive. Have fun :).

import requests 
import json 
import time 
from datetime import datetime, timedelta

# --- Configuration (Replace with your actual credentials) ---
OPENSKY_CLIENT_ID = "yaboyluke2-api-client"
OPENSKY_CLIENT_SECRET = "Hb7FIWChc73PLqqSwvOlQrUuUopNen07"
PARTICLE_ACCESS_TOKEN = "4388b3788171c10e5c44a210025f176a0810af36" # Your long-lived Particle token

# --- OpenSky Token Management Variables ---
OPENSKY_TOKEN = None
TOKEN_EXPIRY_TIME = datetime.now() 

# --- OpenSky Authentication Endpoint ---
AUTH_URL = "https://auth.opensky-network.org/auth/realms/opensky-network/protocol/openid-connect/token"
OPENSKY_URL = "https://opensky-network.org/api/states/all"
PARTICLE_PUBLISH_URL = "https://api.particle.io/v1/devices/events"
PARTICLE_EVENT_NAME = "RawOpenSkyData"

# Example Bounding Box
OPENSKY_PARAMS = {
    'lamin': 41.98759,
    'lomin': -88.22404,
    'lamax': 41.98901,
    'lomax': -87.59579,
}

# --- 1. TOKEN RETRIEVAL FUNCTION ---
def get_new_opensky_token():
    """Fetches a new access token and updates global variables."""
    global OPENSKY_TOKEN, TOKEN_EXPIRY_TIME
    
    print("Fetching new OpenSky access token...")
    
    try:
        response = requests.post(
            AUTH_URL,
            data={
                "grant_type": "client_credentials",
                "client_id": OPENSKY_CLIENT_ID,
                "client_secret": OPENSKY_CLIENT_SECRET
            }
        )
        response.raise_for_status() # Raises an HTTPError for bad responses (4xx or 5xx)
        
        token_data = response.json()
        OPENSKY_TOKEN = token_data.get("access_token")
        
        # OpenSky tokens typically last 1800 seconds (30 minutes).
        expires_in = token_data.get("expires_in", 1800) 
        
        # Set expiry time to a few seconds BEFORE the actual expiry to preemptively refresh.
        TOKEN_EXPIRY_TIME = datetime.now() + timedelta(seconds=expires_in - 5) 
        
        print(f"SUCCESS: New token retrieved. Expires at: {TOKEN_EXPIRY_TIME.strftime('%H:%M:%S')}")
        
    except requests.exceptions.HTTPError as e:
        print(f"ERROR: Failed to retrieve token. Check credentials. Status: {e.response.status_code}")
        OPENSKY_TOKEN = None
    except Exception as e:
        print(f"ERROR: An error occurred during token fetch: {e}")
        OPENSKY_TOKEN = None

# --- 2. MAIN FETCH AND PUBLISH LOOP ---
def fetch_and_publish_opensky():
    global OPENSKY_TOKEN, TOKEN_EXPIRY_TIME
    
    # CHECK 1: Token existence and expiry
    if OPENSKY_TOKEN is None or datetime.now() >= TOKEN_EXPIRY_TIME:
        get_new_opensky_token()
        if OPENSKY_TOKEN is None:
            print("Cannot proceed without a valid OpenSky token.")
            return

    # --- STEP A: CALL OPENSKY API using the Bearer Token ---
    print("Fetching data from OpenSky...")
    
    # Set the Authorization Header with the Bearer Token
    headers = {
        "Authorization": f"Bearer {OPENSKY_TOKEN}",
        "Accept": "application/json"
    }

    try:
        response = requests.get(OPENSKY_URL, params=OPENSKY_PARAMS, headers=headers)
        response.raise_for_status() # Check for errors
            
        raw_json_string = response.text
        print(f"OpenSky JSON length: {len(raw_json_string)} bytes")

        # --- STEP B: POST RAW JSON TO PARTICLE CLOUD (with 255-byte warning) ---
        
        publish_data = raw_json_string
        if len(publish_data) > 255:
            # IMPORTANT: Truncate or use a different method if this is often exceeded.
            print("WARNING: Payload exceeds 255 bytes. Data will likely be truncated or fail.")
            # For demonstration, we'll try to send the full payload as requested, risking failure.
        
        particle_payload = {
            'name': PARTICLE_EVENT_NAME,
            'data': publish_data,
            'private': 'true',
            'ttl': 60,
            'access_token': PARTICLE_ACCESS_TOKEN
        }
        
        publish_response = requests.post(PARTICLE_PUBLISH_URL, data=particle_payload)
        
        if publish_response.status_code == 200:
            print("Particle Event Published Successfully.")
        else:
            print(f"Error publishing to Particle. Status: {publish_response.status_code}")
            print(publish_response.text)

    except requests.exceptions.HTTPError as e:
        print(f"HTTP Error during data fetch: {e}")
        # If the API returns a 401 Unauthorized, we force a token refresh on the next loop.
        if e.response.status_code == 401:
            print("Token appears invalid, forcing refresh next time.")
            TOKEN_EXPIRY_TIME = datetime.now()
            
    except Exception as e:
        print(f"An unexpected error occurred during API communication: {e}")

# --- 3. EXECUTION ---
if __name__ == '__main__':
    # Initial token fetch before starting the main loop
    get_new_opensky_token() 
    
    # If the initial fetch failed, the loop won't start effectively
    if OPENSKY_TOKEN:
        while True:
            fetch_and_publish_opensky()
            time.sleep(10) # Wait 10 seconds before fetching/publishing again

Credits

Lucas Rose

2 projects • 0 followers

Just a student in a Physical Computing Class.

Aircraft Approach Visualization

Things used in this project

Hardware components

Software apps and online services

Story

Introduction

Webhook/API

Query

Raspberry Pi Relay

Photon 2 Programming

Parsing Data

Sorting the Planes

Turning On the Lights

Conclusion

Schematics

Diagram

Code

Main Particle Code

Raspberry Pi API Relay Python

Credits

Lucas Rose

Comments

Embed the widget on your own site

Aircraft Approach Visualization

Aircraft Approach Visualization

Things used in this project

Hardware components

Software apps and online services

Story

Introduction

Webhook/API

Query

Raspberry Pi Relay

Photon 2 Programming

Parsing Data

Sorting the Planes

Turning On the Lights

Conclusion

Schematics

Diagram

Code

Main Particle Code

Raspberry Pi API Relay Python

Credits

Lucas Rose

Comments

Related channels and tags