Inputs: Pressure and Sound

Outputs: LEDs inside balloon cloud

This project is an interactive installation with pressure sensors mapped along the stairs at the main entrance to CFA. When a person steps on each target it turns on different sections of lights within the balloon cloud. When there is nobody stepping on the targets, the lights will react to sounds from the background or another project. Ideally, this reaction will be based on frequencies. If not, it is likely to be based on volume. The balloon cloud will light up with colors like blue, white, yellow, and green to symbolize a thunderstorm. This project is intended to be situated by the stairs near the zebra lounge. Any people passing by can interact with it.

Our maquette demonstrates a small portion of the balloon cloud. The final project will be about 4 times the length and hung horizontally across the stairs not vertically. So far the code for controlling the lights via pressure sensor works great and we are working on the code for the sound input.

To Do List:

• Order LED strips with protective covers so they don’t pop the balloons
• Create decals in the shape of targets to put over the resistors (diy)
• Blow up all of the balloons and attach to string
• Hand cut wooden blocks with eye hooks for wall attachment using velcro
• Laser cut box to house electronics ( 1′ x 1′ x 4″) with two holes 1.5″ diameter for wires
• Cut 20, 21, 21, 22 ft wires
• Solder longer ~20 ft wires to all of the force sensitive resistors so they can reach the electronics box
• Make all connections and put it in the box
• Finalize code for detecting frequencies and volumes to run whenever the pressure sensors are not running
• Fix colors on LEDs

Sketch:

Do you have controversial opinions? Do you have no controversial opinions? Do you have a spicy hot take or a dark secret that you want off your shoulders? Are your thoughts harmless and acceptable or fringe and dangerous?

The Social Pariah Project for a Happier Life is dedicated to exposing you and your friends to new and exciting ideas!

The Concept

Each visitor to the Social Pariah Project is assigned an electronics-equipped wearable that can detect and expose your controversial opinions. The wearables resemble a sorting hat with feathery ears and a prominent lightbulb. The ears animate when the hat is thinking or excited, and the bulb glows to demonstrate your (probable) support for controversial topics as they show up on a prominent display.

The hats are equipped with ESP8266 microcontrollers, LEDs, batteries, and a servo. The hats and prompt displays communicate with a server running on AWS.

How it Works

Opinions and topics are sourced in a few ways:

1. Statistical prompts (decided ahead of time). Real world data reflected by a random group of hats lighting up.
   “Doesn’t believe in climate change”
   1. “Didn’t get vaccinated”
   2. “Goes to therapy”
   3. “Thinks therapy is stupid”
   4. “Has an undiagnosed mental condition”
   5. “Has sociopathic tendencies”
   6. “Knows a sociopath”
   7. “Will develop alzheimer’s in their lifetime”
   8. “Is clinically depressed”
   9. “Is hangry right now”
   10. “Disagrees with affirmative action”
   11. “Does not support reparations”
   12. “Reads Ayn Rand”
2. User-submitted hot takes (generally more light-hearted)
   1. “Thinks white chocolate tastes decent”
   2. “Still does the Donnnnner thing”
   3. “From the South“
   4. “Voted for Panic! Art The CFA for this show’s title”
3. Survey-answers are prompts based off of demographic info or survey questions
   1. “Thinks being in exploded ensemble is cool”
   2. “Would complain that this project promotes cancel culture”

Every 30 seconds or so the prompt rotates, and the hats collectively think and decide if their wearer supports the claim. Eventually they either light up or don’t to indicate your support.

A key aspect is that your support could be real or randomly decided by the council of sorting hats! Wearers will also have the choice to “opt-in” to a claim by pressing a button on their hat.

Statistical vs user-submitted prompts will be differentiated by background colors and animations of the prompts.

Block Diagram

Narrative Description

Constellations is a series of hanging circular foam forms that will move and react based on direction and amplitude of sound or distance to the audience. Beyond reacting to the environment, each of the hanging forms will also sometimes take on a shape with an image projected onto them. We’re hoping to make forms and shapes that look emergent; that is, the circular forms look like they are moving randomly or as reactions, but are actually headed towards a goal shape. This is only revealed when the goal states are reached, and the projected image appears.

