During the visit, our valve mechanism did not work very well. The cardboard flap we had inside the fan duct failed to successfully cut off air flow, which led to our project not being able to modulate air properly. In the end, we just let the flap open so that the air can flow continuously over the bottles to make sound the whole time. However, in the future, we want the flap to be functional so that it can produce different air modulation patterns in order to open the opportunity for more interaction between human and machine.

We found that children found delight in spinning the turntable. Adults were quick to understand the concept of our project and explained to children how changing the water levels would change the sound when air passes through the bottle. Some adults were interested in our setup with the fan and even tried spinning the turntable as well.

It was surprising to see how uninterested most of the children were in changing the water levels. They seemed to be more enticed with turning and watching the turntable as opposed to the sound-producing aspect of the project. However, near the end of our time at the museum, one child was interested in hearing how a bottle would sound if it was filled to the brim with water. So she filled a bottle up with water and placed it under the fan to see how it would sound. Finding that no sound was being produced, she kept pouring a little bit of water out until it finally did produce sound (see: Summary Video).

In order to highlight the sound production aspect of the project, we plan on adding a functional  and more aesthetically pleasing fan duct as well as flap to modulate air. Additionally, we plan on installing lights to highlight the bottle that is currently being blown into so that it emphasizes where the sound is coming from. Our original setup did not make clear the location of the bottle producing sound and so we believe that aided in masking the sound production aspect of the project. It also did not really facilitate pouring water in and out of the bottles to change the water levels so we plan on establishing a “water station” to make that more clear and lowering the height of the turntable by either using a smaller table or making our own stand to make the project more accessible to smaller children.

Seeing that the children are more interested in the turning aspect of the turntable, we are now shifting our focus from mechanizing the turntable to controlling the air flow to modulate the air so that the physicality of turning the turntable is not removed from the experience. We want to center the project’s  focus on the interaction between human and machine where the fan flap will be programmed to control air modulation patterns while the children can control which bottles are being played and how much water is in each bottle or what tones can be played.

Summary Video

Photos

Revision Plan

For modulating the air, we will be using a solenoid instead of a servo to ensure a clear cutoff and opening of air flow for sound production. We also need to revise the fan duct design to accommodate the solenoid.

The fundamental experience does not need to be modified very much. Children will still be turning the turntable for the main experience but this time, the project will be more active in changing the sound that is produced. The turntable will also be at a more accessible height and a more appropriate “water station” will be set up to make the task of changing water levels more clear.

Air modulation will be the only new capability that will be added to the initial objectives. Lights will simply be an accessory to highlight sound production.

Task List

Additional Items to be Purchased

• Clear glass bottles
• Lights

CAD Files

In particular, I noticed one child had tried to hand in his paper, only having done the task once although it instructed the child to repeat the task 6 times. A teacher came over to correct him, but the child asked why he had to repeat the task 6 times. From this, we can see that this activity also illustrates how some children can intuit the repetitiveness of a task and deem it purposeless from only doing it once.

This installation consists of a laser harp that plays sound when a laser is broken by physical intervention. There may be an option to make the lasers hidden so that the actual mechanism is hidden from visitors. A system of mechanical fingers that can “play” the laser harp will accompany it and can be programmed to play songs. Sounds played from the laser harp will be amplified through a speaker/amp that will additionally have a visualizer in the form of LEDs to display the frequencies of the sounds being played.

For the Children’s Museum of Pittsburgh, this installation would do well in a dimly-lit room with enough space to fit the installation. Examples of such spaces would be the room across from the Attic or the various dark hallways, which all house similar installations that include light.

A typical visitor experience would start initially with curiosity and a cursory evaluation of the installation, including specifically looking for instructions for how to use the installation, which may or may not be included. A visitor may explore the frame of the harp, which initially will not have the lasers visible, and may stick their hand, or other limbs, through the space, which will trigger sounds to be played on the amp/speaker. Visitors may then realize they have some aspect of control over the sounds and may create their own sort of song. After, visitors may notice the mechanical fingers and attempt to control it. The fingers may be accompanied with simple instructions on how to get it to play a pre-programmed song. Some visitors may be interested in creating their own songs from directly using the mechanized system.

A hallmark of success would be any interaction with the installation that may spark curiosity on how the laser harp works. Another hallmark would be the individual creation of music by visitors, which should be prompted by the awareness of their control of the installation. We expect to observe a lot of physical interaction with the installation, including stepping around the laser harp and manipulating the mechanical fingers.

