Inspired by the Giant’s Causeway in Ireland, we arranged 300 white cylindrical candles into a mountain terrain formation that reacts slowly to audience interaction. Users were invited to light candles and add dye chips (choice of 8 colors) to pools of melted wax, shaping and coloring the terrain. The terrain “erodes” and transforms organically throughout the night as a result of the collective contributions. Our piece acts as a memorial of the community experience of creating something. A projection on the ceiling of CFA’s Main Hall streamed live video of the piece and users interacting with it, encouraging those inside the hall to come outside and contribute to it as well. 

Early in the exhibition. Only a few candles have been lit and dyed.

People interacting with the piece. Demonstrates overall scale.

Close up of the lit candles and how the dye flows with the melting wax.

Projection of the piece in the hall.

The piece near the end of the exhibition.

Final results after the entire exhibition.

As the dyed candles melted, the wax built up, creating interesting layers and formations.

Chunks of colored solidified wax and their patterns.

Video

Time lapse of the piece over the course of the event:

Process

We experienced some setbacks while assembling our project, and had a few lucky breaks in our final, public installation. 

Andy testing his hexagonal candle cutter.

Testing the chip dyes.

We initially planned to imitate the shape of the columns in the Giant’s Causeway exactly, filling a 24”x36” rectangle with about 250 pounds of hexagonal wax candles. This initial plan’s footprint downscaled to 18”x24” when our proposed budget went above $300, and the hexagons had to be rethought after we had trouble finding thin candles in that shape.

Since we wanted a large “mountain” terrain, we needed a decently-sized base to build on. Using images from the actual Giant’s Causeway, we calculated that the height couldn’t go over ⅔ of the longest base or else it’d look weird. We did our initial planning using this metric plus the height of the tallest bulk candles we could find. This design turned out to be ~200 pounds of wax, which seemed unwieldy and needlessly expensive. We chose a smaller base, and someone came up with the idea of using platforms on the inside so we could avoid making the entire mountain out of solid wax. The project seemed reasonably priced at this size, and would still look proportional when built. 

At this point we were still planning on creating a bunch of hexagonal candles from circular ones. In initial plans to make the hexagons, we thought about methods like using long, hexagonal PVC tubes as molds (sold only on Alibaba, so shipping took too long), 3D printing or silicone molds (really slow), and cutting candles down to shape (slow, bad quality). Each of the mold approaches would have taken several days of boiling, pouring, casting, and cooling, and cutting each one seemed silly, time-consuming, and dangerous. Not to mention all the inevitable quality problems with manually making all our own candles! We settled on buying circular candles and pushing them through a hexagon cookie cutter. The cheapest site we could find sold 200 candles for $80, and we needed around 350 candles post-cut to fill our platform. 

We placed the order right before everyone left for Thanksgiving and waited with bated breath. When we returned, we found the candles were of the expected size, but did not realize that the quantity was wrong. To make hexagons, we created a prototype cutter using wood, epoxy, and bent sheet metal. This rig could cut warmed candles by simply pushing them through by hand. While testing the candle cutter, we noticed that we were missing around a hundred candles, which meant we would not be able to fill our base with hexagons. Especially since they shrink and pack closer when cut. Our hexagon idea died here, and to everyone’s relief: the hexagon tile cutter took a lot of force! Going with the cylinders saved a lot of time and looked almost equivalent, but we still needed to adjust the heights of every candle. 

Screwing the cement board platforms into the wooden supports.

Gluing the candles into place.

Just started the cutting and gluing, so only the top candles have been worked on. The rest of the candles are arranged into place.

Davine came up with a method using a box cutter and rolling it over an end of the candle until it cracked off. Cut-offs of the base could be glued onto another candle, and allowed us to vary their heights for a more organic look. We used hot glue to put them together, then used it again to glue the entire candle to the platform it was sitting on to secure the mountain. 

While the mountain was being built, some of us prepped the platform and cart for the final installation. The base is a large sheet of plywood with standing segments of two-by-four drilled into it; on top of these lie the platforms. Since the platforms are wick-level with individual candles, we chose to make them out of a non-flammable material. Luckily, Zach had some cement board that was perfect for this. We scored it with a carbide knife, then broke it by bending it. 

Breaking the cement board into the mountainous back of the piece.

Created cardboard separators for the dishes and put the dye chips into them.

