This week the focus was on prototyping for the midterms: after ideation my project-partner Keerthana and I prototyped all parts of our idea and tested the electronic components.




Bring back the souls of musicians that have passed away for a few brief moments in a modern form of ritual. 



The audience picks up headphones situated in front of them. Audio will guide them throughout the ritual.

They are asked to turn a wheel of fortune with graphics of four musicians etched on it. The wheel stops at a certain position - a musician gets selected by chance. The artist wants to come back for a few moments from the dead into our world.

Now the participant will put her hands with palms upwards on a screen below the wheel. A drop of water - symbolizing the soul of the musician - will drop from underneath the wheel on the hand of the participant. The moment it hits her palm, a graphic depicting the artist will start rotating on the screen situated underneath the participants hand and a song of the artist is played in the headphones.

After this audio-visual and touch stimulation the participant will listen to the song until it finishes, then take the drop of water left in her palm and put it into a little plant on top of the wheel. The soul of the musician has briefly visited earth and is taken back to heaven now. The plant is watered by the souls of those great artists that have passed away and symbolizes the eternal cycle of creation. 


We chose 4 musicians: Amy Winehouse, David Bowie, Minnie Ripperton and John Coltrane. Both female and male artists from across different genres. 

To prototype the wheel we measured the rotary encoder (used to track the exact position of the wheel to identify the selected musician), constructed all parts in Illustrator and laser-cut in black card-board. The musicians are etched outlines of their silhouettes.


Unfortunately the outlines of Minnie Ripperton were cut instead of etched - something to fix for the final version.

After the laser-cutting we worked on the arduino-code to operate the rotary encoder and the connection to p5. p5 will run the main code with the graphics for the screen, arduino will control the rotary encoder and the water-drop system (solenoid valve).

We used a code-example for a rotary-encoder and customized it to our needs:

# based on a script by Dejan Nedelkovski (

#define outputA 2
 #define outputB 3
 #define reset_button 5
 int counter = 0;
 int star = 0;
 int aState;
 int aLastState;
 void setup() { 
 pinMode (outputA,INPUT);
 pinMode (outputB,INPUT);
 pinMode (reset_button, INPUT);
 Serial.begin (115200);
 // Reads the initial state of the outputA
 aLastState = digitalRead(outputA); 
 void loop() { 
 aState = digitalRead(outputA); // Reads the "current" state of the outputA
 // If the previous and the current state of the outputA are different, that means a Pulse has occured
 if (aState != aLastState){ 
 // If the outputB state is different to the outputA state, that means the encoder is rotating clockwise
 if (digitalRead(outputB) != aState) { 
 counter ++;
 } else {
 counter --;
 if (counter == 40 || counter == - 40){
counter = 0;
 if (counter > -6 && counter <= 4){
star = 1;
 if (counter > 4 && counter <= 14){
star = 4;
 if (counter > 14 && counter <= 24){
star = 3;
 if (counter > 24 && counter <=34){
star = 2;
if (counter < -6 && counter >= - 16){
star = 2;
 if (counter < - 16 && counter >= - 26){
star = 3;
 if (counter < - 26 && counter >= - 36){
star = 4;
 if (counter > 34 && counter < 40){
star = 1;
 if (counter < - 36 && counter > -40){
star = 1;
 //Serial.print("Position: ");
 aLastState = aState; // Updates the previous state of the outputA with the current state
 if (digitalRead(reset_button) == HIGH){
 else {

We already included the serial communication with p5 in the code above. In p5 we used a basic script for reading the serial port and displaying names of the musicians to test the functionality. We will change this to rotating graphics depicting the musicians later this week.

var portName = '/dev/cu.usbmodemFA131';  // fill in your serial port name here
var options = { baudrate: 115200}; // change the data rate to whatever you wish

var serial;          // variable to hold an instance of the serialport library
var inData;                             // for incoming serial data

var star;

function setup() {
  createCanvas(600, 600);
  serial = new p5.SerialPort();       // make a new instance of the serialport library
  serial.on('list', print);  // set a callback function for the serialport list event
  serial.on('connected', serverConnected); // callback for connecting to the server
  serial.on('open', portOpen);        // callback for the port opening
  serial.on('data', serialEvent);     // callback for when new data arrives
  serial.on('error', serialError);    // callback for errors
  serial.on('close', portClose);      // callback for the port closing
  serial.list();                      // list the serial ports
  serial.open(portName, options);

function serverConnected() {
  print('connected to server.');
function portOpen() {
  print('the serial port opened.')
function serialEvent() {
 inData = Number(serial.read());
function serialError(err) {
  print('Something went wrong with the serial port. ' + err);
function portClose() {
  print('The serial port closed.');

function draw() {
  //text("sensor value: " + inData, 30, 30);
  if (inData == 1){
      text("Star: Minnie", 30, 100);
  if (inData == 2){
      text("Star: David", 30, 100);
  if (inData == 3){
      text("Star: Amy", 30, 100);
  if (inData == 4){
      text("Star: John", 30, 100);

We prototyped as well the water drop mechanism with the solenoid valve with a 9V battery. 

In the next few days we will work on automating everything with p5 / Arduino and fabrication.