Technical Outline

This project will consist of three main parts: the mechanical fingers, the speaker/amp, and the harp itself.

The harp will be relatively simple and robust since it is the part that is meant to be roughhoused the most. It will consist of a simple wooden frame with inlaid laser diodes and photo sensors. There could also be an onboard Arduino for processing the signals, but it is unclear at this point if that is necessary. An Arduino would increase the complexity of the harp, but also reduce the number of wires in the harness that goes to the speaker. Wood, laser diodes, and photo resistors are already at our disposal, making this part simple from a materials perspective. Calibrating this part should also be relatively easy, since the difference between a laser directly on a sensor and background light should be significant.

The mechanical fingers are not meant to be touched, but will have to be robust for the inevitable touching they will receive. We have not yet decided upon the exact mechanism that we will use for this task. That being said, the simple micro hobby servos we have will probably work best for driving whatever mechanism we use. Plywood will work well for this part of the project due to its relative strength and ease of working. They will probably play a randomized tune when the harp is in place. When to play will be determined by a micro switch in the base of the harp stand.

The speaker / amp is going to be the most technically challenging due to the musical aspect of this project. It is easy to play pure tones from an Arduino, but not higher fidelity sounds. Thus the amp will have to contain a more advanced controller, such as a Raspberry Pi. A portable speaker can be combined with the audio output of the raspberry pi to create the necessary sounds. The box may also contain LEDs to display the different frequency content of the sounds being played on the top of the box. All of the aforementioned components will be tied down inside a robust plywood box, making it difficult to break this part of the project.

Timeline

The timeline can be found here: Project Proposal: Timeline & BOM.

Project Management

We will divide the responsibilities equally across design, fabrication, and documentation. Nick will be mostly responsible for the electrical portion of the installation while Sora will be mostly responsible for the mechanical portion. However, integrating the two aspects for each part of the installation will be done together to ensure a smooth working demo. Documentation will be done for parts by their respective designers and any artistic additions will be made together.

For this installation, we will need proof-of-concept demonstrations for the laser harp, programming the mechanical fingers to play the harp, and the amp/speaker in addition to the visualizer. These proof-of-concept demos should simply ensure that the specified portion of the installation is feasible and should be done quickly. If they succeed, they can be later scaled to the appropriate size so as to accommodate the envisioned scope of the installation.

For the first on-site test, making sure the laser harp works and responds to physical interaction should be the priority, in addition to its robustness in the hands of children. Next, we should make sure the amp/speakers work so that sounds coming from the laser harp can actually be heard. If those succeed, then we should then prioritize the mechanical fingers and their ability to successfully “play” the harp and follow their programming to play a specific song. Robustness for the mechanical fingers at the mercy of children should also be noted and carefully observed during the on-site test. The visualizer is last in priority as it is not essential to the installation. However, if the previous demos succeed at the first on-site test, then testing the visualizer should be next in priority. Otherwise, it can be tested later at the Children’s School and hopefully be integrated for the final test at the Children’s Museum.

Budget Outline

The Budget Outline can be found in the “BOM” tab here: Project Proposal: Timeline & BOM

Currently, the budget for the project is $100 for the portable speaker, raspberry pi, and LEDs. This could come down with alternative part selection and savvier shopping. Most materials should be able to be sourced from the lab. If there is something we cannot find in the lab, the additional cost should be minimal compared to the cost of those two items.

Sketches

Most of the time, the children seemed to intuitively know to place the balls into the contraption (whether that is based on previous experience or the intuitive design of the contraption is unknown). However, the actual calibration of the balls seemed to require a bit more explanation by an adult. Adult visitors either took a passive role and allowed the child to discover and interact with the exhibit by themselves or took a more active role in showing and explaining how the contraption could be calibrated.

Children were sparked by the largeness of the contraption and the lights resulting from the calibration section of the exhibit. How the ball traveled held the children’s attention as they watched the ball go up the wheel to fall down, bounce against an adjustable surface, and sort itself into the appropriately calibrated lane. The actual calibration was not the center of attention, although it plays a major part in the mechanism of the exhibit. Children seemed more delighted with the visual effect of the calibration section more than its actual function. The mechanism of sorting (how the surface rotated to change the trajectory of the ball when it bounced on it) engaged children’s curiosity as they sought to figure out how the surface “knew” where each color ball had to go. Initiative is the objective that is related to this engagement as children realize they can control the outcome of the exhibit and apply their ideas for controlling the sorting of the ball through the calibration section.