We also used cement board later to fill in a large gap when we found out that we didn’t have enough candles to cover one side of the mountain. Once all the platforms and wood bits were screwed in, we co-opted Zach’s rolling cart to carry it to CFA. We put a cloth canvas over it, then another solid sheet of black aluminum foil on top of that to catch any stray wax strips. This turned out to be invaluable later. When we finished assembling the mountain, we carefully carried it on top of the cart and placed it over the aluminum protection layer. Leah and Davine made holders for the dyes, and Zach gifted us these long matches that were in his house for the participants to light candles with. 

Everything is finished, and we’re heading out to place it at our exhibition.

Once every gap was filled and no internal structure poking out, we wheeled it over to CFA. We lit a few candles first just to show people how to interact with our mountain, but most people had no trouble at all figuring it out. Lots of people came by and lit candles, most adding dyes and watching the streams. We did not anticipate the wax “rivers” that would form from flowing dye, but those were very mesmerizing. We also did not expect the wax from 300 candles to begin leaking into the internal structure, and it started leaking out onto the platform. Here’s where the aluminum came into play; we were able to round up the corners and contain the wax without dropping it all over the ground. While it did not save Zach’s pants, we later found that the buildup of wax layers created many beautiful colors arranged across different layers, much like a sedimentary rock. The dyes worked great. Mother nature felt kind that night, and it wasn’t too cold or windy for the most part. It even helped; the inside was so cacophonous that many people preferred to be outside anyway. Davine put together a last-minute project setup, streaming from outside onto the ceiling in the Great Hall to remind everyone inside that we were outside. Overall, everyone who came by had a great time lighting and dying candles and what it created was truly beautiful.

A group of friends tries to activate all the sections of the balloons at once

In-Progress Media

This image shows us testing colors on our maquette. We decided to get rid of the red and green colors and mostly keep yellow, white, purple and blue to symbolize the colors of a thunderstorm.

Testing out the sensitivity of the force sensitive resistors.

Here we were laser cutting the box to hold our Arduino, breadboard and wires.

Judenique setting up connections inside the laser cut box.

All the wires from the sensors leading to the main box

Olivia working on putting the sensors under the stickers on the steps

The decals on the stairs installed

Here is after we realized that our plan to use velcro to attach the eye hooks to the wall was not going to work and we needed to use aluminum tape to secure the balloons to the walls.

Experimenting with different colors before the event

Dancing Clouds in Action

Close up of the balloons: the leds are controlled by the pressure-sensitive resistors

Balloons are up and installed, currently there is no power running

The aftermath of the project: only the LEDs and string remain

Description

The Dancing Cloud is an installation made up of balloons illuminated by a colored LED strip. The colors of these balloons is controlled by people stepping on force-sensitive resistors placed along the stairs in the CFA Great Hall. When there are no people stepping on these steps, the colors react to sounds in the environment.

The LED strip is wrapped along a 16 feet rope spanning from the Zebra lounge to the other side of the wall along the main entrance of CFA. The balloons are wrapped and tied around this long piece of rope. The rope is held up by hooks screwed into 2 wooden blocks which we attached to the walls around 9 feet high. The force-sensitive resistors are placed on the stairs covered by colorful decals, so that people know where to step to trigger a change in color. We have wires attached along the wall and floors coming from the string of balloons, the force sensitive resistors, the microphone and the power supplies to the laser cut box where everything is connected together with the Arduino and breadboard.

Process Reflection

What worked well?

The waterproof LEDs were blunt and worked well to not cause any balloons to pop throughout the time installation was running. The entire circuit also ran for a long time without running into issues. Furthermore, the balloons retained their size over 2 days allowing us to get started with the installation process before the day of the show.

Selecting specific white balloons that weren’t fully opaque, and testing them with the maquette helped us figure out how well the LED lights shone through the balloons. Our choices were well made because the balloons appropriately replicated the colors of the LEDs. The dark atmosphere in the CFA further helped our balloons stand out.

Our installation also looked mostly clean and very presentable. We were able to restrict the wires from the decals to the stairs to the edges such that it didn’t interfere with people climbing up the steps. We also tied the string of balloons high enough so that people did not crash into it. It ended up being at a good height where it was very noticeable as well.

Challenges faced and what we could have done better?

