A while ago I had an idea that goes roughly like this: you open a shop in some location with lots of tourists – maybe in the Mall of America or in a place like Estes Park, CO – the type of place where people are in a spending mood and have those cheesey “Old-Timey Photos” taken.  In this shop visitors could pose to have a statue of them made. You’d scan them with some sort of 3D scanner and then a custom 3D CNC mill would carve a wooden statue of them while they watch (behind some safety glass). Your setup might even have software that allows them to puff-up their muscles like a super hero, maybe make their belly look a bit more six-pack-ish, make balds spots disappear and so on.   You might sell the small statues fairly cheap, but charge a lot more for large, living room fixture-type statues.  What mother wouldn’t want some little wood-carved statues of her children for the mantle?  It’s a slam dunk.

I first documented this idea back in late 2009.  I did some research into off-the-shelf 3D scanning technologies(expensive!), 3D printing (expensive!), and 3D CNC technologies (expensive!).   I looked at a few college projects for simple 3D scanners that had been posted online, I developed plans for pseudo-3D by combining DIY CNC with a lathe.  Because most of this stuff is so far outside my areas of expertise (and also because most of the people I told the idea to seemed to think it was kind of lame) I gave the idea a fairly low priority – so far all I’ve done with it is bookmark a lot of web pages and make a lot of sketches.

Then the other day I stumbled on this video. Basically it’s my idea brought to life.

Be Your Own Souvenir! from blablabLAB on Vimeo.

So here’s the thing about ideas. Everyone has ideas. With billions of people on the planet it’s inevitable that for any half-way decent idea, thousands of people will come up with it independently. But for some reason that’s not the way we prefer to think about ideas – Edison alone invented the lightbulb (not really true), Bell alone invented the telephone (also not true), only one person can have an idea and everyone else is a copycat.

The funny thing is, the truly difficult part of any idea is making it happen.  An idea doesn’t just turn into a prototype, it takes a lot of time, perseverance, and hard work.  So my hat is off to the guys at blablabLAB for making this idea happen.  But not so much for the idea itself, any jackass could have come up with that.

OMG! A new version of Artscii already!

New features:

• Much faster.
• Color!
• You can select multiple font sizes, up to 500 pt – which is crazy (note that larger fonts take longer to analyze)
• Artscii can convert images to black + white on the fly.
• Option to invert – white fonts on a black background instead of black on white (see starry night below)
• Dithering!  It only *kind of* works at this point, but it’s in there.
• Tool Tips – hold mouse over confusing features for a (still probably confusing) explanation of what they do.
• A Replay Button – Mildly pointless but fun to watch, it plays back the placing of letters at high speed.
• Run artscii from the command-line.  This feature is very limited and possibly even a little buggy, but just run artscii with the path of an image and it will process it with some default settings, save the result as [filename].artscii.png, and exit automatically. I used this with some scripting to create the video below

Some new eye-candy:

Starry Night Inverted - white letters on black background

Barely even seems like ASCII art.

Some features still to come (maybe).

• words and phrases
• overlapping letters
• More control – advanced options for selecting which letters in which fonts in which sizes.
• option for letters to go outside the frame (hard to explain… you’ll see what I mean)
• Better dithering

Just running it on a single letter generates kick-ass results.  I think this would make a pretty sweet type-face

Brought to you by the Letter A

And the Number 8

You can limit it to specific letters (though it tends to have “favorite” letters for filling in dark areas, like lower case b):

Also useful for generating cliched tripe like this (favorite letter here is obviously ‘O’):

Even cool with just one character.

Here’s the program for anyone who wants to play with it.  This is just a prototype – it’s SLOW, the user interface is crap, you can’t change the font sizes, it’s buggy, etc.  Requires .NET, which is probably on your system already.

• Artscii

A few tips:

• Start with small images.  800 pixels max on the longest side.
• For best results convert your image to black and white first – not grayscale, black and white.
• Times New Roman always seems to look great.  Other fonts are hit-or-miss.  ”Funky” fonts don’t usually turn out so great.
• Results often look better when run with only lower-case letters.  Upper-case is kind of jarring.  LIKE BEING YELLED AT.
• This program will rail your CPU.  Open your task manager, select the processes tab, right-click on artscii.exe and select Set Priority->Below Normal to be able to use your computer while it runs.
• Using a single character and lots of different fonts can yield interesting results.
• Some characters like lowercase L render as just a single fat line in some fonts and the result doesn’t look much like ASCII art.

Potential future improvements:

• Faster
• More intelligent about fitting letters together, by using branch-and-bound game-AI algorithm.
• Ability to add words and phrases
• Minor tweaking so it doesn’t over-use certain letters and patterns of letters
• Dithering algorithm of some sort so that it can handle gray-scale images intelligently
• HTML output / vectorized output
• Color?

Normally what you should do at this point is patent the idea then wait for someone else to come up with the idea and actually make it and then sue them for $millions.  This is the guiding principle of our entire patent system.  But I don’t have $10,000 lying around to get a patent, so I decided to just go ahead and try to make it myself.

How do you make a train that records it’s own tracks?  Basically, you need a motorized vehicle of some sort that knows where it is at any moment relative to where it started.  And that can record that position and play it back.  It also needs to be able to complete a loop – the person using the toy will probably never be able to create a perfect loop, so the toy needs to be able to correct the loop so that it can be played back over and over again.  None of that is very simple, but the part in italics is really the key.  How can a toy know where it is?  I came up with dozens of ideas, but eventually boiled it down to these:

• Use a mouse sensor (or something similar) to track distance and turning
• Count the rotations of each wheel on a car and use the differential to determine movement direction.

There are probably hundreds of other ways of recording position – from echo location to GPS to using a cheap video camera and complex digital analysis.  There are also a lot of ways of “cheating” – waypoints that the toy could move between, line-following robots, etc.  But I decided to stick to original idea and to approaches that I could actually prototype cheaply.

I’ve created two prototypes so far.  While neither of these look anything like a “train”, keep in mind it’s not that hard to put a train shell over a motorized toy. Each prototype represents hours of bread-boarding, soldering, coding, and testing.

Mouse-Bot

I was born a computer mouse, but I am oh so much more than that now...

The basic ideas is this – when you move this monstrous franken-toy forward, the microcontroller receives y (as in vertical on an x-y axis) signals from the mouse.  When you turn the toy, it receives x signals.  Using a lot of trigonometry, it should always know where it is.  It actually works quite well. You can watch a video of it following a pre-programmed path here.

Here’s the problem, though.  If the mouse is not perfectly aligned and perfectly centered between the two wheels, crazy-complex calculations are required to compensate – and it’s nearly impossible to perfectly align and center the mouse. The calculations are too complex for the microcontroller to do on-the-fly, but without the calculations, the mouse-bot tends to always pull toward the left or the right (depending). Even the slightest misalignment leads to massive failure.

So I gave up on the mouse approach.

Zoomerang

I think I can, I think I can...

Approach number two, keep track of the differential turning of two wheels.  With a great deal of tweaking, this approach mostly works.

As the video demonstrates, the main problem seems to be recording – it can fairly successfully play back the same loop every time.

I had a lot of trouble finding practical encoders to count the wheel turns, and there’s also a huge problem in that the motors are always “engaged”, so the wheels don’t want to turn during record mode. The system I use for counting wheel turns is ring magnets with alternating poles combined with Hall sensors.  I get 8 “pulses” per wheel turn which is not very precise.

The shiny ring is actually a magnet with alternating north and south poles

There are a number of ways I could improve this design – much more precise encoders, adding a digital compass so that I know which way the toy is pointed (any extra data helps), some sort of method of disengaging the motors in record mode. But I’m starting to get the feeling that this dog won’t hunt.

Insert Coin To Continue

I’m going to shelve this project for a while.  If I pick it up again it will probably be to create a “waypoint” version.  It would work like this: put down two or more (solar-powered?) beacons and a toy will loop between them.  But for now I’m on to other projects…

Circuits and Such

Some notes on the circuit design(s) I used

• The microcontroller and sensors are powered by a 3.3V boost circuit – which doubles as a voltage regulator.  The motors are powered directly from the batteries.  Without the boost circuit, the sensors and even the microcontroller can get confused by voltage spikes and drops when the motors are turned on and off.
• I used a single MOSFET to drive each motor.  With this setup the vehicle can only drive forward.
• Also note that most MOSFETs have a rather high gate threshold, and some of them have a surprisingly high on-resistance.  When using MOSFETs to drive low voltage motors, look for low values for both of these attributes – i.e. gate threshold around 2V and on-resistance in the milliOhms or (even better) microOhms.
• For the mouse-bot version, I directly soldered connections to the mouse’s internal circuit board, rather than fool around with USB or PS/2 communication.