We have not decided what we would like the inputs to be, but considering how much sound will be present in the hall, we figured sound input would be easy to get and cause lots of movement in our piece. Theoretically, we could work with two streams. The environmental input could influence the motors and the other group’s input could influence the projector or vice versa. Regardless, we would like to install this piece over one of the ledges/balconies in the CFA, so the audience views it from the ground floor. 

We chose this idea inspired by the starling murmurations video. The birds randomly forming these massive shapes is awe-inspiring, and we wanted to recreate this experience of seeing random actors move and react and assemble together by pure chance into shapes that have real meaning. 

Drawing

Here’s a rough drawing of our envisioned project. A set of chains are draped over a balcony with circular forms, which will move up and down reacting to the environment. Randomly, the forms will align in certain patterns like stars in a constellation. When this happens, the projector on the ground will suddenly turn on and project the image of the constellation to make the final shape obvious. 

Materials

• Controller + Computer
• Continuous-rotation motors with encoders
• 40ft Ball chain x number of motors
• 3D printed mounts for the motors to hold the ball chain
• Foamcore, cut into various shapes (for targets)
• Projector (cast image onto the targets)

Idea 2: Flaming Hills

Block Diagram

Narrative Description

Inspired by the Giant’s Causeway in Ireland, we’d like to create a natural landscape composed of tiled hexagonal column candles. As the candles are lit, the melted wax will pool and drip organically, eroding the landscape over time. Event visitors can choose which candles to light or put out, collaboratively altering the terrain over the course of the exhibition. As they pass the candles later, they can see the marks and pits that their choices have made upon the landscape. 

Additionally, the data output from another group (sound, color, etc.; we don’t know what the other projects are yet!) will be mapped onto our arrangement of candles; the data we receive will also determine which candles will be lit, working with/against the human audience input. For example, we could set up fans to fan the flames or blow certain candles out. Beyond electronic input, we’ll also want to have the candles exposed. This way, the breeze that people generate by simply walking past will get the flames dancing and potentially even put some of them out. 

• We’d like this piece to be installed indoors if possible, since if it’s outside, environmental input like wind may also affect our flames. 

Materials

• Candle wax – purchase
• Thin candle wicks – purchase
• (15-20) hexagonal candle molds – purchase
• Grill lighters (participants light candles)

Need to make >100 1.5” hexagonal candles, varying heights

Inspiration Giant’s Causeway + Drawing

Like humans, plants operate using electrical biosignals. Where humans use biosignals for complex thoughts, vocal expression, and muscle control, plant biosignals indicate temperature, sunlight, humidity, wound and “pain” responses, touch, or nutrient levels. These primal “thoughts” of a plant are slow and change over minutes, not seconds. When listening to these biosignals as sound, the sounds are ambient and evolve slowly or stay constant.

By talking into a microphone, the installation picks up our thoughts and transmits them into a plant using electrical impulses. The biosignals of the plant are constantly measured and played back as ambient sound. In a way, it’s a drawn-out and restricted speech process. The goal is to make the user think about how speech and thought itself is a complex and abstract transductive process, and take whatever meaning they want.

The setup has a microphone opposite of the plant, with speakers around it. The user is invited to share their thoughts, play a voicemail, or ask a question to be transduced through the plant. The experience is intended to be slightly meditative, and the responses are intentionally completely unintelligible and ambient. After all, you’re talking to a plant.

The presentation will likely be a video of scripted encounters with the plant. I like the idea of making it interactive, but I want to curate a list of interactions as well.

Work so far

I’ve spent a bunch of time working on the actual plant instrumentation. I have it working on a bench with an oscilloscope, and can see the biosignals evolve over time. My issue right now is trying to get an amplifier board to work so that an arduino can pick up the signals. I’ve done a bunch of experiments, and settled on using acupuncture needles as electrodes instead of surface pads.

Project Statement:

