and I like to make stuff.

Welcome to another tutorial

taken from our Arduino StarterKit.

Today we are going to build

a small musical instrument.

You can see, it’s again

a simple circuit.

We have four buttons

connected to the Arduino

and a small piezo speaker

or “paizo” speaker

depending on where you come from.

So let’s press the buttons

and see what happens.

Each button

is associated with a note.

Every time I press a button,

Arduino produces a sound

through the piezo speaker.

So, how does this work?

Let’s start from the circuit.

You can see here there are four buttons.

But the four buttons are connected to the

Arduino board with just one wire.

In the previous examples,

we’ve seen that

for every button we had a wire

going to the Arduino board

We were using one digital pin

to read each individual button

and here we have four buttons

connected to just one wire,

because we have built

what is called “resistor ladder”

That's a combination

of resistors and buttons.

When I press one of the buttons,

I create a combination

of resistors

that let current flow through them.

But then the voltage

that the Arduino board measures

out of this resistor ladder

changes depending on which

button I press.

So, each combination of buttons

produces a different voltage.

You know that

voltages applied to an analog input

can be read from the Arduino

using analogRead().

Then using a

series of “if” statements,

we can actually say

ok, if the value is

between this number and this number,

it's because I pressed the first button.

If it’s between

another set of numbers,

I pressed the second button.

And I could experimentally figure out

which one of the buttons

I pressed

by looking at

all the numbers that come out

when I press different buttons

that correspond to the combinations

of resistors.

Now

the output of this circuit,

the actuator, is this piezo speaker.

The piezo speaker

is a very simple device made of

piezo electric material

that has this feature

that whenever you power it

with electricity, it will make

a small click.

If you turn on and off

the power to the piezo speaker

at a certain speed,

these sequences of clicks

make a sound.

So, for example,

if I turn on and off

the power 440 times per second,

I produce a sound, which is a very

well defined note.

In our code,

as we will see in a few minutes,

we have defined all the different

frequencies of each note.

And when you press the button,

the Arduino detects

which button has been pressed,

and then plays that particular note

on the speaker.

Now let’s have a look at the code

and let’s read it line by line

to understand exactly

how to implement this behavior.

Let’s start from the beginning.

You can see on this line

that we are defining

a new type of variable,

called an array.

This is a variable

called "notes"

that contains four

different integer values.

Each one of these

integer values represents

the frequency associated

to a certain note.

In particular

these are the middle C, D, E,

and F notes.

This will be useful later

when we detect which

button has been pressed,

we can then

choose the right frequency

to play on the speaker.

Then we have the usual setup()

where we have a Serial.begin()

to begin a communication

with the computer.

Let’s look at the loop now.

The first thing we do,

we create a variable called "sounder"

that contains the value read

from the analogPin(0)

that represents the combination of

keys that have been pressed

on the keyboard.

Then we print that

value on the serial monitor,

so we can

look at it on the computer

and then we start to understand

which button

has been pressed.

So we do this by looking at

the "sounder" variable

using a set of “if”

and “else if” statements to

segment values in different bands,

and figure out in which band

the value falls.

Each one of them corresponds

to a sound.

So, at the beginning,

when the value is 1023,

then we know

that we have to play the middle C.

We are using a new function

called tone()

Tone() is able to produce a sound

on a small speaker or a piezo speaker

connected to a certain

pin on the Arduino.

The only thing we need to do is,

we need to say

this is the pin where

the speaker is connected to,

in our case, 8.

And then we have to

specify the note

and that note will be played

on that pin.

Then

if we continue down

the source code, you can see

there’s a number of “else if”

statements that divide

the value of "sounder" in

different bands.

So

we have a band that goes

between 920 and 1010

that corresponds to the middle D,

a band that goes between 505 and 515

that corresponds to the middle E,

and finally

a band that goes between

5 and 10 that represents

the middle F.

If none of these combinations

is actually detected,

then there’s a final “else”

statement that you can see here.

This “else” statement calls this

function called nonetone() that

stops any sound being

produced on the specific pin.

So we say notone(8)

and this stops

the sound.

Let’s try

again the instrument and see

how our software is actually

working here.

At the same time, I will open

my serial monitor so that

we can see the numbers

while I press the button.

At the moment we see a value,

which is very

close to 0,

which represents the fact

that no button has been pressed.

So, we press the button

and we got 1023.

The second button is 1002.

The third button is

about 512

or something.

And the last one is

sort of between 15 and 20.

This

is in a very simple

way, a small

music instrument that you can build

very quickly with your Arduino,

a piezo speaker,

a few resistors and a few buttons.

This is all for now

but remember: Build it,

hack it, share it,

because Arduino is you.