CONCEPTION AND DESIGN

Building upon the idea of interaction. Through various factors, we considered before forming our final idea of the Musical Glove. There was one question we always start with, “What can we do to guide the users to interact with our project ideally without directly telling them?”. With that question in mind, we decided to use a glove as a carrier for our project because if someone is going to use a glove, they must wear it first. Moving on, the next question we came up with after letting users put on the glove was, “What should users do with it?”. This was where we started using technology. The best and ideal spots on a glove for users to use are on the fingers. This means we need sensors, one for each finger. To achieve immediate and accurate response from the sensors, we decided to use pressure sensors. Wait a second, wouldn’t touch sensors be a better option than pressure sensors? Unfortunately, no. Before using pressure sensors, we tried touch sensors first, and it was great. However, it was too sensitive, it gave immediate responses after sensing any and every interaction, and sensing every interaction was bad for our project. We couldn’t find a way for it to not detect something when putting it on the glove. The only thing we wanted the sensors to detect was users touching surfaces with their fingers. This is why we chose to use pressure sensors because they are less sensitive. After achieving the main goal of our project, we decided to build a physical metronome for it. And a new question pops up, “What should we use to create consistent physical sound?”. From what we learned from the class, there weren’t any sensors that could directly create the consistent physical sound we wanted. Then, our instructor, Andy, suggested we use solenoid. A solenoid is an electromagnetic device that converts electrical energy into mechanical motion. And it’s mechanical motion was consistent and physical, so we decided to use it. To make it interactive, we chose to use an ultrasonic sensor to trigger it, so that the speed of the solenoid would be adjustable with the ultrasonic sensor, making the solenoid create fast mechanical motion when the sensor senses something really close, and creating slow mechanical motion when something is further away. Then we can have an adjustable metronome for the glove.

FABRICATION AND PRODUCTION

Some of the significant failures we encountered before and after the user testing session were, having a hard time with the connection of the wires from Arduino to the pressure sensors which was before user testing, and figuring out how to use a solenoid which was after user testing. 

Before the user testing session, for a better user experience and aesthetics of the project, we decided to extend the wires that connect to the sensors from the Arduino and breadboard. We asked Kelvin, one of the IXL fellows, for suggestions, and he told us that we could either desolder the pressure sensor and solder long wires in between the plastic part and the board of the pressure sensor or just directly solder wires to extend the connection. The first method would make the project cleaner and less wire will be used, but it requires good soldering skills. The second method requires fewer soldering skills but will require more wires for connection and will make everything look messy. Unfortunately, neither of us had enough skill to desolder the pressure sensor, and we accidentally broke a pressure sensor while trying the first soldering method. Then we decided to use the second method, which was more workload but worked. 

We concluded the suggestions we got after the user testing session, we needed more elements to extend the process of interactivity. We saw that after playing around with the glove for a while, users lost their interest. This is why we decided to come up with a metronome, this would allow users to combine it with the glove and further interest them. However, this starting process was full of obstacles. Because we decided to use a solenoid that we had never seen before, we needed to look for references and examples of connection. Even with that, we still accidentally created a short circuit and broke one of our Arduino boards. 

As I mentioned earlier, some of the successes were successfully using pressure sensors to activate sounds and successfully using an ultrasonic sensor to activate and adjust the motion speed of the solenoid. I would say I personally contributed a lot to both successes because I wrote the codes for both. For pressure sensors, the main point of the code that I wrote that contributed a lot to the progress of the whole project was using if() and else if() statements to differ the pitch for each finger and using noTone() statement for all the fingers when there the pressure sensors are not triggered. For controlling the solenoid with an ultrasonic sensor, the main point of the code that I wrote was using the variable “delayTime” to control the timing of the solenoid’s activation and deactivation. To calculate that I used the variable “distance” that came from a website I used for guidance for the ultrasonic sensor, putting distance in the map() statement to set a range for the ultrasonic sensor to detect, which also came from the same website. To make it even more accurate, I used the constrain() statement to make the ultrasonic sensor stop detecting after the maximum range I set. By setting all that up, I made this distance-dependent delay to give a dynamic and responsive effect to the solenoid, making it pulse faster as an object approaches and slower as an object moves away.

Below are the pictures of the step-by-step process we took:

Starting with Touch Sensors

Switching to pressure sensors and having the glove ready

Using an ultrasonic sensor and a solenoid to make an adjustable metronome

Code for the Musical Glove

int thumb;

int prethumb;

int index;

int preindex;

int middle;

int premiddle;

int ring;

int prering;

int pinky;

int prepinky;

// Define the notes for each finger

int noteE = 330;  // E4

int noteFSharp = 370; // F#4

int noteA = 440;  // A4

int noteGSharp = 415; // G#4

void setup() {

  Serial.begin(9600);

  pinMode(2, INPUT); // Thumb pin

  pinMode(3, INPUT); // Index pin

  pinMode(4, INPUT); // Middle pin

  pinMode(6, INPUT); // Ring pin

  pinMode(5, INPUT); // Pinky pin

}