The software I wrote to make the mosaics only works on Linux, and is very confusing to use, but I plan to port it to windows and add a GUI to make it more usable, and then release it.  Maybe as freeware, maybe as shareware, maybe as open source – haven’t decided.  I’ll start on it pretty soon, but at the moment I’m working on some ASCII art stuff and a microcontroller project.  I get enough requests from people who have seen my collages that I think it’s finally time to put it out there.

Here’s a link to some more collages/mosaics that my wife Alonna has made with the same software.

• Traveled the world, visiting Holland, France, Spain, Austria, Switzerland, Germany, Czech Republic, Hungary, Italy, Greece, Ecuador (including the Galapagos Islands), Argentina, Chile (I was there for the 8.3 earthquake), England, Turkey,  Egypt (pre-revolution), South Africa, New Zealand, and Australia.  Before you ask, they’re all my favorite.
• Fixed up and sold our house in Boise, packed up everything and moved to Colorado (actually had to drive the trip 3 times – long story)
• Put in hundreds of hours mountain biking all over the world, including my favorite spots, Moab and Fruita
• Got in amazing shape.
• Modded the Rock Band drums for recording and playing back.  Also known as “cheating”.
• Worked really hard on a new project that I’ll talk about here soon if I can ever get the thing working.  I’ll probably post something here about it even if I can’t get it working because it has consumed so much of my time.

To mark my return,  I thought I’d share what I’m certain is the most extensive collection of horse metaphors (meataphors?) that can be found anywhere on the Galactic Interweb.   I encountered situations for which each of these colloquialisms were uniquely useful while waiting in airports, climbing mountains, lost in strange and dangerous cities, and even once while riding horseback to the rim of an active volcano.

Horses are obsolete as a mode of transportation, are (unfortunately) taboo to eat because of their big sad eyes (unlike cows?), and generally just serve as a rich-people pet that drops steaming piles of shit all over my favorite trails.  But they are still very useful as a source of colorful meataphors.

• I’m so hungry I could eat a horse
• Don’t look a gift horse in the teeth
• Heard it straight from the horse’s mouth
• To “have a horse in the race”
• You can lead a horse to water but you can’t make him drink
• Get down off your high horse
• Piss like a race horse
• Putting the cart in front of the horse
• Hold your horses
• Horsing around
• Dark horse candidate
• Every horse thinks his own pack is heaviest
• Beating a dead horse
• One horse town
• Need to see a man about a horse (have to use the bathroom)
• Riding your hobby horse
• F— you and the horse you rode in on
• Hung like a horse
• Back that horse up
• If dreams were horses, beggars would ride
• That’s a horse of a different color
• Stalking horse / stalking horse offer

Meta-horse expressions:

• Getting a little long in the tooth
• Chomping at the bit
• Given free rein
• Back in the saddle

Ponies!:

• Dog and pony show
• One trick pony

Try to use two or three in every conversation.

I stumbled upon one great solution here – use PWM from a microcontroller.  And Atmel recently introduced the ATtiny43U with a built-in boost converter – hopefully this will become a trend and all microcontrollers will come with built-in boost converters, the same way they (mostly) all support serial, I2C, and SPI.

But in the meantime I wondered if a simpler solution might be possible, a boost converter using a 555 timer.  The 555 timer is a very common $0.20 chip that can generate a PWM at a given frequency and duty cycle based on the charge time of some chosen resistors and a capacitor.  The circuit would need the same basic external components as a boost converter (inductor, diode, capacitor), but it would be a lot cheaper.   It wouldn’t be able to regulate the voltage, only multiply it using a calculated duty cycle, so the solution already starts off a bit limited since the voltage of a AA battery varies over it’s lifetime.  But despite this limitation, there are definitely applications where providing roughly 5V from a single AA or AAA is very useful (powering servos in a kite aerial photography rig, for example)

The circuit looks like this:

Wikipedia has a great explanation of how a boost converter works.  The basic idea is that the source voltage is run through an inductor and alternately connected to ground through the transistor and disconnected so that it will charge the capacitor.  The ratio of how long it’s connected to ground and how long it’s disconnected is the duty cycle, which determines the boosted voltage.

The math is pretty simple: D = 1 – V_i/(V_o+0.5) gives you the duty cycle you’ll need (the +0.5 part is to compensate for the forward voltage of the diode).  555 timer calculators are available all over the Internet for choosing resistors and capacitor based on the duty cycle. As long as the frequency is in the KHz it should work.

