Published May 1, 2026

Northern Lights Visualization Scene

This scene represents the present visibility of the northern lights over the mountain Kirkjufell in Iceland.

AdvancedShowcase (no instructions)10 hours17

Things used in this project

Hardware components

Particle Photon 2

Digilent Stepper Motor

SparkFun Snappable Protoboard

Green version

Digilent 5V 2.5A Switching Power Supply

5v DC Adapter Female

Adafruit Neopixel (Silicone coated)

Jumper wires (generic)

Solid Core Wire

Software apps and online services

Particle Build Web IDE

Story

The idea

Beginning with the idea of light, this project stemmed from a combination of ideas involving a natural scene and live, adapting data. Beginning this project, my partner and I decided to create a scene from a mountain in Iceland where the northern lights are very prominent.

Thinking from a computer science perspective, this project would require pulling data from specific geographic coordinates about the visibility of the northern lights. This is essential in creating a scene that has lights that adapt to the current state of the northern lights over this mountain.

Thinking through how this project would include movement was difficult. Other than the brightness of the lights adapting to the live visibility, I wanted the lights to slowly move back and forth like the lights themselves do in real life.

Selecting Lights / Brainstorming

Light selection

My first challenge in brainstorming the mechanics of this project was figuring out how to get lights to bend and move like the northern lights. For this I initially decided to purchase flexible Adafruit Neopixel LED strips. After ordering these lights, despite doing research, I realized that they did not bend in the direction that I had thought they would. This was a relatively easy solve however, as I decided to angle the lights at a 45 degree angle on the ceiling and rotate them so that the bright side was facing directly toward the front, instead of facing down so they could illuminate the scene.

Light movement

My next struggle with getting moving lights was figuring out a way to actually shift the lights from side to side. After considering using a linear rail and gear system, I decided that using a pulley system would work better.

The pulley system

To get the light to shift back and forth required a system to convert the rotational motion of the stepper motor to linear motion. To do this I 3d printed two spools and attached one to the servo. Between them was a string, attached through the ceiling of the project to the middle light bar.

The API

Finding an API to pull data for this project from was extremely straightforward, the NOAA has a database that stores the values of the visibility of the northern lights at each set of latitude and longitude coordinates. The data given from this API was formatted as follows: [longitude, latitude, Probability of Visibility (out of 100%)].

https://services.swpc.noaa.gov/json/ovation_aurora_latest.json

The data

To extract the specific location of the mountain, Kirkjufell, I identified the latitude and longitude coordinates: 64.9417° N, 23.3069° W. Using these numbers, you can find the closest points to this specific location. Given that the database only provided statistics for whole-number coordinates, I took the average of the four points surrounding the location of the mountain (converting 23 to -23, indicating west when using a North, East format. I then added 360 to convert this number into WGS84 format).

Point 1: 337, 64
Point 2: 337, 65
Point 3: 336, 64
Point 4: 336, 65

Query Parameters

Filtering the massive amount of data being retrieved from this API was done via query parameters using the particle integration webhook service. To find the exact lines to retrieve, the row number was manually calculated by multiplying the number of entrees per longitude coordinate by the longitude coordinate of the first point, then adding the number of latitude values away from -90, for example point 1 would be 90+64 in addition to 181*337 (zero is included in the data set, hence the value used is 181 and not 180). The specific lines pulled from the data set are indicated under the query parameters below:

{
"selected": [
"{{coordinates.60970}}",
"{{coordinates.61151}}",
"{{coordinates.60971}}",
"{{coordinates.61152}}"  
]
}

This filters through the "coordinates" array from the API and retrieves the corresponding arrays from the lines indicated, storing them under "selected". The output when testing this event looks like this:

Videos

Code

This program changes the speed of the lights swaying back and forth based on how visible the northern lights are over Kirkjufell, in addition the brightness of the wave pattern of the LEDs is increased the more visible the lights are above the mountain.

Northern Lights

#include <neopixel.h>
#include <AccelStepper.h>
#include <ArduinoJson.h>
#include "Particle.h"

JsonDocument doc;

SYSTEM_MODE(AUTOMATIC);

SerialLogHandler logHandler(LOG_LEVEL_INFO);

#define HALFSTEP 8       //--> 2048 step. Si Halfstep 8 --> 4096 pas
#define motor1Pin1 D0
#define motor1Pin2 D1
#define motor1Pin3 D2
#define motor1Pin4 D4


