JamDroid - The Automated Guitar

Transcription

1 JamDroid - The Automated Guitar Kacey Lorton, Brian Parkhurst, Anna Perdue The University of Central Florida School of Electrical Engineering and Computer Science, Orlando FL. Abstract- A state of the art automated guitar named JamDroid. JamDroid is a creative mechanical device that takes the input of midi files and converted into the programming language C. The program is then transferred using a microcontroller to control the electromechanical devices. JamDroid is to create an automation system to be used on an electric guitar, essentially making a real-time analog playback device. Our device would be used in place of human guitar playback or digital re-creation of guitar tones from a digital music sequence. The typical ways that sequences are created are through either MIDI-enabled keyboard pianos, or by software on a computer. Sequences can be created on either and sent to either. We used a similar method of taking a pre-determined music sequence and sending to our instrument hardware, and having it play it back as if it were a person. A user would download or create a MIDI file on a computer, be converted to control lines is needed for our system, be sent to the guitar hardware, and at the proper time, be played back. The playback would be sensitive to speed, note intensity, durations, and as many inflections and characteristics as possible. The guitar output would be sent to an amplifier or passed through effects pedals, as any other guitar might be in a live performance. always seems to be missing in a cover band is the true talent that comes from the original electric guitarist. This is where an automated guitar would be useful in the modern era. The idea of an automated guitar is to be able to replicate the sound of the electric guitar without human performance. The documentation discusses the design of a controlled electrical circuit and mechanical system that produces reliable playback of audio sound files on guitar. The electrical circuit including control system should be installed on a PCB with interfaces both to a computer USB drive and to the mechanical system. The idea starts with inputting any music file through the computer. The file will be converted, and will talk to the control system. The control system will talk to the different subsystems that we will create to make an automated guitar possible. The electro- mechanical devices we will create will include string selection and depression. This is what gives the guitar its ability to produce different pitches. Along with that we will create a subsystem for picking. The focus will be on electromechanical design, power systems, circuit design, programming, and serial communication. JamDroid can be broken into four main sections, encompassing, hardware, firmware, and software, power. II. Hardware Falling under hardware is the mechanical systems required to press frets, pick strings, and movement for string selection. The other side of hardware is the electrical components used to control the mechanical parts, in terms of control signals, along with an interface with a computer. The mechanical system was broken up into two components the string picking system and the fret pressing system. I. Introduction Music is nearly ubiquitous in our lives. There are many great musicians, Jimi Hendrix, Keith Richards, or even Jimmy Page. These musicians each have a different sound and are known for their remarkable talent with the electric guitar. Imagine going to see a Led Zeppelin cover band play. While watching and listening to the music play, all of a sudden you hear Jimmy Page s solo performance in Stairway to Heaven, almost exactly the same as when you first heard him play in For some this could be a beautiful experience, because the one thing that