And when wired up it does work great… until you attach a load, then the voltage drops precipitously.  Higher frequencies seem to help a bit, but not enough.  A higher duty cycle is needed to compensate for the load, which is how a boost converter handles the problem, but our simple 555 timer with its constant frequency and duty cycle is not up to the task.

If the load never varies – powering a string of LEDs, for example -  then you can play with the duty cycle to get the voltage you need under those conditions.  Other than that, the only thing it’s useful for is charging a capacitor.  If you wanted to boost a 1.5V AAA battery up to 12V or 50V and release it all at once, this circuit can get it done.  Use it to shock your cat.

So a 555 timer isn’t very useful for a boost converter because there’s no easy way to adjust the duty cycle on-the-fly.  But inexpensive PWM controllers do exist… perhaps I’ll try that next.

I’m going to focus on the X-Plorer, but the Guitar Hero World Tour controller and the Les Paul controller work almost identically, eventually I hope to do a post about the differences.  The RB and RB2 controllers are completely different…

Of course, modding your controller to play songs for you is cheating.  I would generally discourage you from using a modded controller on “Pro-Faceoff” mode or anything like that where your cheating will actually adversely affect someone else.  Use your powers for good instead of evil.

Layout

Below is the inside of an Xplorer.

Not a date you'd bring home to mother

Wires run from the main PCB in the upper right out to the fret buttons, strum bar, and whammy, as well as to the headset connection, and a connector for an effects pedal that was apparently never created.  The thick black wire is USB, which is broken out into 5 wires.  The most interesting are probably the top red wire – 5V Vcc – and the black wire second from the bottom – GND.  With these you can power LEDs, a microcontroller, etc.   As you can see there is plenty of empty space inside the controller.  The possibilities are endless.

Guitar Hero PCB

Xplorer PCB

Here is the main internal PCB (printed circuit board) of the XBox 360 Xplorer controller.  I’ve labeled a few items

• A – The microcontroller (uC).  This is the real brains of the guitar.  It accepts inputs, thinks about them, and passes them off to the XBox360.  Generally there shouldn’t be too much for a microcontroller in a device like this to think about, but this appears to be a powerful microcontroller, relatively speaking, based on the number of I/O pins and the fact that there appears to be a spot for optional external RAM. (this spot is populated in about half the Xplorers I’ve seen).  Since it’s labeled “Microsoft” and not “Atmel” or “Microchip” or something similar, my guess is that it’s probably an ARM based custom ASIC.  It might be possible to put custom firmware on it, which would be awesome, but extremely difficult.  Sometimes the Microsoft label is absent, but it still seems to be the same chip.  The microcontroller runs at 12 MHz.
• B – XBox communication chip? – this chip probably handles encryption of some sort.  This is why 3rd party controllers have to be licensed from Microsoft in order to ensure greater profits.  The most likely format of this encryption is something like this:  <Xbox>: hello  <Xplorer>: hi <Xbox>Challenge with random number <Xplorer>Response based on private key and random number <Xbox>Tell me about yourself <Xplorer>String containing serial number and description (this is probably how games know the difference between drums, microphone, guitar, etc).  This is all just semi-educated speculation.
• C – Accelerometer – this is how the controller knows if you lift the neck of guitar up for star power.   From the name you might think that the acceleration of lifting the neck is the key, but actually an accelerometer basically tells the microcontroller which way is down at any given moment.  It can also tell if you shake the controller or drop it, but probably doesn’t care.  In fact, it appears to me that this accelerometer is hard-wired to act just like a button – when you tip the neck of the guitar above a certain point it “presses” the Back button.  The accelerometer is a 3-axis A7260.

Buttons

Normally in an embedded device, buttons are a very simple thing.    Each button is connected to an I/O pin on the microcontroller.  An internal pull-up resistor causes this pin to always read a logic 1 when the button is not pressed.  When you press the button, the pin is connected directly to GND, and the I/O pin reads a logic 0.  This works very well, and it’s one of the first things you’ll learn if you start learning microntrollers.

How a normal button works

For some reason the Xplorer works differently, it uses a sort of signal system.  The guitar microcontroller generates 6 or so “signals”, and pressing buttons connects one of these signals to an I/O pin.

A strange way to handle buttons

I’ve heard that until recently regular XBox 360 controllers used the same system, so I suspect – especially given that the central microcontroller is labeled “Microsoft” – that the Xplorer is basically just a regular XBox 360 controller with the parts rearranged.

Fret Buttons

There are 8 wires going out to the fret buttons, and they are labeled 1 through 8 on the underside of the PCB.  Pressing fret buttons connects the wires like this (In each of these, the first wire is the signal, the second wire is the I/O pin.  I’ll be referring only to Xplorer Rev B):

