By Alara, Ideen, Martin, and Frank

Group 7

Phase One: Ideation and Planning

Brief:

We were asked to design a violin based on similar principles using components such as linear potentiometers and possibly amplifiers but also to take it a step further to interact with the user and provide feedback on the quality of the performance through simple interfaces.

Aim and purpose:

With this project our aim is to create a beginner-friendly, and fun violin that encourages learning and allows the user to have fun while playing. We aim to do this with the use of LEDs as a form of feedback, as well as a simplified method of playing. Our violin design will also be modern and sleek to appeal to the newer generation, as well as the parents who will be purchasing the violin for their children.

Target user:

Our target user will mainly be children from the age of 6 to 10 years old, using a half size violin. Younger or older children who have the correct measurements for a half size violin may also use our product as it is normal that the appropriate size fluctuates from person to person.

Market research:

Design:

Having researched the various popular designs of violins, it was found that most commercially available violins had a classical wooden design. Perhaps this is due to the low cost of the materials used and the already perfected manufacturing technique. More aesthetically adventurous violins had a modern style with geometric patterns or cuts. Our group decided that we would create a modern and sleek looking product for children as these are not very commonly used by children to learn with, yet using an aesthetically pleasing musical instrument may encourage the learning process.

Age and Size:

As the target market for our product will be children who are learning the violin, the most suitable size would be a half-sized violin due to the length of the user’s arms. The age range for a half-sized violin is generally 6-10 years old, however our product could also be appropriate for ages outside of the range depending on the arm length of the user.

 

Project Task List:

Brainstorming – All (Week 8)

Concept Ideation – All (Week 8)

Low-fi prototyping – Alara, Frank and Ideen(Week 9)

Ordering and collecting components – Alara (Week 9)

Documentation (Week 9 to week 12)

• Introduction and body – Ideen
• Maker Manual – Alara
• Programmer’s manual – Martin
• Gantt Chart – Frank

Making the physical violin – Alara and Ideen (Week 10)

Building the physical circuit – Martin and Frank (Week 10)

Programming the Arduino – Martin and Frank (Week 10)

Finalising and testing – All (Week 11)

 

Gantt Chart

 

 

Phase Two – Construction of the product

Low-fi prototype

A low-fi prototype was created using cardboard and a hot glue gun to get an idea of what design we would like the final product to have. We incorporated geometric shapes into the main body, however it was decided that the prism effect that was created for the depth of the violin would be too difficult to replicate with the final materials – acrylic or wood.

We made the initial skeleton of the prototype from pieces of card

We then attached the top surface. Here it is beginning to resemble a violin.

A bow was also made out of card to mimic a real violin bow. We tested the size and shape of the violin before continuing with the prototype.

Here we included elements relating to the strings and the linear potentiometers, to be able to determine the placements before actually constructing the violin.

High-fi prototype/ final product

For this it was decided that transparent acrylic would be used somewhere to account for the light from the LEDs that needs to shine through. Multiple layers of transparent acrylic would be used to for the main body, while being hollowed out to give space to the Arduino board. This would then be layered with a black layer of acrylic on the top and bottom to give a clean, finished look.

To create the pieces, we used a template to draw out the shapes on the acrylic and then used the band saw to cut them out. These pieces were then layered and glued together.

 

Using the Arduino Uno and two breadboards to accommodate all of the used elements, we put everything together to test the product as a whole.

 

Design Breakdown

Design Principles used:

1. ‘Visibility’ suggests that the more visible an element is the more likely the user will know to use it. We incorporated this design principle into our violin by making sure that every interactive element was on the surface of the violin itself. By doing this, the user would know where they would need to place their fingers and the bow in order to operate the violin. Furthermore, creating a violin with a familiar (yet modernised) design helps with usability as most people already know how to use a violin by having seen it being played by others.
2. ‘Feedback’ is needed to make it clear to the user what action has been taken. We implemented this principle with the use of LEDs around the edge of the violin that glow different colours depending on the string that is being played. Not only does this give the user feedback on the fact that a note is being played, but it also helps younger learners who require visual aids to remember information. Having a different colour for each string that is played improves on this, however a potential future step would be to change the brightness or saturation of the LEDs depending on the frequency that is played using the linear potentiometer. This would add a wider range of colours that would relate to each individual note making it easier to visualise the sound being made.
3. ‘Constraints’ are used to ensure the user is using the product correctly. This is specifically important for our target user as children require simplicity in products they use. One constraint that we included was only using a small length of string for each of the four strings so that only that small area would be used. This would prevent the user from becoming confused as to where to place the bow. Having a simplified area such as this would also allow the user to be able to focus on other parts of the violin and learn more easily.
4. ‘Mapping’ is the clear relationship between control and effect. Due to the highly simplistic design of our violin there are only two main interactions and they are physically similar to a classical violin. Having the idea of a classical violin in mind before using our product, the user expects that pressing the neck with a finger and pressing the bow on a string would create a sound. This same action also creates a sound in Violed, creating a clear relation between the interactive elements and what they do.
5. ‘Affordances’ are used to give the user a clue about how to use the product. For this, we used physical and individual strings to make sure it is known that they can be pressed with the bow. Furthermore, the long rectangular shape of the potentiometer on the neck of the violin gives the suggestion that the whole length can be played and that at different points different sounds will be made, while still making the transitions between these sounds continuous.

