Computational Sculpture

Introduction

The computational sculpture was inspired by the idea of incorporating software and electronics into aesthetically pleasing art. The theme for this project is "Cultivating Light." But what is cultivating light? To me, humans have relied on light as a sense of safety and security. This inspired me to pull data from Chicago Data Portal's arrests dataset and produce a project that represents local communities of Chicago to be portrayed in a Tangled-inspired sculpture.

Functionality

The project is intended to update once a day where it checks for new arrests being made in the Chicago. When it reaches the input time, data will be pulled through an API endpoint and filtered for an integer value: CASE_ID. To represent a new arrest being made, the project will briefly light up while the middle sun will spin and move up and down. The software will then record this data for the next time data is called and compare next day's data with it-- ensuring that the software will always be able to compare data from the day before with the current day

1. Creating API Endpoint and Pulling Data

Particle will consistently check the time and convert it to minutes. When it reaches a certain time of the day, adjustable by user, it will publish a particle event which will pull the data with an API endpoint. I had used the Chicago Data Portal: Arrests Dataset as my main source of data extraction. My API endpoint had been written to return the most recent case from the dataset. Then through Particle's integration feature, I was able to create a webhook and filter for only the CASE_ID value which will be embedded into my firmware.

int callTime(){ 
currHour= Time.hour()*60; 
currMin= Time.minute(); 
currTime = currHour + currMin;
return currTime; 
}
void compTime(){ 
    if (currTime == 601){ 
        Particle.publish("Arrest");
    } 
} 
void myHandler(const char *event, const char *data) {
    if (!data) return;
    val = atoi(data); 
    Serial.println(val); 
    compare(); 
}

2. Soldering Lights

My LED chips were very standard but incredibly tiny. Soldering each individual solid core wire onto the chips were quite tedious and time consuming. Each solid core wire soldered on was apx. 3 inches long but adjusted along the way when necessary. Wire was connected to power (red), ground (black), and MO (yellow) on the particle. I then used the popular Neopixel library on Particle to code my lights.

void light(){ 
    for(int i = 0; i < PIXEL_COUNT; i++) {
    strip.setPixelColor(i, strip.Color(255, 213, 128, 0)); // white 
    strip.setBrightness(90);

  }

  strip.show();
  delay(1000);
} 

void off(){ 
     for(int i = 0; i < PIXEL_COUNT; i++) {
    strip.setPixelColor(i, strip.Color(0,0,0,0)); // white 
    }
  strip.show();
  delay(1000);
}

3. Setting Up and Coding Stepper Motor

Working with the stepper motor was pretty straightforward. I had used the Particle's Stepper library for the firmware. Referenced and navigated the Stepper test code that my instructor had provided as a resource when creating turn functions for my motor.

void turn (){ 
    myStepper.step(2048);
} 

void back (){ 
    myStepper.step(-2048);
}

4. Soldering the Protoboard

After testing all of my components on the breadboard, it was time to start soldering on the protoboard. I had soldered headers onto the board which would allow me to freely plug and unplug jumper wires of various components. Lots of trial and error along the way. The headers would be soldered and connected to the necessary pins for the project. This essentially acted very similar to a breadboard.

5. LED Installation

Fortunately installing the lights onto the faux roof was a very simple process. Since my faux roof was made of cardboard, I had marked all the desired spots and then cut tiny holes with a box cutter to string the LED wires through. The LEDs were able to hold themselves up with the wires itself and did not require any other string to hold itself up.

6. Stepper Motor Installation

Similar to the first installation process, I had cut a hole in the middle of the faux roof where the paper sun would be strung through with a clear elastic string. The string itself was looped onto the stepper motor which would be hidden away in the roof while controlling the sun through the hole. This part also took so much trial and error because the elastic string would easily become tangled. By this point I had also cut a hole in the back of my box to create a hole to wire my power and ground wire to a DC jack which was connected to a 5 volt barrel jack plug.

7. Test Code

Finally my faux roof was installed! I did one more round of testing with all the components in place with my test code which repeatedly ran the light up and spin functions on loop. This was to ensure that all hardware was correctly installed and the wires were not messed up along the way.

// test code

void loop() {
   light(); 
    turn(); 
    turn(); 
    back(); 
    back(); 
}

7. Final Touches & Final Product

After ensuring that all hardware components were good to go, I applied the time checking function into my code which was the final tie in completing my project. This marks the completion of my Tangled- inspired computational sculpture project.