Player Guitar

From Omaha Maker Projects

Jump to: navigation, search

Contents

Naming

This project doesn't have a proper name yet, beyond the excessively descriptive "Player Guitar".

Proposals include:

The Plan

The idea is to build a guitar that plays itself. More specifically, a device that could attach to a standardish guitar and play it. The endgame plan is to have a rolling "shunt" that performs the fingering functions, driven by a stepper motor. The positions for notes would be self-tuned on startup such that true string tuning is less important. From there, a rotary plucking mechanism would actually strike the strings and play notes.

Fingering

I'm envisioning a system where a stepper motor drives a carriage (on either a belt or a rod) up and down the neck of the guitar, positioning a shunt (known as a Steel on a conventional slide guitar) on each string. It'd need a home position switch at the top to facilitate calibration. Expanding this to multiple strings would be a pain, but required for chording.

Self Tuning

On startup, the guitar would drive the shunt (the "finger") to the home position (adjacent to the Nut (the top of the strings, near the head) and strike a string. The shunt would then move down the neck to the lowest position, with an acoustic frequency counter making a record of how many steps down from home each note's frequency is. From there, the system will use absolute positioning to move the shunt to any desired note on demand.

Frequency counting

Per Jason Uher

use an attiny to do all the sensing then I2C it to the arduino
you could even do one for each pickup (with one chip)

Plucking

Plucking would be accomplished by either a gear or stepper motor (or potentially a solenoid) that caused the pick to impact the string at a 15-20deg angle (relative to perpendicular). It'd hold one or more conventional guitar picks (if a stepper), and be able to pluck quickly by rotating, picking multiple times per rotation.

Alternatively, it's been discussed to have a "shred it yourself" mode, whereby the mechanism decides when you've plucked the appropriate string, and moves on to the next note. You pluck, it fingers.

Links

Ideal Songs

For initial testing, the basics (like twinkle-twinkle little star) would be ideal, but eventually anything that relied on pluck speed over note-shift speed would be within reason. Some of the note shift issues could be managed with a custom string/tuning setup, where you could jump a whole octave by just switching strings (For example, have multiples of strings other than E). This would sacrifice range and versatility, but improve performance over a smaller set of notes.

Dumping Ground

2. I did a bit of looking at how to play a guitar, and basically I have no clue what I'm doing, but I don't think that'll stop me. The short of it is that each string is tensioned to play a particular note when struck "open" (ie not shunted with a finger to the fretboard). From there, different notes are generated by shunting the string at various lengths. Not every string makes every note, though. I'm enlisting some assistance from a friend who actually plays a guitar to get me some basic insight on how that all works (I checked the internet, and all they seem to talk about is chords, which isn't as fundamental as what we want). 3. I've also determined that there are far too many positions (up to 8 or 9 per string, I think) for shunting to have solenoids be a viable option for a "production" model... I might also have to do some hunting to find 8-10 identical solenoids for the prototype. We may need to switch to some kind of rolling shunt driven by a stepper or something... It won't be "instant" like a solenoid, but I think that's OK.

Aside from all that, I think that a shunting mechanism is almost certainly the way to go, relative to the tension-only mechanism that I'd suggested last night... It requires virtually no dynamic retuning (once the string is tuned, and the shunt points are set, nothing needs to change regularly...)

Just got off the phone with a friend of mine who's a real live guitarist (not [usually] for money or anything, but he's actually a trained musician, just not specific to the guitar), and he was able to explain tons of theory stuff to me, most of which isn't important to us. Most importantly, he informs me that there are 11 "half-steps" (aka "notes") per octave, at which point you'll have used up half of your string.

Based on his input, I think our best bet for a prototype is a single-stringed instrument, with a wheel/bar that slides up and down to fret the string. He further tells me that this is basically how a "slide guitar" works. Based on this photo, 12" of travel should give us a whole octave, with 6" more for the second, and 3" for a 3rd (which would be inefficient).

[FALLBACK PLAN] Secondarily, I'd thought about using solenoids to grab the string at each fret, but that seems like a ton of work, and really limits the number of notes you can strike (at the very least to "actual notes". It'd be amazingly fast, though.

[FUTURE PLAN] I've also done some thinking (which is too big to put here) about how this might become a more extensive instrument, not unlike a pipe organ (in design, not scale... it'd still be relatively small); The downside would be that it'd look nothing like a guitar. The upside would be that it could play songs that would take a whole room full of guitarists.

[ACTUAL UPDATE]: One way or another, I've secured us a guitar for testing. My friend volunteered an old one (cost $0), though I might consider the $20 CL one if it comes through first. Extra materials can't hurt, right?

[NEXT STEP] Basically, there's 2 components to AutoGuitar v0.1: Fret-sliding and string-plucking. The fret-sliding is the more complex (imho) of those parts, so I'll probably start there. Some kind of stepper-motor setup, with a "home" switch up at the top of the fretboard, and a way to calibrate it so it knows how far down to move for each note. The actual build shouldn't be hard; I'll probably try to salvage an old dot-matrix printer for this assembly...

Personal tools
Namespaces
Variants
Actions
Navigation
Toolbox