There is no facilitator present for this exhibit; however, there is text that ensures that visitors know where to place the ball and figure out how to calibrate the contraption, although children seem to already intuit where the ball needs to be placed. The aesthetic of the space ensures that the focus of the exhibit is on the sorting mechanism of the ball, with the calibration section off to the side. Because the exhibit is in the corner of the Attic, it is a bit difficult to really notice the calibration section. But the hole where the ball needs to be placed is the first thing that is seen upon approaching the exhibit. This leads wandering eyes to follow the path of the ball, which leads to the sorting mechanism and, with a bit more careful observation, the calibration mechanism that is a bit off to the side. This sort of path aesthetic leads children to focus on an object from start to end in hopes of bringing to their attention their ability to actually control the exhibit with the calibration mechanism. Other exhibits in the Attic feature a similar enclosed-space aesthetic (such as the ‘Gravity Room’), which suggests visitors to explore that enclosed space to search and discover new ways to manipulate themselves and the environment.

Randy the Robot is a self-contained open cube with a personality! He has two IR sensors: one on top and one behind him. Without any human interaction, he likes to turn in circles. However, if you get closer to his top IR sensor, he will react by doing one of three things: move faster, move slower, or wave his hand at you to say hello. If you get closer to his back IR sensor, he will wonder what is there and turn around quickly to see what (or who!) is behind him.

Video

Arduino Code

#include <Servo.h>

// A -> left motor
// B -> right motor
#define MOT_B1_PIN 6
#define MOT_B2_PIN 5
#define MOT_A1_PIN 10
#define MOT_A2_PIN 11
#define LEFT_MOTOR_CIRCLE_SPEED 100
#define RIGHT_MOTOR_CIRCLE_SPEED 130
static int wheel_speed_left = LEFT_MOTOR_CIRCLE_SPEED;
static int wheel_speed_right = RIGHT_MOTOR_CIRCLE_SPEED;

#define SERVO_PIN 9
#define SERVO_UPPER_LIM 60
#define SERVO_LOWER_LIM 5
#define SERVO_INCR_AMOUNT 5

#define IR_BACK_PIN A2
#define IR_TOP_PIN A0
static int back_ir_threshold = int(random(1, 6));
static int back_ir_counter = 0;
static int top_ir_counter = 0;

Servo small_servo;
int servo_pos = 0;
int servo_dir = 1;

#define RANDOM_SEED A1

// https://courses.ideate.cmu.edu/16-223/f2018/text/lib/WheelDrive.html
void set_motor_pwm(int pwm, int IN1_PIN, int IN2_PIN) {
  if (pwm < 0) { // reverse speeds
    analogWrite(IN1_PIN, -pwm);
    digitalWrite(IN2_PIN, LOW);

  } else { // stop or forward
    digitalWrite(IN1_PIN, LOW);
    analogWrite(IN2_PIN, pwm);
  }
}

void incrementServo() {
  int tmp_pos = servo_pos + servo_dir * SERVO_INCR_AMOUNT;

  if (((servo_dir == 1) && (tmp_pos > SERVO_UPPER_LIM)) || 
    ((servo_dir == -1) && (tmp_pos < SERVO_LOWER_LIM))) {
    servo_dir = servo_dir * -1;
    incrementServo();
  }
  else {
    servo_pos = tmp_pos;
    small_servo.write(servo_pos);
  }
}

// check if sensed distance is between specified threshold
// https://acroname.com/articles/linearizing-sharp-ranger-data
bool check_IR(int IR_PIN){
  float vol = analogRead(IR_PIN)*(5.0/1024);
  float dist = 2914/(vol + 5) - 1;
  return (dist < 500);
}

float read_IR(int IR_PIN){
  float vol = analogRead(IR_PIN)*(5.0/1024);
  float dist = 2914/(vol + 5) - 1;
  return dist;
}

void idle_movement(){
// move in figure 8 or circle pattern
  set_motor_pwm(wheel_speed_left, MOT_A1_PIN, MOT_A2_PIN);
  set_motor_pwm(wheel_speed_right, MOT_B1_PIN, MOT_B2_PIN);
}

void wave_hand(){
  unsigned long start_time = millis();
  while ((millis()-start_time) < 1000){
    incrementServo();
    delay(30);
  }
}

