Guitar Tuner With an Arduino

Pitch is everywhere, but what exactly is it? This website will document the steps to create your very own Arduino guitar tuner.

Pitch, which is often thought of as how high or low a sound is, can be defined as the human perception of frequency. It is clear that humans can not detect frequency with the naked ear, however, our natural idea of pitch can get us most of the way there. Pitches are denoted by the seven letters A,B,C,D,E,F,G and A which is one octave above the initial A with a frequency of 2A. If we look at the keys of a piano we see a repetition of those same musical notes. Each set of eight notes is known as an octave and each note can be flat (lower) or sharp (higher) than the ideal pitch frequency. Lets take a look at rather small frequencies between 50 and 0.

Starting with C the frequencies are, C0 = 16.35, D0 = 18.35, E0 = 20.60, F0 = 21.83, G0 = 24.50 A0 = 27.50, B0 = 30.87 all in HZ. We define a pitch as any multiple of the zero frequency i.e. A*N where N is any real number greater than 0. That means that 55.00 HZ, 110 HZ, 220 Hz, ... are all considered musically A. The same goes for the remaining G through B. Using these repeating domains allows us to convert any input frequency (in Hertz) to it's corresponding pitch.

We were not given this natural ability to perfectly detect pitch or frequency, but with technology and our understanding of signals, this can be done. This demonstration will outline how AC/DC achieved a means to detect the pitch of a guitar string through frequency analysis.

This image indicates the frequency layout for any note the guitar signal might produce. These ranges allow the user to tell if the note being played is sharp or flat, and this is displayed in a later video.

How exactly do we get frequency from a raw input sine wave? We'll get into how the Arduino handles the conversion later, for now, lets build the input circuit. The input is taken directly from the audio jack which intern receives the signal through the audio cable from the inductive pickups located on the guitar. We need to collect the signal and then amplify it, after that the raw voltage value is inputted into the board as an analog input to be processed.

1) Lets begin by building the op-amp circuit. Take the time to gather all the components listed below.

(1x) 10uF Capacitor (amazon)

(1x) 100nF Capacitor (amazon)

(x1) TL082CP Op Amp (amazon)

(x1) 1/4 inch Mono Audio Jack (amazon)

(x1) 220 ohm resistor (radioshack)

(x1) 22k ohm resistor (radioshack)

(x3) 100k ohm resistor (radioshack)

(x1) toggle switch (amazon)

(x2) 9V batteries and snaps to power the amplifier

(x1) 2.1mm DC barrel jack (male, center +)

(x1) lots of wire/jumpers

(x1) bread board/ prototyping board

NOTE: The Op Amp circuit takes the sound waves and increases the amplitude, so that the Arduino can read it easily. The waveform without it would not be in the detectable range of the Arduino of 0 to 5V. It then sends the signal into the Arduino to be sampled, which then samples the frequency of the sound waves, and records it on the serial port so the user can see.

We need some way to out put the processed data from the arduino, for this Guide we will be using the following schematic to output with the 16x2 LCD display. For this you will use the same arduino connected to the op-amp circuit as well as;

(x1) 10 kOhm potentiometer for the LCD back-light

(x1) large value resistor (for power to the LCD) we used 22 kOhm.

more wires...

and that's it. This is pretty simple, just connect the wires in the same way that they are shown in the schematic.

NOTE: We used a 10 kOhm potentiometer as a variable resistor to adjust the gain of the op amp. The gain is the amplitude of the output voltage divided by the amplitude of the input voltage.

This video shows the full circuit put together, walks through the schematic and parts list, and goes over important parts of the code.

//Free for use and modification //Written by: Noah St. Pierre and Ethan Gibson //Credit for frequency detection code to: //https://github.com/akellyirl/Arduino-Guitar-Tuner // include the library code: #include

#define LENGTH 512

byte rawData[LENGTH]; int count; char noteName;

// Sample Frequency in kHz const float sample_freq = 8919;

int len = sizeof(rawData); int i,k; long sum, sum_old; int thresh = 0; float freq_per = 0; byte pd_state = 0;

//Base 0 octave frequencies //float freq = 415; // dont neet this float Ffreq; float Note;

char testput; String out = “b—-[[ ]]—-#”; int octave_counter; float C = 16.35; float D = 18.35; float E = 20.60; float F = 21.83; float G = 24.50; float A = 27.50; float B = 30.87;

// initialize the library with the numbers of the interface pins //Pin 12 = RS //Pin 11 = E //Pin 5 = DB4 //Pin 4 = DB5 //Pin 3 = DB6 //Pin 2 = DB7 LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup() { Serial.begin(115200);

analogReference(EXTERNAL); // Connect to 3.3V analogRead(A0);