We encountered issues working with the command strips to attach the blocks to the wall. Specifically, it was an issue trying to get it working high up on the wall where we could not apply enough force in the right way. We had to resort to using aluminum tape. On one hand, this tape was quite strong and held up the blocks well. On the other hand, it did not look very pretty. In hindsight, it would have been a much better idea to test the command strips ahead of time to make sure they worked on the day of installation.

One of the other issues we noticed while the installation was in place was that the force sensitive resistors under the decals did not work as well as we hoped. With shoes like heels and even some regular shoes, the sensors did not always sense something unless stepped on in a certain way. However, when it worked, it did keep people occupied to watch themselves influence the colors of the balloons. We even had groups of people who tried to light up all sections of the balloons by stepping on all of the decals. If we had more time, we could have tried to test several decals and materials used before we installed them.

We also received some feedback suggesting some way to let people know what our installation was. We realized it may have been difficult for people walking downstairs to realize what the decals they stepped on did. People also may not have known that the balloons were reacting to sound from the environment. Since the sound from the environment was random, the balloons changing colors might have also seemed random unless there was a large spike in sound. Furthermore, the presence of so many other installations may have resulted in people not realizing if it was connected to something else like the decals. Having some sort of a sign near the stairs explaining our installation may have resulted in more people interacting with it.

What change could we have made to take our project in a different direction?

We could have decided to implement the LEDs and force sensitive resistors in many different ways to create a similar effect to our project. We could have designed a smaller scale installation that looked more like an object rather than a large mass hanging above our heads. We considered the idea of using fabric for our project so perhaps we could have covered the LEDs in fabric and created a similar glowing effect that the balloons had. The way that people experience our project would have been very different if we had made something as a smaller scale but overall we are happy with the success we had with the Dancing Cloud.

Code

  // Group Judge My Vow
  // Dancing Clouds
  // Creats an instance of the Pololu LED strip
  // Uses 6 force sensitive resistors and 1 Adafruit mic
  // The force sensitive resistors and mic are inputs for the led strip
  // where the sound received is a countinuous change and the 
  // force sensitive resistors change sections of the strip to 


#include <PololuLedStrip.h>

// Create an ledStrip object and specify the pin it will use.
PololuLedStrip<12> ledStrip;

// Create a buffer for holding the colors (3 bytes per color).
#define LED_COUNT 300
rgb_color colors[LED_COUNT];

const int FCR0 = A0; //defining analog sensors
const int FCR1 = A1;
const int FCR2 = A2;
const int FCR3 = A3;
const int FCR4 = A4;
const int MIC = A5;
const int FCR5 = 5;
bool priority = true;

int forceVal0, forceVal1, forceVal2, forceVal3, forceVal4, forceVal5;

const int sampleWindow = 50; // Sample window width in mS (50 mS = 20Hz)
unsigned int sample;

void setup() {
  pinMode(FCR0, INPUT);
  pinMode(FCR1, INPUT);
  pinMode(FCR2, INPUT);
  pinMode(FCR3, INPUT);
  pinMode(FCR4, INPUT);
  pinMode(FCR5, INPUT);
  Serial.begin(9600);
}