Wires 2, 5, 6, 7, and 8 are signals, and wires 1, 3, and 4 are the inputs.  The signals must be different enough that the input pins can tell them apart, so if signal 7 and 6 are detected on input wire 3, the microcontroller knows that both red and yellow are pressed down.

Several of the signals are “duplicates”.  Signal 7 is the same as signal 8 – if you touch wire 8 or wire 7 to wire 1, the controller thinks you are pressing the green button.  Touch either one to wire 3 and it thinks you are pressing red.

Understanding the Signals

The signals themselves are 1 kHz reverse sawtooth waves.

The signals on wires 2 and 8

Signals 2 & 8 when connected to I/O wire 1

What’s going on here is pretty clear, once every millisecond the microcontroller sets several signals high then checks the corresponding input wires to see if you are pressing the corresponding buttons, then sets those signals low and moves on to the next one.  In other words, it sets wires 8, 7, and 5 high, checks wires 1, 3, and 4, then sets those signals low again and sets 6 and 2 high and checks inputs 1 and 3.  The shape of the wave shown on top is caused by a capacitor – the spiked shape on the bottom when the button is actually pressed is because the capacitor discharges into the input pin.  The delay between setting one signal high and setting the next one high is about 10 microseconds, and the delay between setting one signal low and the next one high is less than 1 microsecond -  so synchronizing with these signals and mimicking them would be very difficult.  Maybe that’s the point, hacking these controllers would be a lot easier if you could just generate the appropriate signal on the appropriate wire.  I think it can be done, but haven’t tried.

The diodes shown here are to prevent current from flowing the wrong way if you press two buttons at the same time which are connected to the same input wire.

The signal traces pass through the diodes on the right

I could do a much more extensive analysis of these buttons and signals, but I don’t see any point, you can just simulate button presses by connecting the appropriate wires with optocouplers or analog switches and move on to more interesting challenges.

How to Simulate Button Presses with a Microcontroller

In my mods I have found these optocouplers to work well (make sure you use a 1K resistor too!  read the datasheet!), and I’ve also done some testing with these analog switches, which are cheaper, smaller, and easier to use than optocouplers, and they seem to work great, but I only recently discovered them and have not made any mods with them yet.

With optocouplers you connect the desired signal to the collector pin of one of the photo transistors, and the corresponding input wire to the emitter.  When you trigger the photo coupler, the two are connected.  However if you wire it up the other direction (signal to emitter, input wire to collector), it won’t work because current can only flow one way through the photo transistor.  This Wikipedia article explains how optocouplers work.

Analog switches on the other hand allow current to flow either way once the switch has been triggered.  Just send a logic 1 to the control pin and the button is pressed.

Regular transistors simply won’t work.  Or, more accurately, they won’t work simply – an analog switch is basically a collection of transistors and resistors.   But any simple combination of transistor and resistor to bypass the button will interfere with the signal.  A MOSFET transistor (as opposed to standard BJT) might work, but I haven’t verified this.

Below is the circuit board layout for my Guitar Zero mod, and you can see how I used optocouplers to simulate button presses if you stare long enough.  The optocouplers are the two chips on the right side, and 2 resistor arrays are located above and below them respectively.  The ASCII art is artfully distasteful, as befitting a mod of this nature.

Strumming

Strum is really just 2 buttons, and they work the same as the fret buttons, there are 2 signal wires (up strum and down strum), and one input wire.  You can tell which is which just from looking at the strum PCB.

strum connection wire desoldered in preparation for modding

Interestingly, if you strum up and down fast enough – and it doesn’t even have to be all that fast – both up and down strum can be pressed simultaneously.  Either the guitar or the game itself does some filtering so that this is handled intelligently.  In my experimenting I’ve found that just tapping the strum button really fast and releasing as fast as you can results in it registering as being pressed down for at least 100 milliseconds.  So in those really fast songs with close together notes, there is a limit to how fast you can hit those by only strumming in one direction.

Back, Start, D-Pad, LEDs

From what I can tell from following the traces on the Xplorer PCB, the up and down d-pad buttons are wired to the same input wires as up and down strum – the Guitar has no idea which one you press.  Not that there’s anything useful about knowing that.

The LEDs for the ring of light appear to be 0805 or possibly 0603 surface mount.  You should be able to easily swap them out for different colors… but I haven’t tried it.  This search should turn up (probably) compatible LEDs.  Blinking and alternating color LEDs would be a perfect mod for these, but those are hard to find in surface mount form.  If you want to order 3000, try here.