void turn_around(){
  unsigned long start_time = millis();
  while ((millis()-start_time) < 1000){
    set_motor_pwm(LEFT_MOTOR_CIRCLE_SPEED, MOT_A1_PIN, MOT_A2_PIN);
    set_motor_pwm(-RIGHT_MOTOR_CIRCLE_SPEED, MOT_B1_PIN, MOT_B2_PIN);
  }
  while ((millis()-start_time) < 1000){
    set_motor_pwm(-LEFT_MOTOR_CIRCLE_SPEED, MOT_A1_PIN, MOT_A2_PIN);
    set_motor_pwm(RIGHT_MOTOR_CIRCLE_SPEED, MOT_B1_PIN, MOT_B2_PIN);
  }
}

void turn_around_fast(){
  unsigned long start_time = millis();
  while ((millis()-start_time) < 1000){
    set_motor_pwm(LEFT_MOTOR_CIRCLE_SPEED*1.5, MOT_A1_PIN, MOT_A2_PIN);
    set_motor_pwm(-RIGHT_MOTOR_CIRCLE_SPEED*1.5, MOT_B1_PIN, MOT_B2_PIN);
  }
  while ((millis()-start_time) < 1000){
  set_motor_pwm(-LEFT_MOTOR_CIRCLE_SPEED*1.5, MOT_A1_PIN, MOT_A2_PIN);
  set_motor_pwm(RIGHT_MOTOR_CIRCLE_SPEED*1.5, MOT_B1_PIN, MOT_B2_PIN);
  }
}

void back_ir_behavior(){
  if (back_ir_counter < back_ir_threshold) {
    turn_around();
  } else {
    turn_around_fast();
    randomSeed(analogRead(RANDOM_SEED));
    back_ir_threshold = int(random(1,6));
    back_ir_counter = 0;
  }
}

void top_ir_behavior(){
  randomSeed(analogRead(RANDOM_SEED));
  int rand_val = int(random(100));
  Serial.println(rand_val % 3);

  if (rand_val % 3 == 0){
    set_motor_pwm(0, MOT_A1_PIN, MOT_A2_PIN);
    set_motor_pwm(0, MOT_B1_PIN, MOT_B2_PIN);
    wave_hand();
  }else if (rand_val % 3 == 1){
    wheel_speed_left = LEFT_MOTOR_CIRCLE_SPEED * 0.8;
    wheel_speed_right = RIGHT_MOTOR_CIRCLE_SPEED * 0.8;
    idle_movement();
    delay(1000);
  }else{
    wheel_speed_left = LEFT_MOTOR_CIRCLE_SPEED * 1.2;
    wheel_speed_right = RIGHT_MOTOR_CIRCLE_SPEED * 1.2;
    idle_movement();
    delay(1000);
  }

  wheel_speed_left = LEFT_MOTOR_CIRCLE_SPEED;
  wheel_speed_right = RIGHT_MOTOR_CIRCLE_SPEED;
}

void setup() {
  // Initialize IR sensors
  // pinMode(IR_TOP_PIN, INPUT);
  // pinMode(IR_BACK_PIN, INPUT);

  // Initialize the motor driver control pins to output drive mode.
  pinMode(MOT_B1_PIN, OUTPUT);
  pinMode(MOT_B2_PIN, OUTPUT);
  pinMode(MOT_A1_PIN, OUTPUT);
  pinMode(MOT_A2_PIN, OUTPUT);

  // Initialize servo pin
  small_servo.attach(SERVO_PIN);

  // Start with drivers off, motors coasting.
  digitalWrite(MOT_B1_PIN, LOW);
  digitalWrite(MOT_B2_PIN, LOW);
  digitalWrite(MOT_A1_PIN, LOW);
  digitalWrite(MOT_A2_PIN, LOW);

  Serial.begin(9600);
}

void loop() {
  static int state_index = 0;

  switch(state_index) {
    case 0:
      Serial.println("State 0");
      idle_movement();
      if (check_IR(IR_BACK_PIN)){
        state_index = 1;
      } else if (check_IR(IR_TOP_PIN)){
        state_index = 2;
      }
      break;
    case 1:
      Serial.println("State 1");
      back_ir_behavior();
      if (check_IR(IR_BACK_PIN)){
        state_index = 1;
      } else if (check_IR(IR_TOP_PIN)){
        state_index = 2;
      } else {
        state_index = 0;
      }
      break;
    case 2:
      Serial.println("State 2");
      top_ir_behavior();
      if (check_IR(IR_BACK_PIN)){
        state_index = 1;
      } else if (check_IR(IR_TOP_PIN)){
        state_index = 2;
      } else {
        state_index = 0;
      }
      break;
  }
  // Serial.println(read_IR(IR_BACK_PIN));
  // Serial.println(check_IR(IR_BACK_PIN));
}