This project is an audio and visual touchpad driven by nine force sensitive resistors. The visuals controlled by these nine analog inputs will be projected onto multiple screens to create an immersive installation. The user can press along a grid of sensors to change the gradient and size of the ellipses on the screen. The force sensitive resistors will also control a sound output that increases in volume as the voltage increases.  It is designed to be an interactive experience that gets people excited about generating their own unique artwork. It is designed for members of the public or friends of mine in the architecture studio to use.

Fabrication:

Making the box to house electronic components

Visuals: Currently all being controlled by the same input (mousepress) because my serial connection to the analog inputs on the arduino is not working yet

Code:

I have been trying to debug an error with the serial connection between processing and arduino but no matter what I try I still get the error saying the COM5 port is busy. Serial monitor on arduino is always closed and I have tried restarting everything. Maybe I am just missing something small.

Here is my arduino code.

//read nine force sensitive resistor

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 FCR5 = A5;
const int FCR6 = A6;
const int FCR7 = A7;
const int FCR8 = A8;

void setup() {
  // put your setup code here, to run once:
  pinMode(FCR0, INPUT);
  pinMode(FCR1, INPUT);
  pinMode(FCR2, INPUT);
  pinMode(FCR3, INPUT);
  pinMode(FCR4, INPUT);
  pinMode(FCR5, INPUT);
  pinMode(FCR6, INPUT);
  pinMode(FCR7, INPUT);
  pinMode(FCR8, INPUT);
  Serial.begin(115200);
}

void loop() {
  // put your main code here, to run repeatedly:
  //if we get a valid byte, read analog ins:
  //if (Serial.available() > 0) {
  // get incoming byte:
  //inByte = Serial.read();

  //read the value of the resistance and store it
  int forceVal0 = analogRead(FCR0);
  //map value to 255
  forceVal0 = map(forceVal0, 0, 1023, 0, 255);
  Serial.println(forceVal0);
  delay(10);

  int forceVal1 = analogRead(FCR1);
  //map value to 255
  forceVal1 = map(forceVal1, 0, 1023, 0, 255);
  Serial.println(forceVal1);
  delay(10);

  int forceVal2 = analogRead(FCR2);
  //map value to 255
  forceVal2 = map(forceVal2, 0, 1023, 0, 255);
  Serial.println(forceVal2);
  delay(10);

  int forceVal3 = analogRead(FCR3);
  //map value to 255
  forceVal3 = map(forceVal3, 0, 1023, 0, 255);
  Serial.println(forceVal3);
  delay(10);

  int forceVal4 = analogRead(FCR4);
  //map value to 255
  forceVal4 = map(forceVal4, 0, 1023, 0, 255);
  Serial.println(forceVal4);
  delay(10);

  int forceVal5 = analogRead(FCR5);
  //map value to 255
  forceVal5 = map(forceVal5, 0, 1023, 0, 255);
  Serial.println(forceVal5);
  delay(10);

  int forceVal6 = analogRead(FCR6);
  //map value to 255
  forceVal6 = map(forceVal6, 0, 1023, 0, 255);
  Serial.println(forceVal6);
  delay(10);

    int forceVal7 = analogRead(FCR7);
  //map value to 255
  forceVal7 = map(forceVal7, 0, 1023, 0, 255);
  Serial.println(forceVal7);
  delay(10);

    int forceVal8 = analogRead(FCR8);
  //map value to 255
  forceVal8 = map(forceVal8, 0, 1023, 0, 255);
  Serial.println(forceVal8);
  delay(10);
}

Here are the two processing codes that I have been working with. The first one I have written is the one that needs debugging on the serial connection. I have it trying to draw a single ellipse based off of the values from the first force sensor. The second one I am using to see my completed visuals without a serial connection to the arduino for now. I will transfer this code over once I get the connection debugged on the other code. I will also add in the audio after the serial connection works.

//serial connection not working but I think I am close!

import processing.serial.*;
import cc.arduino.*;
import org.firmata.*;

Arduino arduino;

int forceVal0; //defining analog sensors
int forceVal1;
int forceVal2;
int forceVal3;
int forceVal4;
int forceVal5;
int forceVal6;
int forceVal7;
int forceVal8;