AccelStepper stepper1(HALFSTEP, motor1Pin1, motor1Pin3, motor1Pin2, motor1Pin4);

int endPoint1 = 8192; 


int LED_Count = 41;

Adafruit_NeoPixel light(LED_Count, SPI, WS2812B);

int lightDelay = 50;
float brightnessOfLed = 1;
int speed = 300;
int minSpeed = 200;//200
int maxSpeed = 500;
float maxLightVal = 20.0;


int previous1 = -1;
int previous2 = -1;
int previous3 = -1;
int previous4 = -1;


void getData(){
    Particle.publish("getNLData");
}
int w = 0;
int v = 0;
int k = 0;
int n = 0;
void colorAnimation(){
    //add usage of lightspeed
    if(w<LED_Count){
        light.setPixelColor(w, 0 * brightnessOfLed, 184 * brightnessOfLed, 22 * brightnessOfLed);
        light.show();
        w++;
    }
   
    
    if(w >= LED_Count && v < LED_Count){
        light.setPixelColor(v, 0 * brightnessOfLed, 145 * brightnessOfLed, 19 * brightnessOfLed);
        light.show();
        v++;
    }
    
    
    if(v>=LED_Count){
        w=0;
        v=0;
    }
}

Timer getTimer(30000, getData); // Run getData every 1000ms outside of the void loop
Timer lightMovement(lightDelay, colorAnimation);


void setup() {
    while(Particle.disconnected());
    Serial.println("Particle connected to cloud!");
    Particle.subscribe("hook-response/getNLData", extractInfo);
    Serial.begin(9600);
    stepper1.setMaxSpeed(1000);
    stepper1.setAcceleration(100000);
    stepper1.setSpeed(speed);
    light.begin();
    light.show();
    light.setBrightness(50);
    light.show();
    getTimer.start();
    lightMovement.start();
}

void loop() {

    
    if (stepper1.distanceToGo() == 0) {
        stepper1.setCurrentPosition(0);
        endPoint1 = -endPoint1;
        stepper1.moveTo(endPoint1);
    }
    
    stepper1.run();

  
    // Run both motors simultaneously
    
    
    
}

void extractInfo(const char *event, const char *data)
{
    Serial.println("Handler is starting...");
    deserializeJson(doc, data);
    Serial.println("Data Deserialized and is available for analysis.");

    JsonArray arr = doc["selected"];    
    
    const char* p1 = arr[0];
    const char* p2 = arr[1];
    const char* p3 = arr[2];
    const char* p4 = arr[3];
    
    std::string st1(p1);
    std::string str1 = st1.substr(7); 
    int sub1 = std::stoi(str1);  
    
    std::string st2(p2);
    std::string str2 = st2.substr(7); 
    int sub2 = std::stoi(str2);  
    
    std::string st3(p3);
    std::string str3 = st3.substr(7); 
    int sub3 = std::stoi(str3);  
    
    std::string st4(p4);
    std::string str4 = st4.substr(7); 
    int sub4 = std::stoi(str4);  


    if(previous1 == -1){
        previous1 = sub1;
        previous2 = sub2;
        previous3 = sub3;
        previous4 = sub4;
        changeSpeed(sub1, sub2, sub3, sub4);
    } else if(previous1 != sub1 || previous2 != sub2 || previous3 != sub3 || previous4 != sub4){
        changeSpeed(sub1, sub2, sub3, sub4);
        previous1 = sub1;
        previous2 = sub2;
        previous3 = sub3;
        previous4 = sub4;
    }
    
    
    Serial.println(sub1);
    Serial.println(sub2);
    Serial.println(sub3);
    Serial.println(sub4);
}

void changeSpeed(int a, int b, int c, int d){
    float avgnum = (a+b+c+d)/4.0;
    float percentageSpeed = avgnum/100.0;
    float percentForUse = avgnum/maxLightVal;
    if (percentForUse>1.0){
        percentForUse = 1.0;
    }
    speed = (percentageSpeed * (maxSpeed - minSpeed)) + minSpeed;
    Serial.println(speed);
    Serial.println(percentForUse);
    stepper1.setSpeed(maxSpeed * percentForUse); //just use variable speed for more accurate and less drastic change.
    brightnessOfLed = percentForUse; //use percentageSpeed variable for more accurate and less drastic change.
}