CAD Files

You can find the CAD files here.

Our two robots are akin to soulmates in love: they finish each other’s song-tences (get it, instead of sentences)! Each bot is equipped with a speaker, a SPDT switch, and a servo with an attached arm. When the first bot’s arm moves down, it presses the switch of the second robot, which begins to play one verse of the popular English lullaby, “Twinkle Twinkle Little Star”. After it sings its verse, the second robot then places its arm down, pressing on the switch of the first robot. The first robot then plays the second verse of the song before moving its arm down again to allow its partner to start playing the beginning of the song again.

Video

Solidworks Files

Demo 3 – Solidworks Files

Arduino Code

/*
Jen Kwang and Sora Shin "Demo 3: The Conversation" for 16-223
Lifts servo arm to upright position, then plays a tune, then moves arm 90 deg
down to push the switch on its partner.  Note that switch is wired to power
the whole circuit when pressed and ground otherwise.

Code for twinkle twinkle little star taken from baojie at GitHub:
https://gist.github.com/baojie/4522173
*/


/* Melody
 * (cleft) 2005 D. Cuartielles for K3
 *
 * This example uses a piezo speaker to play melodies.  It sends
 * a square wave of the appropriate frequency to the piezo, generating
 * the corresponding tone.
 *
 * The calculation of the tones is made following the mathematical
 * operation:
 *
 *       timeHigh = period / 2 = 1 / (2 * toneFrequency)
 *
 * where the different tones are described as in the table:
 *
 * note   frequency   period  timeHigh
 * c          261 Hz          3830  1915  
 * d          294 Hz          3400  1700  
 * e          329 Hz          3038  1519  
 * f          349 Hz          2864  1432  
 * g          392 Hz          2550  1275  
 * a          440 Hz          2272  1136  
 * b          493 Hz          2028  1014  
 * C          523 Hz          1912  956
 *
 * http://www.arduino.cc/en/Tutorial/Melody
 */

#include <Servo.h> 
int speakerPin = 5;
const int servoPin = 10;
Servo svo;

int length = 15; // the number of notes

//twinkle twinkle little star
char notes[] = "ccggaag ffeeddc ggffeed ggffeed ccggaag ffeeddc "; // a space represents a rest

//////////////
// !! Depending on which of the partners you have, change the first or second half of the array to all zeroes.
// Sora =  { 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 2 };
// Jen =  { 1, 1, 1, 1, 1, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0 };
//////////////

int beats[] = { 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 2 };
int tempo = 300;

void playTone(int tone, int duratio n) {
  for (long i = 0; i < duration * 1000L; i += tone * 2) {
    digitalWrite(speakerPin, HIGH);
    delayMicroseconds(tone);
    digitalWrite(speakerPin, LOW);
    delayMicroseconds(tone);
  }
}

void playNote(char note, int duration) {
  char names[] = { 'c', 'd', 'e', 'f', 'g', 'a', 'b', 'C' };
  int tones[] = { 1915, 1700, 1519, 1432, 1275, 1136, 1014, 956 };
  
  // play the tone corresponding to the note name
  for (int i = 0; i < 8; i++) {
    if (names[i] == note) {
      playTone(tones[i], duration);
    }
  }
}

void setup() {
  svo.attach(servoPin);
  pinMode(speakerPin, OUTPUT);

  
}

void loop() {

  svo.write(30);
  delay(500);
   
  for (int i = 0; i < length; i++) {
    if (notes[i] == ' ') {
      delay(beats[i] * tempo); // rest
    } else {
      playNote(notes[i], beats[i] * tempo);
    }
    
    // pause between notes
    delay(tempo / 2); 
  }

   svo.write(120);
   delay(5000);

  
}

Rain Room, 2012

Barbican, London; MoMA, NY; Yuz M, Shanghai; LACMA, LA; The Maxine and Stuart Frankel Foundation for Art, MI

Summary

Rain Room (2012) is an installation created by Hannes Koch and Florian Ortkrass, designers and co-founders of Random International, a London-based artist collective, that has visited both LACMA and MoMA. It consists of a large space of continuously falling water that pauses wherever a human body is detected beneath. This immersive installation allows visitors to use their mere presence to seemingly control the falling water, a recreation of rain, which furthers the question of humankind’s interaction with nature through technology.

Random International

Mechanism