//string output = 0; // set up the LCD’s number of columns and rows: lcd.begin(16, 2); lcd.setCursor(0,0); lcd.print(” EE421: Signals”); lcd.setCursor(0,1); lcd.print(” Guitar Tuner”); delay(3000); lcd.clear(); lcd.setCursor(2,0); lcd.print(“[“); lcd.setCursor(13,0); lcd.print(“]”); // Print a message to the LCD.

count = 0; } float freq; void loop() { if (count < LENGTH) { count++; rawData[count] = analogRead(A0)>>2; } else { sum = 0; pd_state = 0; int period = 0; for(i=0; i < len; i++) { // Autocorrelation sum_old = sum; sum = 0; for(k=0; k < len-i; k++) sum += (rawData[k]-128)*(rawData[k+i]-128)/256; // Serial.println(sum);

// Peak Detect State Machine if (pd_state == 2 && (sum-sum_old) <=0) { period = i; pd_state = 3; } if (pd_state == 1 && (sum > thresh) && (sum-sum_old) > 0) pd_state = 2; if (!i) { thresh = sum * 0.5; pd_state = 1; } } // for(i=0; i < len; i++) Serial.println(rawData[i]); // Frequency identified in Hz if (thresh >100) { freq_per = sample_freq/period; //Serial.println(freq_per);

//Filter out frequencies that are too high to matter if(freq_per < 400) { freq = freq_per; } else { freq = -1; }

} count = 0; Serial.println(freq); displayToLCD(freq); delay(400); } }

void displayToLCD(float freq){ if(freq == -1) { return; }

if(freq >= 15.89){ // check if above minimum C; octave_counter = -1; Ffreq=getFfreq(freq);

if((15.89<=Ffreq) & (Ffreq<=17.34)){ Note = C; noteName = ‘C’; } else if((17.35<=Ffreq) & (Ffreq<19.475)){ Note = D; noteName = ‘D’; } else if((19.475<=Ffreq) & (Ffreq<21.215)){ Note = E; noteName = ‘E’; } else if((21.215<=Ffreq) & (Ffreq<23.185)){ Note = F; noteName = ‘F’; } else if((23.185<=Ffreq) & (Ffreq<26.00)){ Note = G; noteName = ‘G’; } else if((26.00<=Ffreq) & (Ffreq<29.185)){ Note = A; noteName = ‘A’; } else if((29.185<=Ffreq) & (Ffreq<31.785)){ Note = B; noteName = ‘B’; }

float closeness0 = (Ffreq/Note); int cl1 = 0; cl1 = int((closeness0-1)*100); // round to nearest whole number if(Ffreq==Note){out = “b—-[[ ]]—-#”;} else if(cl1==-1) out = “b—-[[ ]]—-#”; else if(cl1==1) out = “b—-[[ ]]—-#”; else if(cl1==-2) out = “b—<<< >—–#”; else if(cl1==2) out = “b—–< >>>—#”; else if(cl1==-3) out = “b–<<<< >—–#”; else if(cl1==3) out = “b—–< >>>>–#”; else if(cl1==-4) out = “b-<<<<< >—–#”; else if(cl1==4) out = “b—–< >>>>>-#”; else if(cl1==-5) out = “b<<<<<< >—–#”; else if(cl1==5) out = “b—–< >>>>>>#”; } else{ Ffreq = -1; } // -1 one for too low // count++;

lcd.setCursor(3,0); lcd.print(freq); lcd.setCursor(11,0); lcd.print(“Hz”); lcd.setCursor(0,1); lcd.print(out); lcd.setCursor(7,1); lcd.print(noteName); lcd.setCursor(8,1); lcd.print(octave_counter); }

float getFfreq(float freq){ octave_counter++; if(freq > B){ return getFfreq(freq/2);} else return freq; }

}

This video consists of Ethan running through tuning process with our electric guitar tuner and comparing its results with a commercial guitar tuner.

Below is the close-up visual of the monitor of the pitch detection.

The construction of the LCD circuit was setup and designed from an online tutorial from the following linked web page. This link also includes the circuit schematics for the LCD circuit.

https://www.arduino.cc/en/Tutorial/HelloWorld

The electric guitar signal amplifying circuit was developed with aid of another Instructable. The link contains the corresponding circuit diagrams.

https://www.instructables.com/id/Arduino-Guitar-Tuner/

Additional online resources used for Arduino frequency detection:

http://www.akellyirl.com/arduino-guitar-tuner/

http://www.akellyirl.com/reliable-frequency-detection-using-dsp-techniques/

https://github.com/akellyirl/Arduino-Guitar-Tuner

Thanks for reading our Instructable, we hope you enjoy it!