The Project
Our Idea
The Car Rotation
Slip Rings
Solution
Lighting
Motors
Power
The Cars Themselves
Conclusion

Published April 16, 2026 © GPL3+

A City of Light

The current state of automobile pollution is not great, and this project (loosely) represents the hyperbolized effect of EV vs ICE cars.

AdvancedShowcase (no instructions)10 hours20

Things used in this project

Hardware components

Particle Photon 2

We used the Photon 2 specifically because it is SUPER easy to connect to the internet with and makes API requests really simple. 10/10 would recommend this micro controller to others.

Breadboard (generic)

We actually used proto boards and soldered everything to them. Breadboards work just fine too though.

Jumper wires (generic)

NeoPixel LED Ring

https://www.amazon.com/WESIRI-WS2812B-Individually-Addressable-Controller/dp/B083VWVP3J/ref=sr_1_2?crid=31WRWNRFF6LFZ&dib=eyJ2IjoiMSJ9.pbokfCICLdpZ1C5-Vj4JtJiqvP_GxTkDwbGqsfQWWPKDzBSf2l_TmxM_P0ov88cnMFoc4ub32bh012mo2bhXvnc6BRNedYXZKNZ9vv4JeBRDAH-4q-W91rqoel8FOtC-5RKndYR9NTFYd7gX0HPI5E1GS9ZC3bFeaPri0xL0DuOm_lCiH_jbooHWxMeDsY9qT9xRJTTHgxm7e91ZRfVXuqv4eq_drnNAwv2zvMO6jsPM6oqxQBGqAJGlCmr_nFNoa5mGFe5Juw3I9XWYQOx-veV_hGNkbND5TnVq0JOELvA.qnA2AOoBBUuGWZ8OyleZRnrzbFdhmXctF79DIagAzWA&dib_tag=se&keywords=led%2Bring%2Blights%2Bindividually%2Baddressable&qid=1770146117&sprefix=led%2Bring%2Blights%2Bindividually%2Badressab%2Caps%2C490&sr=8-2&th=1

Adafruit NeoPixel Digital RGB LED Strip 144 LED, 1m White

Choose light density and length to your liking. These were used to backlight the buildings.

Digilent Stepper Motor

5V/5A Power Supply

Software apps and online services

Twelve Data

TSLA API request example: https://api.twelvedata.com/time_series?apikey=43f257b6e6674105898183cd58aeafe2&symbol=TSLA&interval=1h&exchange=NASDAQ&type=stock&outputsize=1&format=JSON

Particle Build Web IDE

Hand tools and fabrication machines

3D Printer (generic)

Tape, Electrical

Hot glue gun (generic)

Soldering iron (generic)

And solder of course.

Story

The Project

This was created as a project for my Physical Computing Lab (PCL) class. The guidelines:

It has to somehow be related to the theme "Cultivating Light"
It has to have movement with a stepper motor or servo
It has to have lights that respond to data pulled by you from the internet

Our Idea

This was a cross over between my PCL class and the Sculpting class. We were given a partner and we had to work together in our respective areas of expertise to make a single project. Zoeh (my partner) did a lot of great visual work which you will probably see in pictures, however in this documentation I will primarily focus on the electrical aspects of the project.

Our idea in full was to have 2 rotating rings of cars that rotated through a city, one with gas cars and one with EV cars. The cars would speed up or slow down in relation to the GM stock or the TSLA stock. A sun in the background would get less bright as GM stock increased, representing an increase in pollution. While the direct relationship between stock price and pollution output is flimsy at best, I'm going to tell you to use your imagination.

The Car Rotation

The car rotation posed the biggest challenge for me. In the end you and I both are going to be thinking, "Wow that's really simple. Of course I'd think of that immediately." Well, I didn't. And I really went through the 5 stages of grief trying to come up with solutions before coming up with the seemingly simple problem. The problems:

There are 2 counterrotating rings of cars that need to be lit from underneath
There needs to be space in the middle of the rings where a stationary pillar can be
The rings cant be very heavy because they have to be rotated by a stepper motor.

If you don't care about my problem solving process, skip here. If you want to struggle with me, keep reading.

Slip Rings

Slip rings are components that allow stationary wires to be connected to wires that rotate in a circle. The only thing with these is that if you try to put something not rotating next to it, the wires will clothesline the supports as it rotates around. Think of it like this.

They do make slip rings with a hole in the middle, so that you can put stationary wires or supports through the middle. However, I would need 2 of these (because one slip ring can only rotate one direction, and two counter rotating car rings means two slip rings) which is not particularly cheap, nor are the holes any where near how wide id like them (130 ish cm diameter). So basically, I get to make my own slip ring!

My plan was to have the LED rings themselves rotate with the model cars merely sitting on top. Like this:

Instead of making them vertically stacked, I made a custom horizontally oriented slip ring. How it was going to work was there would be rings of copper wire that was in constant contact with a brush from the LED light rings. As the stepper motors rotated the rings, the wires would drag along the copper wires and provide current to all components. The copper is connected to the Photon. See the picture below, it should make more sense.

3D model of the slip ring

However, the contact between the LED wires and the copper wires was not strong enough and the LEDs didn't turn on. There was also too much stringing in the 3D print and the LED wires ended up getting stuck and jumping. The whole thing was good in theory, but in practice it was a disaster. Its important to not that this concept took about 3 weeks to design and execute (way too long).

The slip ring with copper wiring on the bottom and the LED ring with the exposed wire "brushes". Around the copper wire, you can see the stringing I was talking about causing problems.

The gap between the LED rings and the copper wire slots is shown. The wires would hang down and go into those rows you can see on the bottom which housed the copper wire.

Solution

Why deal with all the mess of rotating wires when I could just rotate the cars alone without the lights? I don't need the lights to move for the light to hit the cars, just the cars have to move. So in all, I just re-modeled my design, printed out rings for the cars to rotate on with, and glued the rings to the bottom. Much simpler, and much more reliable.

Shows the lights are no longer the thing thats moving, but rather underlighting the cars through holes.

Again shows the cars rotating not the lights.

Lighting

The ring lights under the cars were already discussed quite well. The lights in the buildings are simply little strips of 4 NeoPixel strips that are all soldered together to work off the same pins. The buildings are hollow, and the lights simply under light them. The other buildings are lit the same way, but with one continuous strip that is kinda crammed in there.

Ring light lit up

The sun is just a normal LED Diode that is controlled by a PWM pin to change brightness with stock price.

Its important to realize that the car ring lights, the tall building lights, and the small building lights never change and are always at 100% brightness with the color white. Therefore, there was a lot of sketchy soldering to just solder all the power, ground, and signal pins down to 1 wire, allowing me to control hundreds of lights in parallel with just one pin. This simplified the breadboard itself much, however its important to wrap the joints with electrical tape to stop unexpected short circuits.

Shows the strip lights inside the buildings. Also shows the wild soldering and taping I did to cover the mess up.

Motors

Originally, I was going to use an L298N Motor Controller to control both the rings of cars. However, the motors themselves required too much hight and didn't have enough torque to spin the ring (which is crazy because theres not that much inertia or friction). After wasting a lot of time on this, I pivoted to using two 28BYJ-48 Stepper Motors and ULN2003 Driver SY2526s.

The motors are simple stepper motors controlled with the AccelStepper class allowing the speeds to be individually controlled. They interact with the cars through a simple rotary gear system which is lowered a little bit below the artificial floor. They are hidden from sight, but one is on the inside of the circle for the inner cars and one is on the outside.

Power

One problem I had to unexpectedly face was the lack of power. I was using a 5V/1A power supply originally, however this was not enough to power the large amounts of lights and the motors and the Photon at the same time. Whenever the Photon would connect to the internet, it would have a current spike and push the power supply over 1A, causing everything to restart in a permanent boot loop. This scared me initially because lack of power was an option but definitely not the only option. Luckily, switch to a 5V/5A fixed it and no change was needed.

**Make sure to up the resistor for the LED diode though or you'll blow it

The Cars Themselves

The cars were simply made using free Tesla models and pickup truck models off the internet. I added some holes, 3D printed them, then we painted them. They are hollow and should have little holes in the front and back to act as head lights, however due to size and printer stringing, these holes dont really work how they're supposed to.

A little quality control was done on these I just dont have a better picture.

Conclusion

Overall, the components were pretty simple to use, but the manor and quantity of these components presented a fun set of challenges to overcome on a quite strict timeline. The code is pretty self explanatory, but if enough people want me to explain it I can go into detail. There's some final media below, and make sure to let me know if you have any questions! Thanks for reading!

Final Project outside of diorama

Final Project

Schematics

Code

Main

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

SYSTEM_MODE(AUTOMATIC);
SerialLogHandler logHandler(LOG_LEVEL_INFO);

#define RingPin SPI //MOSI, D15, SPI
#define HOME_PIN D10

Adafruit_NeoPixel RingLight(64, RingPin, WS2812B);

AccelStepper outerMotor(AccelStepper::FULL4WIRE, 0, 2, 1, 3);
AccelStepper innerMotor(AccelStepper::FULL4WIRE, 4, 6, 5, 7);

JsonDocument doc1;
JsonDocument doc2;

float TSLAdiff = 0;
float GMdiff = 0;
float oldTSLAdiff = 0;
float oldGMdiff = 0;

int innerMotorSpd = 100;
int outerMotorSpd = 100;

// flag to indicate new data has arrived and motors should be updated
volatile bool newDataReady = false;