2 The figure shows the two subsystems attached to the guitar that will be used for this project. The dimensions of the static items have been fitted specifically for this instrument and would likely not be compatible with another instrument, apart from one of similar make and model. A. Solenoids We have determined that in the implementation of depressing strings at frets as a human finger would require the use of linear solenoids. Linear solenoids would achieve the desired performance. This will work as current is passed through the solenoid, magnetic force is induced that will cause a metal shaft to be displaced. The requirements that were most considered when comparing solenoids were length, width, and height dimensions, weight, cost, force applied to the shaft, force versus current applied, force versus shaft displacement, coil resistance, and voltage, current, and power ratings. Of primary importance were the length and width of the solenoid. As the solenoid would have to be able to fit between each fret without hitting the previous solenoid from the other fret; It was desired that the length and width were both less than 20 mm. This requirement was chosen because of the fret-to-fret width at the 12 th fret, the highest fret location we planned to fit with a solenoid for string depression, was slightly larger than 20 mm. The choice of 20 mm had margin built in, as it was forecasted that there may be intermediate structure between the solenoids. Of next highest importance was the force applied to the shaft. In initial experimentation it was determined that the force required to fully depress a string on an electric guitar was less than one pound of force. The minimum required force to depress a string so that characteristic guitar sound could be produced, was estimated to be around 50 gf. Wanting to give plenty of margin on this specification because of the perceived variability of the quality of repeated tones produced from borderline force values, we set the desired force at 200 gf. A small solenoid with length and width below 20 mm each that produced a 200 gf force at the string would fit our first two requirements. (2.38 mm), plus a margin to avoid unwanted damping of the string vibration (1 mm), was 3.38 mm. Removed from this displacement was the projected height of a rubber cap adhered to the end of the solenoid shaft to aid in reliable string depression and characteristic guitar tone, which was estimated to be at least 1 mm. A final expected solenoid shaft displacement was set at 2 mm. That is, the desired force of 200 gf should be achievable at a displacement of 2 mm. Weight was not of great concern for the performance of the solenoid. However, as the solenoid would be a load on the servo motor that was moving it, and considering that the greater load would reduce the maximum speed of the rotation of the servo motor, it was important for the system s overall performance to minimize solenoid weight. The actual effect of the weight of the solenoid on the maximum speed of servo motor rotation, all other weights involved being equal, is difficult to predict accurately. However, we project that the motor speed loss due to solenoid weight would be minimal if the solenoid weighed less than 50 g. As we researched different models of solenoids, we kept that in mind as a loose requirement. B. Servo Motors The servo motors are an important electromechanical device used in the JamDroid design. The servo motors are responsible for string plucking system. They will rest upon the base of the guitar and have a guitar pick attached, to pluck the string. The servo motors will also be required in the string selection. They will rest on top of the fret board in a mechanical design. The servo motors will be scattered to move vertically the solenoids to work in string selection. Upon testing it was verified that the servo choice Tower Pro MG90S would be best to use due to the size and low cost. Below shows the dimensions and size of the servo motor, which was created AutoCAD Electrical Coupled with the setting of the force requirement was the understanding that solenoid force output varies inversely with displacement of the shaft, we were compelled to estimate the expected distance the shaft would be required to travel. The combination of the maximum prescribed action, or distance between the neck and a string that is not depressed, for a string

3 C. Microcontroller The most important specifications for choosing the microcontroller was the availability of designated PWM output channels. JamDroid requires the use of 8 servo motors to move the solenoids in the string selection to the correct location along with using 6 motors to pick each string. Therefore JamDroid requires 14 PWM input control lines. PWM is common across many applications, but since companies make so many models of microcontrollers, they are able to optimize them for use in specific applications, some of which do not use PWM. Therefore it had made it easier to narrow the search in choosing a microcontroller. When the composite of specifications significant to our design is considered, the TM4C123 family of microcontrollers is found to be more satisfactory. More specifically, the TM4C123 s maximum processor speed (80 Mhz to 48 MHz) and maximum number of GPIO pins (120 to 52) were superior. The maximum Flash memory (256 kb) and maximum SRAM memory (32 kb) were the same among the two families, and the rest of the listed specifications were comparable, while the maximum number of PWM channels (24 to 16) was greater with the ATSAMD family. However, as our design only needs 12 different PWM outputs, this was not significant. The major differences between the two families were cost, input/output resources, and processing resources. We felt the performance and resource advantage of the TM4C123 family was worth the cost. The evaluation board offered by TI is the Tiva C Series TM4C123G LaunchPad Evaluation Kit. The microcontroller incorporated into the evaluation board is the TM4C123GH6PM. III. Software In terms of software, we will be converting a MIDI file format into our firmware format, using a program that we would need to create ourselves in a high-level language. Also included in software would be a GUI controlling when the guitar plays, and potentially other features. The sum total objective of the desktop application, which is to be composed in C++, is to parse a MIDI file into its sequence components, and hence be broken down into its elements of note to be played, intensity of note, duration of note, and any other available parameters to be made available. Once the Tiva Launchpad has been programmed in the C++ language JamDroid communicates to the Launchpad via JTAG to talk to the chip that will be located on the Printed circuit board. Once we have our MIDI music parsed into useable data, we can then go on to convert it into a useable data format that our guitar system microcontroller can use to complete a sequence. We are to use the lowest 8 frets be playable on all 6 strings of the guitar, in addition to open strings (no fret pressed). Because of the way a guitar is made, there are several places in which the same note (frequency) can be played. With this in mind, a mapping module is created that can take in the Note number and simply convert it to a fret number. Because of the way guitar strings are tuned, the 5 th fret of the E2 String is equivalent to the open (no fret pressed) note of the A2 string. They are both A2. Therefore, if a note can be played on an open and available string, it would be convenient in all aspects to simply pick that particular string. This would circumvent the use of the servo motor and solenoid for that particular note, which frees a particular fret s servo to be moved to another string to play a note that cannot be attained through the easiest measure possible. Also to be converted is the measure value to a timestamp value, by taking the beats per minute and measure and combining them, taking into account the time signature as well, into a point in time for our convenience, with the beginning of the sequence being time t = A. Exceptions The software will require some exceptions implemented so as to not bog down the hardware with impossible to play sequences and so that notes on the same fret would automatically be changed into a different fret and string combination that is available. To show how this would occur, a new test sequence is required; one that would prove impossible without the planned exceptions To keep the jumping around to a minimum, the first exception check that shall be implemented will be the Range Check. It will compare a sequence item s converted String and fret position to range of allowable frets (in the event that it is too high) and if it is found to be greater than 77, that value could be subtracted by multiples of 12 until it reaches an allowed frequency and then placed back into the