void loop() {

  thumb = digitalRead(2);

  index = digitalRead(3);

  middle = digitalRead(4);

  ring = digitalRead(6);

  pinky = digitalRead(5);

  // Play individual notes for each finger

  if (prethumb == LOW && thumb == HIGH) {

    Serial.println("Thumb Pressed");

    tone(8, noteE, 300); // E4

    delay(350);

  } else if (preindex == LOW && index == HIGH) {

    Serial.println("Index Pressed");

    tone(8, noteFSharp, 300); // F#4

    delay(350);

  } else if (premiddle == LOW && middle == HIGH) {

    Serial.println("Middle Pressed");

    tone(8, noteGSharp, 300);

    delay(350);

  } else if (prering == LOW && ring == HIGH) {

    Serial.println("Ring Pressed");

    tone(8, noteA, 300); // A4

    delay(350);

  } else if (prepinky == LOW && pinky == HIGH) {

    Serial.println("Pinky Pressed - Playing Full Melody");

    // Play the full sequence: E E F# E A G#

    tone(8, noteE, 300); // E4

    delay(350);

    tone(8, noteE, 300); // E4

    delay(350);

    tone(8, noteFSharp, 300); // F#4

    delay(350);

    tone(8, noteE, 300); // E4

    delay(350);

    tone(8, noteA, 300); // A4

    delay(350);

    tone(8, noteGSharp, 300); // G#4

    delay(350);

  }

  // Stop the tone if no buttons are pressed

  if (thumb == LOW && index == LOW && middle == LOW && ring == LOW && pinky == LOW) {

    noTone(8);

  }

  // Update previous button states

  prethumb = thumb;

  preindex = index;

  premiddle = middle;

  prering = ring;

  prepinky = pinky;

  delay(10);

}

Code for the Adjustable Metronome

// Define pins for the ultrasonic sensor

int trigPin = 9;

int echoPin = 10;

// Variables for the distance measurement

long duration;

int distance;

// Define pin for the solenoid (digital control)

int solenoidPin = 8;

void setup() {

  Serial.begin(9600);

  pinMode(trigPin, OUTPUT);// Set the trigPin as an OUTPUT

  pinMode(echoPin, INPUT);// Set the echoPin as an INPUT

  pinMode(solenoidPin, OUTPUT);// Set the solenoidPin as an OUTPUT

}

void loop() {

  // Clear the trigPin

  digitalWrite(trigPin, LOW);

  delayMicroseconds(2);

  // Set the trigPin HIGH for 10 microseconds

  digitalWrite(trigPin, HIGH);

  delayMicroseconds(10);

  digitalWrite(trigPin, LOW);

  // Read the echoPin and calculate the distance

  duration = pulseIn(echoPin, HIGH);

  distance = duration * 0.034 / 2;  // Convert to centimeters

  // Check if the distance is below 40 cm

  if (distance < 40) {

    int delayTime = map(distance, 3, 40, 50, 300);

    delayTime = constrain(delayTime, 50, 300);

    // Activate the solenoid

    digitalWrite(solenoidPin, HIGH);

    // Delay based on the mapped value

    delay(delayTime);

    // Deactivate the solenoid

    digitalWrite(solenoidPin, LOW);

    // Delay again for the same amount of time

    delay(delayTime);

  } else {

    // If the distance is 40 or above, keep the solenoid off

    digitalWrite(solenoidPin, LOW);

  }

}

Disassembly

Works Cited

An Ultrasonic Sensor that calculates speed.

This was adapted from a tutorial found here: https://howtomechatronics.com/tutorials/arduino/ultrasonic-sensor-hc-sr04/

Anon, et al. “Ultrasonic Sensor HC-SR04 and Arduino - Complete Guide.” How To Mechatronics, 18 Feb. 2022, howtomechatronics.com/tutorials/arduino/ultrasonic-sensor-hc-sr04/. 

The idea of using a solenoid was adapted from here: https://www.instagram.com/p/Cw23QsBNS0A/?hl=en

Marcus, Nathan. “Nathan Marcus on Instagram: ‘for the Minimal Music Festival 2021 @minimalmusicfestival in the @muziekgebouw I Worked on a Mechanical Sound Installation for the “Ontscheppen” Performance by @this.Is.Janne . I Was in Charge of Developing a System / Instrument That Could Remotely Control ~60 Solenoids That Were Spread throughout the @muziekgebouw Building. These Solenoids Were Attached to the Different Surfaces and Materials in the Building; Concrete, Wood, Glass, Iron and Metal. by Triggering the Solenoids They Excited the Natural Sounds of the Building’s Materials Creating a Soundscape Made up of the True Sound of the Muziekgebouw. Effectively Turning the Muziekgebouw into a Giant Instrument. Some of the Solenoids Were Attached to an Offline System That Generated Algorithmic Compositions and Others Were Hooked up to a System to Control Them in Real-Time Using OSC Communication. to Achieve Real-Time Control I Used Two Teensy 3.2’s and Hooked Them up to an Ethernet Shield to Allow for Live Communication with Max/MSP, Ableton and Supercollider over Long Distances the Laser-Cutting, Soldering Was Done with the Kind Help of @indigo___kona and @shoal__ . . . #technology #installation #soundart #solenoids #spatialsound #artinstallation #muziekgebouw #teensy #music #musictechnology #interactiveart.’” Instagram, www.instagram.com/p/Cw23QsBNS0A/?hl=en. Accessed 18 Oct. 2024.