void loop() {

  // setting all the values of the force sensitive resistors
  forceVal0 = analogRead(FCR0);
  forceVal0 = map(forceVal0, 0, 1023, 0, 255);
  delay(10);

  forceVal1 = analogRead(FCR1);
  forceVal1 = map(forceVal1, 0, 1023, 0, 255);
  delay(10);

  forceVal2 = analogRead(FCR2);
  forceVal2 = map(forceVal2, 0, 1023, 0, 255);
  delay(10);

  forceVal3 = analogRead(FCR3);
  forceVal3 = map(forceVal3, 0, 1023, 0, 255);
  delay(10);

  forceVal4 = analogRead(FCR4);
  forceVal4 = map(forceVal4, 0, 1023, 0, 255);
  delay(10);

  forceVal5 = digitalRead(FCR5);


  // Sensors take priority
  // If they are not pressed, sound input is received
  if (!priority) {
    unsigned long startMillis = millis(); // Start of sample window
    unsigned int peakToPeak = 0;   // peak-to-peak level

    unsigned int signalMax = 0;
    unsigned int signalMin = 1024;

    // collect data for 50 mS
    while (millis() - startMillis < sampleWindow) {
      sample = analogRead(MIC);
      if (sample < 1024) { // toss out spurious readings
        if (sample > signalMax) {
          signalMax = sample;  // save just the max levels
        }
        else if (sample < signalMin) {
          signalMin = sample;  // save just the min levels
        }
      }
    }
    peakToPeak = signalMax - signalMin;  // max - min = peak-peak amplitude
    double volts = ((peakToPeak * 5.0) / 1024) * 10;  // convert to volts

    // map the sound input
    int soundc = map(volts, 0, 20, 0, 255);

    // when the sound input is above a certain threshold, the led string flashes white
    if (soundc > 340) {
      for (int i = 0; i < LED_COUNT; i++) {
        colors[i] = rgb_color(255, 255, 255);
      }
      ledStrip.write(colors, LED_COUNT);
      delay(100);

      for (int i = 0; i < LED_COUNT; i++) {
        colors[i] = rgb_color(0, 0, 0);
      }
      ledStrip.write(colors, LED_COUNT);
      delay(100);
    }

    // the colors are defined by the input sound converted to rgb
    else {
      for (uint16_t i = 0; i < 300; i++) {
        byte x = (soundc >> 1) - (i << 3);
        colors[i] = hsvToRgb(soundc * 5 - (i * 3), 255, 255);
      }
    }

    // Write the colors to the LED strip.
    ledStrip.write(colors, LED_COUNT);
    delay(10);
  }

  // Chack if the pressor sensors are activated
  // Light up sections of the balloon based on a specific resistor
  else {
    //FSR0
    if (forceVal0 > 10) {
      for (uint16_t i = 0; i < 50; i++) {
        colors[i] = rgb_color(255, 255, 255);
      }
      for (uint16_t i = 200; i < 250; i++) {
        colors[i] = rgb_color(255, 218, 0);
      }
    }
    else {
      for (uint16_t i = 0; i < 50; i++) {
        colors[i] = rgb_color(0, 0, 0);
      }
      for (uint16_t i = 200; i < 250; i++) {
        colors[i] = rgb_color(0, 0, 0);
      }
    }

    //FSR1
    for (uint16_t i = 50; i < 100; i++) {
      if (forceVal1 > 10) {
        colors[i] = rgb_color(0, 0, 255);

      } else {
        colors[i] = rgb_color(0, 0, 0);
      }
    }
    for (uint16_t i = 250; i < 300; i++) {
      if (forceVal1) {
        colors[i] = rgb_color(0, 255, 255);

      } else {
        colors[i] = rgb_color(0, 0, 0);
      }
    }

    //FSR2
    for (uint16_t i = 100; i < 150; i++) {
      if (forceVal2 > 10) {
        colors[i] = rgb_color(75, 0, 103);

      } else {
        colors[i] = rgb_color(0, 0, 0);
      }
    }
    for (uint16_t i = 250; i < 300; i++) {
      if (forceVal2) {
        colors[i] = rgb_color(0, 255, 255);
      }
    }

    //FSR3
    for (uint16_t i = 0; i < 50; i++) {
      if (forceVal3 > 10) {
        colors[i] = rgb_color(255, 255, 255);
      }
    }
    for (uint16_t i = 150; i < 200; i++) {
      if (forceVal3 > 10) {
        colors[i] = rgb_color(255, 200, 0);

      } else {
        colors[i] = rgb_color(0, 0, 0);
      }
    }

    //FSR4
    for (uint16_t i = 200; i < 250; i++) {
      if (forceVal4 > 10) {
        colors[i] = rgb_color(255, 140, 0);
      }
    }
    for (uint16_t i = 100; i < 150; i++) {
      if (forceVal4 > 10) {
        colors[i] = rgb_color(255, 0, 255);
      }
    }

    //FSR5
    for (uint16_t i = 250; i < 300; i++) {
      if (forceVal5) {
        colors[i] = rgb_color(0, 255, 255);
      }
    }
    for (uint16_t i = 100; i < 150; i++) {
      if (forceVal5) {
        colors[i] = rgb_color(75, 0, 130);
      }
    }
    for (uint16_t i = 0; i < 50; i++) {
      if (forceVal5) {
        colors[i] = rgb_color(30, 144, 225);
      }
    }

    // Write the colors to the LED strip.
    ledStrip.write(colors, LED_COUNT);

    delay(10);

  }

  // determines which input is currently being received
  bool f0 = (forceVal0 > 10);
  bool f1 = (forceVal1 > 10);
  bool f2 = (forceVal2 > 10);
  bool f3 = (forceVal3 > 10);
  bool f4 = (forceVal4 > 10);
  bool f5 = forceVal5;

  priority = (f0 || f1 || f2 || f3 || f4 || f5);
}