4 sequence. In the event that the MIDI note was a frequency below the guitar s lowest frequency, it would not have been mapped to a fret in the first place. This provides us with the choice to either drop those notes all together or bring them up in frequency, up multiples of 12 MIDI notes until it reaches an allowed frequency and then be placed into its respective place in the sequence. After that stage of exception checking takes place, another exception check is necessary to alleviate the notes being on the same fret. For the example given, we would want the exception handler to see the conflict and then proceed to make the change of string to 5(B) and to then add 5 to the fret value, as this new fret is the same frequency as the previous fret. As for the first exception, note 80, originally on 1(E), fret 15, would be dropped by one octave, making it fret 3 on (1E). This would raise another hazard, as this fret was previously occupied by the same note. It would be possible to play it twice, as that is what it would do, but it would produce an undesirable effect of repetitive notes. To enhance the sound, this note could instead be moved to 6(E) on fret 3. However, this would raise a slightly different flag than that from before. The issue is not that the notes are on the same fret at the same exact time. Rather, it is that they are on the same fret but meant to be played sequentially without pause. Because of the physical limits in place by our mechanical design, this should raise a flag as well. Moving the servo/solenoid from string 1(E) to 6(E) and all the way back to 1(E) would not be feasible. For this sequence, we know in advance before we play that we want to be back at 1(E) on that fret relatively soon. Hence, it would be very good to not leave unless absolutely necessary until that note has also been played. Therefore, the moved note, originally at note 80, should be played on a fret that is currently not occupied by anyone in the general area of time around that note in the sequence. The exception handler would easily be able to conjure a list of possible notes that are in multiples of octaves below or above the note, and from that list, pare away notes that conflict with other notes nearby in the sequence. The distance in time that notes should be considered for paring is arbitrary at this point. More generic exceptions to be considered are the tempo of the MIDI sequence provided. Physical constraints on our design will limit the beats per minute that can be played as well as what power of note division can be achieved in measures, i.e. quarter, sixteenth, and thirty-secondth notes. There are two paths to be taken to alleviate speed constraints. The first option is to drop every other note completely from the sequence and essentially cut the beats per minute in half. The second option is to be to slow the song down, and effectively increase the timestamp values linearly across the board. At this point, the sequence could be ready to be sent to the guitar system to be played. Our microcontroller, and the firmware involved, detailed will simply want to see a stream of values to be pushed out in order to the various mechanical devices required to produce the music sequence. Hence, the final goal of the PC program written in C++ is to communicate via USB with our TI Microcontroller, send over the entire sequence packet, and then be able to initialize playback at the desired time. To accomplish this, the microcontroller has dedicated USB protocol lines and hardware internal to it. We are under the assumption that we will be able to use open source code to implement the USB protocol on the Microcontroller end to make it a slave device. IV. Electrical Design The electrical design section for JamDroid includes all of the schematics necessary to drive the electromechanical devices. This includes the servo motor driver circuit and the solenoid driver circuit. Once the servo motor and solenoid driver circuits have been designed they must be modified for the requirements. There are 8 servo motors that will be used in the fret system and 6 in the picking system. There are 8 solenoids needed with an additional 6 solenoids that are used for damping. Device Needed Pins Servo Motors 14 Solenoids 14 A. Servo Motor Driver Circuit To drive the servo motors a pulse width module is required. The microcontroller offers the pulse width module lines and 16 of them are available for. Since JamDroid requires 14 servo motors, the microcontroller offers enough pulse width modulation to run the driver circuit. Both the servo and microcontroller require an external power that requires around 5 volts and therefore can be part of the same regulation line.