Whammy

If you’ve read about the Xplorer at all you probably know that the whammy bar uses a potentiometer.  It’s labeled a 10K potentiometer in some guitars, though I measured 9.5K, strangely (note that if you measure it while still connected to the guitar you’ll get a completely different – and inaccurate – value).  The voltage going into it is about 1.60V, and in its default position, the whammy potentiometer divides this to about 0.75V.  Pressing the whammy bar all the way down results in a voltage of 1.45V.  As you wail on the whammy bar, the voltage varies between these two levels, and this value is presumably read by an analog pin on the microcontroller.

Whammy Potentiometer outside its natural habitat

I’ve done some playing around with this (I’ve been working on a little hack to play Row Row Row Your Boat on the whammy bar on really long held notes.  Stay tuned), and I’ve found that just sending between 1.45 V and 0.75 V on the middle line is enough to “fool” the guitar.

I believe the input voltage to the whammy potentiometer registers as 1.6V because there is a 20K resistor between the 5V Vcc source of the microcontroller and the potentiometer.  I haven’t been able to verify this.

Also note that if the voltage goes higher the microcontroller appears to recalibrate.  So if you were to send 2V on the middle wire, the microcontroller will decide that this is the new high point.  You can probably use just about any voltage range that you want to hack the whammy, though I haven’t experimented with the limits of this…

Effects Pedal

The pedal connection is a phone jack of all things.  Internally, two wires run out to it – it’s really just a button with a signal and input wire just like the other buttons. If you short these wires together – “press” the button – the Xbox interprets it as a right shoulder button press (or possibly right D-pad).  The Guitar Hero games, however, seem to completely ignore it.  I tested “pressing” the effects pedal button during song playback and during star power activation in GH2, GH3, and GHWT and never got any noticeable response.  Whatever this pedal is meant to do, the functionality doesn’t appear to be built into the video games themselves yet.

Voltage

The guitar runs on 5V from USB.  In my experimentation I’ve found this to be a very stable source that can provide way more current than the guitar needs.  I wouldn’t run a blender off it, but it probably has 250 mA or more to spare.  USB is rated to provide up to 500 mA (though the long cable might limit that to something lower), and the guitar doesn’t need much of that.

Tips

A few (hopefully) helpful points to remember if you mod a Guitar Hero controller

• Most people who have modded the Guitar Hero controllers use a PC-based solution – the timing, etc, happens on the PC side, and whatever they embed in the controller just receives instructions and presses the buttons.  This is a much easier approach than embedding the entire circuit in the guitar.  It’s kind of a sissy approach, but your mom will still be impressed.
• If you do embed a microcontroller in the guitar, use a crystal oscillator to clock your microcontroller or it will all end in tears.
• If you do embed a microcontroller, you have to store your songs somewhere.  I recommend an external EEPROM.  You’ll also need a way to get songs onto whatever external memory you use.
• Optocouplers, analog switches, and possibly MOSFET transistors can be used to “press” buttons, as described above.
• Timing is incredibly important.  If for some reason you “lose” 1/100th of a second every second, by the end of a song you’re 3 seconds off and missing every note.  Design around this fact from the very beginning.

Summary

So that’s everything I’ve gathered from playing around inside the Xplorer.  If you find this information useful in making your own mod, or if you think I’ve missed something, please post a comment or e-mail me.

Here’s some random GH controller mods I’ve stumbled on around the net.

• Guitar Zero – this is my mod, records at half speed in practice mode, plays back at full speed
• Ultimate Guitar Bot – me again, a bot with every song from every game built into it
• DaveyBot – Arduino that works in conjunction with a PC and video camera to automatically hit notes
• Ambient Light Sensor GH Bot – this one uses ambient light sensors set close to the television screen
• Guitar Hero Autowhammy – this is for the PS2 controller, but the whammy works the same in the 360 Xplorer
• Wireless GH controller in a Box – apparently with plans to have it automatically play songs too…
• RockBots – controls all of the Rockband instruments simultaneously.

Mostly I intend for this to be a place I can just post about things I’m working on, so that I can say “well here, I wrote a little about it, I’ll send you a link”.

So the posts won’t necessarily follow a specific theme. Some of it might be very technical, some will probably just be pictures and videos. All of it will be interesting to those of you who like to take things apart, put things together, and understand how the world works. Hopefully.