// code from example library for neopixels
rgb_color hsvToRgb(uint16_t h, uint8_t s, uint8_t v)
{
  uint8_t f = (h % 60) * 255 / 60;
  uint8_t p = (255 - s) * (uint16_t)v / 255;
  uint8_t q = (255 - f * (uint16_t)s / 255) * (uint16_t)v / 255;
  uint8_t t = (255 - (255 - f) * (uint16_t)s / 255) * (uint16_t)v / 255;
  uint8_t r = 0, g = 0, b = 0;
  switch ((h / 60) % 6) {
    case 0: r = v; g = t; b = p; break;
    case 1: r = q; g = v; b = p; break;
    case 2: r = p; g = v; b = t; break;
    case 3: r = p; g = q; b = v; break;
    case 4: r = t; g = p; b = v; break;
    case 5: r = v; g = p; b = q; break;
  }
  return rgb_color(r, g, b);
}

close-up of one of the camera/microphone pipes in the performance space

close-up of the melon

Narrative Description:

A parasitic pipe organism has taken over CFA. The pipes spread through the walls from the Alumni Concert Hall, where they collect and display video and audio information for visiting humans to hear. These ducts emerge from the floor in all of their aluminum glory; some are more bendy and allow the humans to pick them up to listen, others are self-supporting. The pipes allow humans to experience the goings-on of the main hall without all of the busyness, and also allow them to experience performances from various locations all in the same space.

Hints of the CFA pipe infection was first discovered by Henry Hornbostel himself in May of 1923, but it wasn’t tracked until the late 1980s when a group of paranormally-inclined students decided to track and journal the progress of the spreading infection. They called themselves the “Brazil Pipe-Watching Society” or BPWS. At the time, the infection was contained entirely inside the walls themselves and the organism’s data-transfer capabilities were limited to crude acoustics. In the late 2010s, the organism became capable of mimicking CCTV video surveillance systems, and small video-capture pipes burst through the walls into the main hall. Around this time, a government research team from Southern New Zealand happened upon the student journals and decided to investigate for themselves due to fears for the confidentiality of New Zealand’s rich and secretive subterranean avocado industry. In December of 2021, the organism’s heart suddenly burst forth through the floor of the Alumni Concert Hall, where it had been growing dormant for nearly a century. The New-Zealand researchers responded fast, and fully eradicated the organism from CFA, much to the dismay of students of BPWS. Since then, little remains of the ductwork organism, just discarded foil and limbs which will safely remain in Hunt A5 for many years to come, or until Zac gets annoyed.

Process Photos:

we got the stuff !

Mockup of pipe bases, includes both the less flexible and flexible ducts

planning out the final layout

wall pipe mockup

on the way to install everything

Finished making all of the bases and supports for the bendy pipes

testing various ways of supporting bendy pipes. This iteration didn’t work

Process Reflection:

The process was highly reflective, primarily due to the extensive use of aluminum foil and reflective tape.

We ended up being very happy with the design concept for the installation, but struggled a bit with execution. We were able to set up all of the pipes, but a large portion of the installation’s electronics failed. A major issue we faced was just lack of time towards the end, mostly because we changed concepts a few times leading up to the installation week, and didn’t have enough time to properly test everything before the final install.

The installation process itself ended up being far more chaotic than we expected, primarily because we didn’t have room access until the show was actually happening. The scale of the other installations was larger than we thought, so testing the camera/microphone pipes and running wires while the show was happening was really difficult.

The electronics turned out to be very difficult mostly just because of scale. An audio cable is easy, but 300ft of audio cables is not. In the end, a lot of little bits failed because they were rushed and we didn’t test in the actual setting extensively enough. The audio cables were likely shorting occasionally which would kill the microphones, and the thick walls of CFA made the video signal on the melon too weak to work (the vertical/horizontal sync just refused to work if the signal wasn’t really strong). Ideally we would have tested all of these things beforehand, but because of time we could not.

We did however learn that even if your thing doesn’t work you can still show it as long as you have good lighting, which we were lucky enough to bring along with us. Although it definitely would have been even cooler if everything functioned, people still enjoyed looking at the project, which is definitely some form of success. Two of the video feeds worked which was great, but the audio breaking was super unfortunate.