5 The fourteen servos will be interfaced directly with the microcontroller chip s dedicated individual Pulse Width Modulation GPIO pins, with the microcontroller and servo motors sharing a common ground. All fourteen servos shall have a common ground and a common supply voltage of 5 volts. There are no required dropdown capacitors or resistors with the servo circuits as they have all the required couplings, stator, and pulse width modulation circuitry is all packaged within the servo. B. Solenoid Driver Circuit Solenoid plungers can be switched in between an on or off position by a number of electrical components, including transistors. Solenoids act as inductive loads on a circuit, whose voltage drop is proportional to change in current so a protective component is required to be placed in parallel with the solenoid coil to prevent high voltage from damaging the semiconductor switching device. In this case we will need a freewheeling diode. Below shows how we will drive the solenoids with the microcontroller, along with the using of a BJT. The type of transistor we will choose for our design will be a BJT, as a BJT does not require as high of a voltage applied at the base to operate as a FET requires at its gate Though the drawbacks of using a BJT are current flow at the base terminal, voltage drop across the collector-toemitter terminals, and often higher power dissipation, they have not been issues to the testing, and implementation of JamDroid. The BJT that the JamDroid solenoid Driver circuit requires is the TIP102 Darlington NPN BJT. The output from the microcontroller is either high (3.3V) or low (0V). When it is low, the biasing voltage is below turn-on voltage and the transistor is in cutoff mode. The collector-to-emitter terminals act as an open circuit and the power supply is not connected to ground. The solenoid remains in the off state. When the output of the microcontroller pin is high, the transistor is biased beyond the turn on voltage. The collector-to-emitter terminals nearly act as a short circuit; the transistor is in saturation mode. The power supply is connected to ground and current is passed through the solenoid but not through the diode. The current in the solenoid does not change instantaneously but exhibits a transient response. By the end of the transient response, the solenoid passes an expected amount of current, resulting in the desired force applied to the shaft and, by extension, the guitar string. When the microcontroller output transitions from high to low voltage, the solenoid is expected to return immediately to its off state. The use of the freewheeling or flyback diode is placed in parallel with the solenoid to dissipate the current quickly. This occurs as the sudden change in voltage supply induces opposing current through the solenoid, causing it to continue operating after the desired time and with the spike in voltage potentially damaging the circuit components.

6 C. Printed Circuit Card V. Firmware For firmware, we will create a control construct based on picking a note, which encompasses picking a string and fret, deciding when to play that note, at the same time potentially simultaneously doing the same for a different fret/string combination. The arena of firmware to be used in our design begins where the software implemented on the PC computer ended, which is at USB communication as a slave device. Our microcontroller will shake hands with the PC computer, receive a packet including a musical sequence and then store it in memory to be initiated at the desired time specified by the master device, the PC computer. Assuming a song sequence has been sent to the microcontroller and then stored in memory, here is an example of what we will need the microcontroller to do. Below is an example of a sequence that will be necessary. The volume level parameter from the MIDI File, has been converted to simply high for this sequence. In the case of a much longer sequence, this would be specified per second of the sequence Number of items in Sequence = 6; Volume: High String Fret Duration Time End Note time 2 (B) (B) (E) (E) (E) X X Infinity Infinity All of these sequence components need to be turned into electro-mechanical device instructions. To accomplish a list was implemented; first the devices were converted to that of a state/position value. There are various field sizes so encoding these into bits, bytes, or words were a case by case basis. The conversion showed that there are some elements which will only need two states; for example the solenoids. They are either turned on or off. This could easily be represented in two bytes in memory and or a register, and just bit-set when necessary. Other elements, such as servo motors, would need six values, making the minimum bit field required to be 3. The value stored in a particular Servo s variable field would be tied to a Pulse width modulation value to be output by the Microcontroller at all times while the system is powered on. A 1 encoded would indicate the pulse width required for the servo to move the matching solenoid to the E(1) string, whereas a 6 encoded would change the pulse width to the value required to move the solenoid over to string E(6). VI. Power Since we are using 6 servo motors for the picking system and 8 servo motors for the fret pressing system JamDroid requires a total of 14 servo motors. Since JamDroid requires the use of 8 solenoids for the first octave. Power will also need to be distributed to the microcontroller. Below shows a table of the power requirements for the devices chosen. Component Rate Current Rated Voltage Power Supply 24 V 14.6 A Servo Motors 4.8V-6 V 0.3 A Solenoids 5V-6V 0.5 A The rated current and rated voltage was taken from values that were measured during testing. The values were also taken from the data sheet. Since there are 8 solenoids that require 5 Volts to 6 Volts that use 0.5 Amps, JamDroid requires a regulator that is able to breakdown a high voltage into low voltage, having a regulation of 4 Amps of current. However there are also 6 more solenoids that are used at the base of the guitar that is used for damping. Therefore in total we will need 7 Amps of current. The figure below is a schematic of the capacitors, and resistors values used for regulation. To either adjust the current or voltage within the circuit the resistor values just need to be changed. The regulator used for the circuit that breaks down 24 Volt to 5Volt and has an output current of 5 AMPS requires the LMZ23605tz. The circuit is shown below.