This installation consists of “water, injection moulded tiles, solenoid valves, pressure regulators, custom software, 3D tracking cameras, steel beams, [a] water management system,” and a 100 square-meter grated floor (Random International). Visitors can walk around the grated floor and will quickly realize that they remain dry despite the turbulence of the falling water around them. Ten 3D tracking cameras and a “custom drop ceiling in the gallery made up of 1,600 tile-like squares, each packed tightly with 36 tiny sprinkler-nozzles releasing rain” make note of any human body that enter the installation by taking advantage of reflecting light, provided by a spotlight placed in the corner of the room (Vankin). Consequently, the water immediately above any visitor, in an approximately six-foot radius, will pause, leaving them dry as they roam around the wet, grated floor.

Rain Room involves both mechanism and computation. The path and continuous filtering of the water used in the installation requires thoughtful design in the physical setup and handling of the water. 3D cameras and custom software are used to create a reality that is both ordinary and unnatural. But the installation itself does not reveal its secrets. Computers in a back room control the computational facets of the installation and hide well away from the curious eyes of incoming visitors.

Random International

Context

Rain Room “can be seen as an amplified representation of our environment”. As a recreation of one of nature’s most common proclamation of its presence to humans, Rain Room illustrates how our interaction and relationship with nature is “increasingly mediated through technology” as it both exposes and protects visitors from the falling water (Random International). In the context of humanity’s increasing dependence on and evolution alongside technology, this installation provides a narrative for visitors to explore this trifold relationship between people, technology, and nature and questions how it will evolve in the near and far future.

Links

Random International

LA Times

Sources

“Rain Room, 2012.” Random International. Random International, https://www.random-international.com/rain-room-2012/. Accessed 11 September 2018.

Vankin, Deborah. “First look inside LACMA’s Rain Room: an indoor storm where you won’t get wet…honest.” Los Angeles Times, 27 Oct. 2015, http://www.latimes.com/entertainment/arts/la-et-cm-lacma-rain-room-20151028-story.html. Accessed 12 September 2018.

I used stored gravitational potential as the operating principle for my device. The servo turns and pushes an eraser which is attached to the first level by wire. The eraser falls off the edge and pulls the rest of the apparatus down with it, thus producing a pratfall. The device is constructed with laser-cut 6mm plywood parts and put together through a series of simple inserts. The servo motor is attached to the second level of the device with a screw attachment.

Video

Solidworks Files

Pratfall Solidworks Files – mgshin

Arduino Code

#include <Servo.h>

const int PIN = 7;
Servo push;

void setup() {
  push.attach(PIN);
  push.write(0);
}

void loop() {
  push.write(180);
  delay(500);
  push.write(0);
  delay(10000);
}

This simple demo includes a servo motor with a horn that is taped to a wooden chopstick and a cardboard cutout of a hand. Place the device on any surface that will allow you to rest your elbow and wait for a high-five. The high-fives are not consistent, however, and may require a bit of patience.

In the code, I used the random() function to generate a number between 0 and 100 and if that number is divisible by 7, the device will give you a high-five. Otherwise, it won’t.  By introducing some randomness into the demo, it gives the device a more human aspect, as if its high-fives were given on a whim or a decision of its own rather than a consistent and mechanical action often seen in industrial robots. It makes the experience of waiting for a high-five more interesting, exciting, and perhaps even thrilling since you don’t know when exactly the device will decide to give you that high-five. But patience rewards you in the end and eventually, it will grant the high-five that participants seek upon initial interaction with the device. I also tried to make the actual action of the high-five more human by having the ascent of the arm faster than its descent.

My inspiration for this came from my cat. I tried to teach him to give me his paw and after half an hour of patiently waiting and trying, he finally did. I wanted to re-create that same feeling of not knowing whether or not you’ll get a result and patiently waiting until the universe (or in my case, my cat) responds. You can’t possibly control everything in your life, so sometimes it’s okay to just wait and see what the world gives you.

Video

Video & cardboard hand cutout credit: Victor Song

Code

#include <Servo.h>

const int PIN = 7;
Servo hand;

void setup() {
  hand.attach(PIN);
  hand.write(0);
}

void loop() {
  // generate random number
  int num = random(0,100);
  if (num % 7 == 0) {
    // ascending
    for (int i = 0; i < 90; i+=15) {
      hand.write(i);
      delay(50);
    }
    // descending
    for (int i = 90; i > 0; i-=5) {
      hand.write(i);
      delay(40);
    }
    delay(500);
  }
  delay(1000);
}