void setup() {
    while(Particle.disconnected());
    
    RingLight.begin();           
    RingLight.setBrightness(100);
    for (int i = 0; i < 64; i++){ RingLight.setPixelColor(i, 255, 255, 255); }
    RingLight.show();
    
    pinMode(HOME_PIN, INPUT_PULLUP);

    Particle.subscribe("hook-response/getTSLA", extractTSLA, MY_DEVICES);
    Particle.subscribe("hook-response/getGM", extractGM, MY_DEVICES);
    

    innerMotor.setMaxSpeed(2500);
    innerMotor.setAcceleration(2000);

    outerMotor.setMaxSpeed(2500);
    outerMotor.setAcceleration(2000);

    innerMotor.setSpeed(400);
    outerMotor.setSpeed(400);
}


int timeCounter= 0;
void loop() {
    //fogMotor.run();
    innerMotor.runSpeed();
    outerMotor.runSpeed();
    
    if (timeCounter > 20000) {
        timeCounter = 0;
        Particle.publish("getTSLA", PRIVATE);
        Particle.publish("getGM", PRIVATE);
    }

    // handle motor logic only after new data has arrived
    if (newDataReady) {
        newDataReady = false;
        motorHandler();
    }
    
    delay(1);
    timeCounter ++;
}

void motorHandler(){
    if (TSLAdiff != 0){
        if (TSLAdiff < 1) {
            if (TSLAdiff < 0.01) { 
                innerMotorSpd -= 5;
            } else if (TSLAdiff < 0.05) {
                innerMotorSpd -= 10;
            } else if (TSLAdiff < 0.1) {
                innerMotorSpd -= 15;
            } else { //fell by >10%
                innerMotorSpd -= 20;
            }
        } else {
            if (TSLAdiff < 1.01) { 
                innerMotorSpd += 5;
            } else if (TSLAdiff < 1.05) {
                innerMotorSpd += 40;
            } else if (TSLAdiff < 1.1) {
                innerMotorSpd += 20;
            } else { //rose by >10%
                innerMotorSpd += 80;
            }
        }
    }
    
    if (GMdiff != 0){
        if (GMdiff < 1) {
            if (GMdiff < 0.01) { 
                outerMotorSpd -= 5;
            } else if (GMdiff < 0.05) {
                outerMotorSpd -= 10;
            } else if (GMdiff < 0.1) {
                outerMotorSpd -= 15;
            } else { //fell by >10%
                outerMotorSpd -= 20;
            }
        } else {
            if (GMdiff < 1.01) { 
                outerMotorSpd += 20;
            } else if (GMdiff < 1.05) {
                outerMotorSpd += 40;
            } else if (GMdiff < 1.1) {
                outerMotorSpd += 15;
            } else { //rose by >10%
                outerMotorSpd += 80;
            }
        }
    }

    
    if (innerMotorSpd > 200){
        innerMotorSpd = 200;
    } else if (innerMotorSpd < 0){
        innerMotorSpd = 0;
    }
    
    if (outerMotorSpd > 200){
        outerMotorSpd = 200;
    } else if (outerMotorSpd < 0){
        outerMotorSpd = 0;
    }
    
    
    Serial.print("TSLAdiff: ");
    Serial.print(TSLAdiff);
    Serial.print(" outerSpd: ");
    Serial.print((long) map(outerMotorSpd, 0, 200, 50, 682)); //    2048steps/1min * 20rev/1 min * 1min/60sec = 682steps/1sec
    Serial.print(" ");
    Serial.print(outerMotorSpd);
    Serial.print(" GMdiff: ");
    Serial.print(GMdiff);
    Serial.print(" innerSpd: ");
    Serial.print((long) map(innerMotorSpd, 0, 200, 50, 682));
    Serial.print(" ");
    Serial.println(innerMotorSpd);

    innerMotor.setSpeed((long) map(innerMotorSpd, 0, 200, 50, 682));
    outerMotor.setSpeed((long) map(outerMotorSpd, 0, 200, 50, 682));
}

void extractTSLA(const char *event, const char *data) {
    float val1, val2;
    if (sscanf(data, "%f,%f", &val1, &val2) == 2) { //delemeter between floats is comma
        TSLAdiff = std::round((std::abs(val2 - val1)/val1) * 1000.0) / 1000.0; 
        
        Serial.print("TSLA diff: ");
        Serial.println(TSLAdiff);

        newDataReady = true;
    } else {
        Serial.println("Error: Could not parse TSLA data");
    }
}

void extractGM(const char *event, const char *data) {
    float val1, val2;
    if (sscanf(data, "%f,%f", &val1, &val2) == 2) {
        GMdiff = std::round((std::abs(val2 - val1)/val1) * 1000.0) / 1000.0;
        
        Serial.print("GM diff: ");
        Serial.println(GMdiff);

        newDataReady = true;
    } else {
        Serial.println("Error: Could not parse GM data");
    }
}

Credits

Lucas Rose

3 projects • 0 followers

Just a student in a Physical Computing Class.

Thanks to Zoeh Muniz.

A City of Light