7 Since we are using 7 Amps of current for the 14 solenoids that are being used, therefore we will only have 10 solenoids on the line. There are still 4 solenoids that are not attached to on the line and we have 2 Amps to make up for. We also still have servo motors that require about 0.3 Amps of current per each servo motor used, JamDroid requires 4.2 Amps. Therefore a solenoid can be added to this line and that offers around 4.7 Amps of current. Since there is still minimum current left, we are able to attach the microcontroller to this line. The microcontroller consumes micro amounts of current, and when it is powered by 5 Volt, the internal power breaks it down to the regulated 3.3 Volts, that is needed. Below is a schematic for this circuit. It will power all 14 servo motors, 1 solenoid, and the microcontroller. This circuit regulates the voltage to 5Volt and offers and output current to 5 Amps. The voltage can be increased, and the current can be decreased or increased by simply changing the resistors values. Again the regulator that is used for this circuit is the LMZ23605tz. Once the circuits were designed for the correct power regulation, the printed circuit board needed to be created. The printed circuit board was used from the EagleCad. Once the schematic had been created it was easy to convert to a board. The layout was created through simplicity having three lined up by the output pins, and after the input pins. It should be clear which circuit is which. Also the width lines were created to carry the proper amount current without have a high temperature lead. Below is a figure of the board that was created for the power distribution. The servo motors all have power distributed, and breakdown to the rated voltage and current. The microcontroller also now has a line to receive power for. All but three solenoids have power distributed to them. This leaves about 1.5 Amps of current that is needed. Therefore the regulator used is the LMZ23603tz. The current in this regulator can be changed up to three amps of current within a simple resistor change. Therefore if more current is needed in the assembly, we are able to make a simple resistor change. This concludes the power for the 14 solenoids, 14 servo motors, and the microcontroller. The figure below shows the circuit for the regulator that has an output current of 1.5 Amps and 5 Volt output. The board was ordered through OshPark, due to the quickness and affordability of the board. With the order three boards came with the order for the affordable price of $ VII. VIII. Conclusion Biography

8 Brian Parkhurst is a senior Electrical Engineering major at the University of Central Florida. He worked as a student technician at Lockheed Martin s Missiles and Fire Control Division in Orlando Florida in the CWEP Program for just under two years. His technical electives focused on Communications protocols and microwave engineering. He has accepted an offer from Northrop Grumman s Electronics Systems division in Baltimore, MD. Anna Perdue is a senior Electrical Engineering major at the University of Central Florida. She worked as a student technician at Lockheed Martin s Missiles and Fire Control Division in Orlando Florida for more than half a year as a CWEP student. Her technical electives focused on MEMS and power engineering. Upon graduation, she would like to focus on clean and renewable energy engineering solutions. Kacey Lorton is a senior Electrical Engineering major at the University of Central Florida. He worked as a student technician at Lockheed Martin s Missiles and Fire Control Division in Orlando Florida in the CWEP Program for just under two years. His technical electives focused on FPGA design and..upon graduation he would