As you may or may not know, aside from computers, I'm also into music.
I play electric guitar... Where there are basically two camps.
Most guitarists still live in the 50s, and use very basic equipment, with very little technology.
Then there are people like me, who have a background in the digital world, who like to apply modern day technology to music aswell.

I personally have a digital effect unit, with midi input and output, and I use a Marshall tube amplifier with midi input.
By hooking them up together, I can have the Marshall amp switch to a pre-programmed channel when I switch to a new preset on my effect unit.
Even though my amp is already pretty old (from 1992), such a midi interface is by no means standard on a guitar amp, even today.
Most amps do have switching capabilities, but they generally support only a simple footpedal. Only a handful of amps have midi onboard.

I looked around for external midi modules, that would take the place of a footpedal. They do exist, but there are only a few suppliers and they are fairly expensive. I figured it wouldn't be that hard to build one myself, with a cheap microcontroller and a few extra components, to allow for midi input/output, and to replace the swithing that a standard footswitch would normally do.

A colleague of mine will assist me in designing the hardware. I will write the PC-side software myself, and I hope to be able to write the bulk of the microcontroller code myself aswell.

Some other ideas that I would like to implement, once the basic MIDI functionality is in place are servo-controlled pots, and a series of effect-loops, switched via midi commands.

I'll post my progress here, and I intend to publish the schematics and sourcecode, so if people are interested, they can build their own MIDI interface and modify it to suit their needs.
Posted on 2009-03-30 08:51:57 by Scali
Nice :)
What servo-pots will you be using? (I'd like to get some to play with). I found only

If you'll have PC-side software, then LPT or rs232 are way easier and faster to implement. My first midi-keyboard used no midi HW at all, it was controlled via LPT and x86 software was sending relevant data to a KMD that broadcast midi events. Though, 1ms latency couldn't be guaranteed all the time.
Posted on 2009-03-30 23:34:46 by Ultrano
Well, it will be more of attaching a servo to a regular pot, via a flexible shaft.
Something like this:

So basically you upgrade a simple analog device to digital control. Then you can add realtime control, or add memory to the settings.
Proper MIDI is crucial for this project, because I want to control this unit via standard MIDI devices, such as my effect processor. I want the microcontroller to respond when the effect processor sends MIDI commands.

Since MIDI is very similar to RS232, I can use a microcontroller with a built-in RS232 port. Basically all you need to do is make it run at a custom bitrate of 31.25 KHz, which most microcontrollers are capable of (they generally just use a divider to generate the baudrate from a standard clock input). Then you need to add a few extra parts to convert the electric signal (MIDI uses a current-loop link with opto-isolators), and your RS232 port can input and output MIDI signals :)
Sounds simple, and I hope it is :)
Posted on 2009-03-31 02:38:36 by Scali
It is :)

Well, though the servo will be a bit harder to make optimized, I guess. Controlling the step-motor will have to be done asynchronously with some nifty logic, if the motor has trouble stepping into the required 7-bit pot-value (otherwise it could end-up doing ping-pong between two steps). Or maybe it is hard only for me to do logic in PIC uCs.
Posted on 2009-03-31 10:38:41 by Ultrano
I've tried to create a formal list of requirements, to give the project some structure and vision:

MIDI-controlled project



- The device will be relatively cheap (eg < 100 euros).
- The device will use mainly standard, easily available components.
- The device will be easy to assemble.
- The device will be easy to program via a PC.


- The device will be able to send and receive MIDI messages.
- The device will have a memory to store settings, with settings linked to MIDI programs.
- The settings can be retrieved via a MIDI program change command.
- There will be a button to store the current settings to the current MIDI program memory.

(Amp Gizmo functionality)
- The device will have a set of relay switches, which can be connected to for example the footpedal input of an amplifier (we can start with 4 to 8 relays for a first version).
- The status of the relay switches can be stored and retrieved from memory.
- For each switch, a led will indicate the status of the switch.
- For each switch, there will be a button to toggle the status.

The next requirements are optional, for future revisions:
('Third hand' functionality)
- There will be a set of servo's, controlled via a DAC. The servo's can be controlled via MIDI commands, eg a midi footpedal controller (we can start with perhaps 3 or 4 servo's).
- The servo's can be attached to the shaft of a potentiometer via a flexible rod. This allows the servo's to drive the settings of an amp or effect in a digital way.
- The current position of the servo's can be stored and retrieved from memory.

(Effectloop functionality)
- There will be a set of effectloops (serial, audio send and return), which can be controlled via MIDI commands (send signal through loop, or bypass). This allows you to create a chain of effect units, where you can conditionally turn effects on or off by sending a signal through them, or bypassing them in the chain.
- The order of the effectloops in the chain can be modified (eg, instead of just having 1 -> 2 -> 3 -> 4, it should be possible to also route something like 4 -> 2 -> 1 -> 3. Not sure how difficult this is to implement).
- The status of the effectloops can be stored and retrieved from memory.

(Generic MIDI interface)
- The device can be connected to a PC (via RS232 or perhaps USB), and by installing the appropriate driver, the device will act like a regular MIDI interface to the PC, with standard MIDI input and output functionality exposed to the OS.
Posted on 2009-04-09 06:58:35 by Scali