Archive for the 'Final Report' Category
Go Bananas – Final Report: Guitar Pedal


In the age of digital music a recent need to digitally alter music on the fly is not a necessity. It would be nearly impossible to make many of the sounds we hear all day long that make music enjoyable as we hear it today. Thus we have mane a cheap and effective sound altering patch that can be played real time that would generally cost  thousands with the adaptability.


The hardest part of the patch is the interface, where the computer side patch is the easiest and most flexible. The system requires a Mono>stereo connecter to PC audio board. One Arduino (maybe more/larger for additional buttons). We used 6 (selector stye) Switches that runs dry contact controls (on/off) . To build the patch it is helpful to emulate the physical controls with computer triggers and then later attach the human interface. To do this we ran “Bang” to “triggers” to “spigots”. The bang emulates what the ardwino will send, the trigger is used to flip the bit from 1>0 and back. The Spigot is similar to a Single pole changeover switch (always on but down different paths. Think of train track switches) Individual guitar effects can be found at guitarextended. By using spigot we can then pass audio through the distortion or not. It is important to note that for cleanliness it is nice to place the effects in sub patches to hide the mess. To wire every thing up insert the adc~ (instrument in) to the first spigot. If you built sub patches it is good to know that the what input goes where (generally in order) We for simplicity we placed the second input right to the output and the first though the distortion. The first half of the spigot connects to the first input (distorton) and the second though the bypass. You can do this for as many effects as you want. and then finally attache the output of the last effect to the dac~ (digital out/speakers) 

YouTube Preview Image


In the end the repeatability/ease to remake of the project after a few computer crashes was easy to make. The system was tested on both Windows and Mac with very little configuration other than COM ports. A few other considerations I would suggest making later on is the have a maybe a .25 second mixed fade between distortion and non. This would help with the issue we had when clicking from the distorted and non. Another consideration that I will implement later on is leveling of some patches. We noticed that depending on the inner working of the patch that is levels would be higher or lower of the non distorted. In the future Geoffrey plans on implementing a variable resister that can be used as a foot petal to alter various effects. Since the project is done and I have learned a bit more I would have liked to use a method that would allow the effects petal to control what order the effects are in. This is epically useful when compounding effects to get a better sound.

Violin Hero – Final Report: Dubstep Violin