Serial myPort; //create an object
String val; //data recieved from the serial port

int[] serialInArray = new int[3]; // Where we'll put what we receive
int serialCount = 0;     // A count of how many bytes we receive

void setup() {

  size(1500, 1500);
  colorMode(HSB,100);
  smooth();
  fill();
  ellipseMode(CENTER);
  arduino = new Arduino(this, Arduino.list()[0],115200);

  // List all the available serial ports

  // Open whatever port is the one you're using.
  //String portName = "COM5";
  myPort = new Serial(this, "COM5", 115200);

  // don't generate a serialEvent() unless you get a newline character:
  //myPort.bufferUntil('\n'); <-- do i need this

  arduino.pinMode(forceVal0, Arduino.INPUT);
  arduino.pinMode(forceVal1, Arduino.INPUT);
  arduino.pinMode(forceVal2, Arduino.INPUT);
  arduino.pinMode(forceVal3, Arduino.INPUT);
  arduino.pinMode(forceVal4, Arduino.INPUT);
  arduino.pinMode(forceVal5, Arduino.INPUT);
  arduino.pinMode(forceVal6, Arduino.INPUT);
  arduino.pinMode(forceVal7, Arduino.INPUT);
  arduino.pinMode(forceVal8, Arduino.INPUT);
}

void draw() {

  // set the background color with the color values:
 
  println(forceVal0);
  //change the background according to analog read
  background(forceVal4, forceVal7, forceVal1);

  //draw the ellipses
  strokeWeight(10);
  stroke(100, 100, 100, 100);
  fill(255, 0, 0);
  ellipse(width/2, height/2, forceVal0, forceVal0);
}

//code that made the gradient visuals seen above!

ArrayList<Circle> circles;

void setup() {
  size(1500, 1500);
  colorMode(HSB, 100);
  smooth();
  noFill();
  circles = new ArrayList<Circle>();
}

void draw() {
  background(0);
  for (Circle  c : circles) {
    c.draw();
    c.update();
  }
}

void mousePressed() {
  circles.add(new Circle(375, 375, mouseX/2, mouseY/2));
  circles.add(new Circle(750, 375, mouseX/2, mouseY/2));
  circles.add(new Circle(1125, 375, mouseX/2, mouseY/2));

  circles.add(new Circle(375, 750, mouseX/2, mouseY/2));
  circles.add(new Circle(750, 750, mouseX/2, mouseY/2));
  circles.add(new Circle(1125, 750, mouseX/2, mouseY/2));

  circles.add(new Circle(375, 1125, mouseX/2, mouseY/2));
  circles.add(new Circle(750, 1125, mouseX/2, mouseY/2));
  circles.add(new Circle(1125, 1125, mouseX/2, mouseY/2));
}


class Circle {
  int hue = 0;
  float x, y, w, h, sw;

  Circle(float x, float y, float w, float h) {
    this.x = x;
    this.y = y;
    this.w = w;
    this.h = h;
    sw = random(2, 2);
  };

  void draw() {
    strokeWeight(sw);
    stroke(hue, 100, 100, 100);
    fill(hue, 100, 100, 25);
    ellipse(x, y, w, h);
  }

  void update() {
    hue++;
    if (hue == 100) {
      hue = 0;
    }
  }
}

Here’s the mockup of the top shell that I’m adding to the handheld EMI meter. There are no electronics in it, but after I added them it looked the same as this photo.

Using analogWrite to drive a current gauge. Gonna rebrand that thing as an EMI meter.

Turns out that taking probability class is very helpful, because I knew how to generate “random” pulses using the Arduino. Sounds great, very similar to Geiger counter’s actual clicking noise.

Full setup. I added this to the 3D printed shell and handle from above, and that’s what my 90% looks like!

Maquette of Touch Pad

Possible visuals:

Materials I have

• Jumper cables
• Rechargeable battery pack

Materials Available

• Arduino due
• Force sensitive resistors
• Projector
• Thin sheet of (wood?) to cover resistors

Materials to be ordered

• possibly a thin sheet of silicone to cover the pressure sensors