Why each component was used:

Piezo element

This was used to create the sound of each note that is played. Initially, the standard smaller buzzers were used but these did not create a loud enough noise that would be suitable for the user. A larger speaker was used for the final product.

SoftPot Linear Potentiometer

This was used to mimic the playing of a classical violin where the player’s hand can move up and down the neck to create different sounds.

LEDs

These were used to provide feedback for the user in a subtle yet interesting way.

Programmer’s Manual

The code works as follows: there are four strings that go into separate INPUT set Pins on the Arduino Board. The bow is connected to Ground, and when it comes into contact with any of the strings it will close the circuit. From this signal we can know which string is being played, and map the potentiometer with each string’s respective real life frequency values for a violin. From that same signal we are displaying different coloured LED lights inside.

——————————————————————————

Arduino Commented Code:

//initializing variables

int potpin = A0;

int buzzer = 2;

int string1 = 3;

int string2 = 4;

int string3 = 5;

int string4 = 6;

int a;

int val1;

int ledPinR = 9;

int ledPinG = 10;

int ledPinB = 11;

void setup() {

Serial.begin(9600);

//defining pin modes: 4 strings and fingerboard

pinMode(potpin, INPUT);

pinMode(string1, INPUT);

pinMode(string2, INPUT);

pinMode(string3, INPUT);

pinMode(string4, INPUT);

//defining pin modes: speaker and lights (RBG LEDs pins)

pinMode(buzzer, OUTPUT);

pinMode(ledPinR, OUTPUT);

pinMode(ledPinG, OUTPUT);

pinMode(ledPinB, OUTPUT);

}

void loop() {

int potval = analogRead(potpin); //reads in value of fingerboard and puts it into the potval variable

//reads whether the string is being touched (circuit closed)

int string1state = digitalRead(string1);

int string2state = digitalRead(string2);

int string3state = digitalRead(string3);

int string4state = digitalRead(string4);

int UF; //upper frequency

int LF; //lower frequency

UF = setfrequency(string1state, string2state, string3state, string4state); //function to determine what the upper frequency is

LF = UF/2; //one octave per string: determined by halving the specific upper frequency to produce a potentiometer scale of one octave

//function to play the note depending on which string is being played (and subsequently the upper and lower frequencies of that string), and the position of the finger on the fingerboard

playNotes(string1state, string2state, string3state, string4state, potval, UF, LF);

//turns lights on depending on which string is beingt played

lightsOn(string1state, string2state, string3state, string4state);

}//end of loop

void lightsOn(int a, int b, int c, int d){

if (a != 1){ //first string colour white

digitalWrite (ledPinR, HIGH);

digitalWrite (ledPinG, HIGH);

digitalWrite (ledPinB, HIGH);

}

else if (b != 1){//second string colour blue

digitalWrite (ledPinR, LOW);

digitalWrite (ledPinG, LOW);

digitalWrite (ledPinB, HIGH);

}

else if (c != 1){ //third string colour green

digitalWrite (ledPinR, LOW);

digitalWrite (ledPinG, HIGH);

digitalWrite (ledPinB, LOW);

}

else if (d != 1){ //fourth string colour red

digitalWrite (ledPinR, HIGH);

digitalWrite (ledPinG, LOW);

digitalWrite (ledPinB, LOW);

}

else { //if no string is being played turn the LEDs off

digitalWrite (ledPinR, LOW);

digitalWrite (ledPinG, LOW);

digitalWrite (ledPinB, LOW);

}

}//end of lightsOn