Our project is the dub step violin. Our project uses a variety of effects originally designed for guitar via GuitarExtended (taken from to alter the characteristics of a violin playing. Below is an explanation of the patch, all the patches that were used were uploaded and a video has also been uploaded to visually show what our project does and how it works.


The patch is not specific to any input form. Any instrument or mic source is capable of utilizing it. However, with open mic forms there is a high risk of feedback, and instruments that can use pickups such as guitars and violins are preferable. Also, while the patch is designed to make use of an arduino, it could easily be set to use keys and allow the computer to function as a soundboard.

The basic effects are borrowed from GuitarExtended, and used in combination with the template for a basicpolysynth. The effect is loaded by an internal patch within the same directory. Within the effect, adc~ and dac~ are changed into inlet~ and outlet~ respectively. This is then put into a subpatch within the polysynth. And adc~ is attached to the effect, and the effect attached to a *~ object. An inlet, toggle, $1 10 message, and line object are connected to the *~. This allows the effect to be turned off over a short time rather than suddenly. The *~ object then attaches to a dac~. In the polysynth patch, the left side bang is attached to the inlet of the subpatch to turn the toggle on and off. By using only one side, multiple effects can be ran at once. If the desire is for the effect to automatically turn off when the connection is broken, the corresponding right side bang should be connected as well. The arduino itself is set to sense the creation and breakage of a connection.

To use the attached files, they should all be placed in the same directory, or folder. The toucheffect pd file open the arduino control and the effects. With the arduino plugged in,  clicking the devices message should display the port number it is plugged into. This number should then be placed into the comport object, such that it will read comport ## 115200.

To use other effects that are available on guitarextended, or other sources, the file needs to be placed in the same directory. Open the file, and find the adc~, and change it to inlet~, and the dac~ to outlet~. Open the effect to be removed in the toucheffect, such as pd bold. In the subpath, there will be an object with the same file name as the effect. Change it to the new effect’s file name, save. The new effect should now be select able via the arduino. 




 YouTube Preview Image


The sound effect works pretty well, however we would like to have a more efficient way to switch in between the sound effects and not just a on or off swift instead a nob that can fade the effects so we can create more sounds. If the project were to expand in the future we would like to take away the instrument part so it would be easier to play in different places and easier to set up. We would also create a better han held controller to activate all the effects instead of wires coming out of an auduino. But overall, it was great experience and worked just like we wanted it to.




Although this is an online submission, please use language and formatting appropriate for a final report (capitalization, well-constructed sentence structure, paragraphs, etc.). Also please delete text such as this which is clearly to help you and not intended as part of the report. You may change the form of this template as you wish, but please include the main elements outlined.

[Trash m8ks noise] Final Report: [Trash band]

Team Members:

Kevin, Waziri, Narjas


Our project is about triggering video songs from the youtube and adding a response to them .We used  three different trash to to tap on them and play the songs and 3 different trash to play the responce.

YouTube Preview Image


Building this project is not very hard. All you really need is a Pd program, music, video, and lots of trash that will connect onto an arduino. The only challenge will be putting a Pd program together which we will provide instruction and pictures to help explain. 
Well start with the video and music. You will need to create 2 sub Pd programs (one for audio and one for video). As shown on the Video image and Audio image, you will need to create a Pd program which will upload and play the video that your wanted to play (for the Video program). It is also the same for the Audio program as well. TheAudio program is doing is uploading the sounds that you want and playing it. Now remember that all your videos and sounds needs to be under the same file so that Pd will be able to locate them onto your computer and play them for you. Also dont forget (which is shown on the init image and controls image) that you will need a init program which does is creating your gem (or window) so that you can play your videos while the controls program which helps you with control. 
Now the main Pd program is our PATCH2. PATCH2 combines all of our audio, video, window, control, etc together. As show on the PATCH2 image, we have set up a scratcher which helps play the video and audio. We also have a master volume which is used to control the volume output. And our main program is the arduino which is connected to the sample sounds. Once the Pd program is running, the triggers will bang (trigger) the sounds that the trigger is assigned to. Now speaking of trash, make sure to use an organic (banana, apples, bread, and etc) or metal (tin can without wrapper) to be used as triggers. If you use anything else like plastic, it will not work due to that plastic has a high resistance. 


Everything in the project worked well as we planned for the idea was easy and with the help from our teacher we reached to the point we wanted. we were happy when we had the chance to play our project in front of the class and see other people reflection, I don’t see anything wrong happened while we were working on the project.In the future  to make it more exciting we  will use more than four Arduino and download  songs depending on how many arduino we have and for each song add to it a different response ,so instead of one response for all the song each song will have a response. 


Although this is an online submission, please use language and formatting appropriate for a final report (capitalization, well-constructed sentence structure, paragraphs, etc.). Also please delete text such as this which is clearly to help you and not intended as part of the report. You may change the form of this template as you wish, but please include the main elements outlined.

BANG! – Final Report: Mellophone Looper

Team Members:

Mitchell Crow

Noal Anderson

Austin Crane


YouTube Preview Image

This patch uses the arduino analog inputs in conjunction with three switches that are conveniently located at the bottom of a scrap mellophone. Why a mellophone? We thought is might be fun to make noises from an instrument that don’t normally come from that instrument. This could be changed though to use nearly any organic material and an operator as a momentary “switch”. The switches make different sounds dependent on the user selected bank. These sounds can be recorded into a track and reproduced in a looped playback. This allows to to essentially be a one man band. Eventually, you’re loop will be so full of sounds you will want to clear it and start over again. Simple keyboard commands allow for the recording, playback, and clearing of your looped track.


One side of each momentary switch is connected to the ground of the arduino. The other side of each switch is connected to the analog inputs 1, 2, and 3 respectively on the arduino. The arduino is connected to a computer running the Pd patch via a USB cable. The arduino should be running the Touch2.ino file attached in this document. Now that the hardware of the project has been set up, let’s move onto the Pd patch itself.

The arduino may be connecting on a different COM port for you’re computer than it did ours. To ensure you’re on the correct port in Pd, click the “devices” message box and a list of all available COM devices will be populated in the Pd control console. You may need to edit the “comport” object and adjust it to the correct comport your arduino is using. Pd is simply reading information from the comport that is being output from the arduino. These messages send integer values for when switches are shorted and open. The “select” objects receive these messages and output a bang in the associated outlet of the object. These “bangs” feed into sub-patches titled “pd note”.

After entering a subpatch, the sounds for each bank can be found in this sub-patch. The received “bang” is routed through another “select” object to play the sound with the selected bank. The sub-patch is also sent a “bang” when a switch has been released. This is sent to a message “0″ which is multiplied by the output and therefore stops any noise that was previously being played. The sounds for each bank and trigger can be changed by entering the appropriate sub-patch for the trigger and selecting the appropriate array for the bank. Clicking the “bang” to the “openpanel” object for the desired array will bring up a window to select an appropriate sound file. You should choose a .wav sound file because they make life easier in Pd. If the sound you want to use is in another format, download audacity or another sound editor to convert it to .wav. The outputting number boxes associated with the array tell the number of samples in the array and the time in milliseconds to play the samples assuming the sound is at 44100 bit rate, the common bit rate for audio recordings. After changing a sound, the message being fed to “line~” should be adjusted to contain [0, "number of samples in array" "time in milliseconds"].

Now that we have the sounds we want, we can select the bank though the horizontal selector in the main patch. To begin recording, press the “R” keyboard button and a bang will be sent to record for 2 seconds as well as play a metronome beat every 1/2 second. If you’re musical, you can think of this as four-four time and the each measure plays back what was played in the previous. The recording will continue until you press the “R” keyboard button again. The patch will continue to play anything that was played previously. If you want to just listen to a loop that has been recorded, press the “P” button on the keyboard. To stop playback, press the “P” button again. To clear the array, press the space bar.

Below are the arduino sketch used as well as a zip file containing the Pd patch and the .wav files used.




The project was fun to put together and is entertaining for hours. We initially used a mellophone  because we thought it may be creative to have odd noises being produced by it, but after completing the project, it makes more sense to use the switches similar to an electric drum set. More banks can easily be added with more sounds which will help add variety to the loops being created. Similarly, more “triggers” can be used with the ardiuno. Using the Touch2.ino, up to 6 triggers can be used with an arduino. Another change that could be made in future revisions is to have multiple loops that can be turned on or off at any time. This would allow for different sections of a song (verse, chorus, bridge, etc…) to play different loops. It would also be helpful to expand the looped array to record and playback in 4 bar phrases rather than single measure loops. The future of this loop patch should become more user friendly for musicians that can allow for easily specifying a tempo and recording each song section loop to perform. This is a simple and entertaining project for all ages and great for beginners in Pd.

Guitar Hero Hack by team: Don’t Worry Be Harpy


 Team members:

Chiran J.    ( binary to decimal converter in PD )

Ankit G.    ( Guitar Design using CATIA, PD sketch and weekly and final report)

Rich S.     ( Hot glue, Wring, PD sketch, weekly and final report)

John H.    ( PD Extended expert, The God of PD )



    In the spring 2014 semester, service learning course led by John Harrison required Wichita State University students to collaborate with Maize High school students. The ultimate objective was to work with Maize students on projects that involve many different software’s including PD, which was the main programming software to be used. For our service learning project, we built a 12 button guitar Hero clone with Kenny, a talented maize high school student. We settled on a guitar hero clone for several reasons. The first one was to built something with the materials that would be cheap, quick and easy for anyone else to do it again, and more importantly because we knew we would have so much fun in doing this project.  We built the guitar equipped two Arduino clones and two MaKey-MaKey  clones, and a guitar design cut from XPS foam board ( Extruded Polystyrene ). Each Arduino was paired with a MaKey clone to receive input from 6 of the 12 buttons on the guitar neck. Both pairs were hot glued to the back of the guitar in a hallowed out cavity in the guitar body. The ground wires were connected together and connected to the aluminum contact pad SOUND HOLE. The rest of the connections (A0 – A5 ) on the MayKey clone were connected to the lower 6 or Upper 6 contact pads glued to the guitar neck. To make the connection a little more tidy we connected both Arduinos to a portable non-powered USB Hub.

    On the software end, we used PD extended to interface with the Arduino clones through 2 com ports (USB PORTS). We used a main patch and two sub patches.  In the main PD script ( MAIN PATCH:  guitarhero ) we used two blocks that read data in from each Arduino port (button presses). The first sub patch (SUB-PACH ” pitchshifter“) wich takes the audio sample held in the ” soundBuffer ” and changes the pitch of the play back. The second (  SUB PACH ” note” ) utilizes the pitch shifter to make one wave file sound like 12 different notes. this is explained in better detail in the video (below).



      After discussions among the group and drawing various rough sketches on paper, we came up with an initial design of a guitar. The team knew that the guitar was going to be made out of foam, using the CNC machine on the 3rd floor Wallace hall which requires sketches in pdf or some other specific formats. For this very reason, guitar design was created using CATIA by Ankit Gupta. The draft of CATIA was then modified with the help of INK-SCAPE to fit the format HPGL, which the CNC foam machine requires was made.


      The body neck and head of the guitar were traced from a cool looking guitar found by searching on google and using our own imagination. We included the PDF of the vector drawings obtained from CATIA drafts (below). These pdf files are the files which were to be used in INK_SCAPE to make it fit for the format required by CNC foam cutting machine


Vector drawings PDF files

The prototype


and the final guitar




       Here are a few pictures of us wiring the prototype and the finished wiring. Since the touch shields were sensitive to mechanical wiring connections we opted to solder as many connections as possible.





          For the prototype we used the “polysynth” banana piano patch. We also made an attempt to use only one Arduino and a set of schmitt inverters for touch sensing and encode a 12 digit binary number ,one digit for each button, as a 4 digit decimal number then translate it back to binary in PD . However, in the end John worked up a more efficient functional block that replaced the polysynth. and we just used two Arduino clones and a USB hub. All of the patches need to be in the same directory for the program to work.

      MAIN PATCHguitarhero 

      SUB PATCH:   ‘note



      All the audio files were downloaded from (  )

guit1 is a bass,

guit2 is a single note from an acoustic guitar

and last but not the least guit3 is an OVER POWERED POWER CORD.

guit1      guit2       guit3       


   Through the opportunity of this project, the team members were able to learn many different skills from each other. Mr. Richard Staubin helped Ankit and Chiran with PD sketches and introduced them to the soft wares like INK-SCAPE. What started out as a mandatory course project, later turned out to be more than that, and the team enjoyed this whole process and again gained various educational insights to bring this project to completion. Kenny, the Maize high school student, was fast to learn PD and showed immense interest and hard work with team from WSU.

The result was a guitar, made out of foam programmed with Pure Data, which surprised many people and won their appreciation during the open house on 05/09/2014.

and finally here’s us playing with it LOL and explaining briefly what it is, with the actors Ankit and Richard.


YouTube Preview Image

In hind site, there are many features like pedal effects that would’ve made a great addition. But due to time constraints they couldn’t be implemented.  

We also planned to decorate the body (bellow) but we didn’t have a high enough quality print.


         The team would like to take this opportunity to thank Mr. Tom Mcguire (Senior design Lab assistant) for his contribution towards the success of building our guitar hero by helping us with foam cutting. The team would also like to thank Mr. John Harrison, who had been the real backbone of this project and course, to bring students together from WSU and Maize to work on project successfully. He also helped us with the PD sketches at the times when the team really needed and provided ideas and guidance to propel this project to completion.