void playNotes(int a, int b, int c, int d, int p, int uf, int lf){

if ((a != 1) || (b != 1) || (c != 1) || (d != 1)){

//maps the predetermined frequency range to the potentiometer. it does this if any string is played, but since the frequency range is defined beforehand it changes for each string

int val1 = map(p, 0, 1023, lf, uf);

tone(buzzer, val1); //plays note (val1)

}

else{

noTone(buzzer); //if no string being played dont play notes

}

}//end of playNotes

int setfrequency(int a,int b,int c,int d){

int upper;

if (a != 1){

upper = 659; //set frequency to open E note

}

else if (b != 1){

upper = 440;//set frequency to open A note

}

else if (c != 1){

upper = 294;//set frequency to open D note

}

else if (d != 1){

upper = 196;//set frequency to open G note

}

return upper; //return chosen frequency depending on string being played

}//end of setfrequency

——————————————————————————

Maker Manual

Tools:

1. Template for the case

2. Layers of acrylic (2 for the top and bottom in your preferred colour and 6 transparent pieces for the middle layers)

3. Band saw

4. Acrylic glue

5. Metal wires without coating

6. A long wire with coating

7. A metal rod

8. 6 RGB LED lights

9. Breadboard and Arduino UNO

10. Resistors

11. Speaker

12. Wires

Build section:

User Manual:

Video: https://www.youtube.com/watch?v=Q6B-mW0tyoc&feature=youtu.be

Overview:

Overall, our final product met our design brief and also our design principles that we set out to achieve. In terms of the aesthetics, the outcome was a clean, modern, and geometric style which would appeal to our target user and their parents who would be purchasing the violin. The product was sturdy and comfortable to play with, as well as simple to use and understand. Not only does this meet the needs of our target user but also fulfils the requirements for any children’s product. In terms of the functionality, apart from some compromises that were made due to the components that we used, we managed to reach our goal in what we wanted our violin to do. The group worked well as a team and tasks were properly delegated, with no member doing too much or too little.

Testing conducted:

Throughout the process, many aspects of the project were tested. Constructing and prototyping the violin required testing to determine the strength of the structure as well as the aesthetics. However the aspect that required the most testing was the wiring. Prototyping of the code led to multiple iterations where one segment would function, but another would fail. An example of where tasing made an impact was with the piezo elements. Initially, we were going to use four small buzzers where each would make the note of a string, however the quality of the sound from the buzzers was poor and resulting in an annoying tone that would not be pleasant for the user.

Video: https://www.youtube.com/watch?v=BNr4Fd5PBc0&feature=youtu.be

Known shortcomings:

One of the more significant shortcomings for the final prototype was the fact that the notes were not mapped accurately onto the potentiometer. The code written for this purpose would have satisfied the idea well enough, but the potentiometer we had was a lot longer than we needed it to be, so we had to bend it into place. This created several pressure points along the strip that altered where the zero note actually was. This meant that the open string notes were not congruent with the notes that came from the fingering. This could have been fixed through thorough testing and the appropriate tuning equipment to calibrate all of the notes. Along those lines, if we were to build the product for commercial use we would also have had to consider the non-linear progression of the notes on the potentiometer, and we might have had to introduce some mathematical formulas to get the right frequencies for every note.

We also had some shortcoming with the LED strip which we had initially planned on using. Although we are not sure exactly what the issue was, when the strip was connected we experienced interference and loss of clarity in the sound. We fixed this by changing the LED strip to several RGB LEDs connected in parallel. We think the library we used for the LED strip might have been the issue, but we did not pursue the idea further as we knew it would also work with the RGB LEDs , albeit not as elegantly.

Something else we wanted to do was have an independent buzzer for each string, so that they might be played together in some cases, but as it turned out there could only be one tone at a time on the Arduino IDE, and so we abandoned the idea. It worked fine otherwise, but obviously we couldn’t incorporate that piece of our realistic violin model. This in turn caused the higher frequency string to override the lower frequency string when both strings were being touched, but it can be accepted as a non-detrimental factor, since it still allows for each string to be played individually.

A shortcoming with the violin casing was its final finish. A further alteration to the process would be to laser cut every acrylic layer of the violin to allow for a smoother and more elegant look, however due to the lack of accessibility to this equipment, the entire manufacturing process was done by hand. Although we believe the finished product to still be aesthetically pleasing, laser cutting would have definitely elevated this.