ARDUINO = GRduino

Started by FreeTime, May 02, 2011, 06:27:16 AM

Previous topic - Next topic

0 Members and 1 Guest are viewing this topic.

FreeTime

This is a good way to add an ext ctl pedal and maybe add some completely zany physical midi control to our new earcandy. Its going to take some browsweat but with a few dollars and some effort it can be used for anything MIDI.

First, let me introduce you to my little friend ,the 'AVR Microcontroller'. What is it and what does it do you ask ? Well, its pretty tiny and it controls things. All kinds of things, like your GR55 for example. How does it do this ? By telling it how to behave depending on input conditions. Unconditionally, relentless, it will do what you ask no matter how ridiculous, sometimes to great fanfare, sometimes not so much. The beauty is that its usually repeatable.

         Input ---> Do something with it ---> Output

Lets have a closer look. There are many flavours of microcontrollers out there, some faster, some smaller , some with built in fu-fu valves, some are so top secret they sand off the chip markings! Not unlike our beloved GR55 its all about price point. Speaking of price point, you can be the proud owner of your very own microcontroller for as little as $6 , a suitable one for our application will cost about $20. Since our task doesnt require 'Tianhe-1A' class processing power lets have a look at the 'Atmega 328'.

atmel.com/dyn/resources/prod_documents/8271S.pdf

For our intents and purpose its going to come in the flavour of an 'arduino'. This mean the grunt work has been done for us, no timig diagrams, R/C/L networks or differential calculus required. We are artists and want to create after all, not worry about bootloaders.

So more on the care and feeding of an arduino. This critter requires a source of power, for testing purposes USB works, but in the field an external wall wart power supply will work, even a 9V battery will keep it alive for quite a few hours, the 328 is built for low power consumption. It also requires an input. By input I mean a variable voltage between zero and five volts. How do we get this voltage ? Use your imagination. We can get it from light intensity, motion, position, how about that lightbeam/handwavy thing you see on a few high end synths, anything we can measure, like oh say maybe pedal position. Later I'll talk about 3 ways to do this. Next we have to do something with this information. This is where programming comes into the picture, this is easier than it sounds because there is literally a small army at your disposal, myself included, and a library of tutorials available for your free perusal. Also, the software to program the arduino is open source, most starving musicians like free. So now we have a hypothetical position number (yes, well get to how to get that number in a bit), now what. We will simply translate it into something the '55 understands. Again, the hard work has been done for us, on the hardware end of things its as simple as cutting a MIDI cable in half, soldering on a resistor, and connecting 3 wires to the arduino. Done.

INPUT

If you havent clicked out of this thread yet lets talk about Input for a while. I come from a background in Instrumentation, and let me tell you there isnt much you cant measure and represent in some discrete value. In our case we want to measure pedal position. The simplest way would be to mechanically couple a potentiometer (pot) to the pedal via a rack/pinion affair. Next in line might be a mechanical barrier connected to a pedal that gradually covers a light sensor which has a LED shining on it. My favorite way so far , and the way I built mine, was to use a gravity detector. No, this did not come from Roswell NM, nor did it tear into my music budget. I picked it up at a nameless store for under $30 in the form of a Wii nunchuk. Did I mention its wireless ? Here is the chain of events : I look at tilt of the nunchuk whether its forward/ backward tilt or side to side tilt ,each axis has its own CC number (if you dont know what a CC number is dont worry, for now think of it as a knob you can turn and you can assign that know to whatever you want, its minimum value is 0 and its maximum value is 127, so when the nunchuk is rotated fully forward itll spit out a 0, fully backwards is 127, and horizontal around 63). What to do with the nunchuk ? Stick it on the head of your guitar. Stick it on your shoe. Give it to your better half to wave around while youre playing. Ok great, so we have a number, now what ? Anything you want ! Tremolo rate, chorus depth, harmonies, all controllable in real time as if you were fiddling with knobs. If you're fiddling with knobs onstage you havent done your homework. How about effects delay time ... as you bring the guitar neck up vertically, the delay time increases, at the same time a forward tilt brings on a wash of infinite repeats ,as you return to normal playing position you are back at your original values. How about its on your shoe. Foot position affects Q and resonance/frequency. A virtual Wah pedal that goes with you. Did I mention its wireless ? Rock on yeah !!

I posted a primer on how a pot works here https://www.vguitarforums.com/smf/index.php?topic=3815.0. So what does the arduino do with it ? It takes the analog voltage from the wiper and using a Analog to Digital converter turns it into a number between 0 and 1023 depending on position. This is much better resolution than we need for MIDI which is 0 to 127 for the CC numbers. Later well see some slick ways of converting these to numbers we can use in the 'programming' section. On the microcontroller that we're using we have 6 of these available,so in theory we could have 6 pedals, but who would want that.
Another method of input to the arduino is the 'I2C' bus. Also known as the 'single wire bus', those of us with an understanding of MIDI will see that its much the same: several devices share the same bus (fancy way of saying they're connected to the same wires), each device has a unique ID, that's how our microcontroller can tell where the data is coming from. I2C is not obscure, all kinds of modern (2011) devices use it, GPS, accellerometers, gyros, alphanumeric LCDs, etc. It also makes wiring MUCH easier ( 4 wires per device)
To close off this section,we can use all kinds of things for input, the limit of your imagination is the boundary. If you have any ideas please don't be afraid to post them.

Tomorrow I'll talk about programming and give some examples, which even though it sounds painful is actually quite fun. Ok I lied, its painful, but its a good pain, sort of like working out. OK, I lied again , there is no good pain. Take it for what it is, but the more you put in the more you get out. My initial program worked, but it was crude, after spending a few hours with it I have it working quite well with damping, averaging and filtering getting rid of the annoying clicks that would happen from time to time, im not afraid to use this live onstage to wow the audience with the marriage of technology, body english and magic.

FreeTime

#1
It's hard to convey in two pages what some people spend a lifetime learning, its been my experience that you have to be aware of some basics, the rest can be gleaned from the internet and looking at examples of specific problems. When we say programming we usually think software, but the ulterior motive of any bit of code is to get our hardware to do something useful. I've seen such vastly different programming styles concurrently used on the same system,even though all the programs would perform the same functions. Is there a right way ? Well much like there is a right way for you to get up, go to the store, get an orange, come home and eat that orange there are as many ways to do it right. Are you walking or driving ? Do you have enough money for an orange ? Does the guy at the store speak english ?. With programming we usually have to be quite specific. One thing I've noticed about all programming languages is that they are very similar to each other. They all add, divide, move numbers around. What makes one different from the next is the dialect, the way the language is spoken,  also customs are a bit different between languages. One language might freak out if you don't declare a variable, the next doesn't care. So why have so many languages ? Simply put, some languages are better at data communication, while the next is awesome at being more  like spoken language.Ultimately all programming languages get turned into machine code that the microcontroller can understand. Once you learn to speak the language it becomes quite easy; the nice thing is that there are only a few dozen words to learn, and ultimately can be gratifying. Much as that orange tasted that much sweeter because the shopkeep only spoke tuk-ta-yuk-tan and through much gesturing and articulation you were able to get the fruit of your labor home and enjoy it, when you reload your program for the nth time and it finally works there is a  feeling that the hard work was worth it.
Earlier I mentioned something about some basics about programming. Although they apply to some other languages as well, these are arduino specific.

1) Libraries. Some of the work has been done for you. Much like you can go to the library and get a book of tabs so you don't have to figure out the individual notes off a record, libraries are available that take the gruntwork out of doing some things. They are much like a popmachine, I don't care what happens between putting in a coin and gettnig my pop, so long as it happens. Of course if you prefer you can reinvent the popmachine, but libraries are a great tool. There are all kinds, LCD libraries for talking to displays, there is a 'Wire' library for talking to L2C devices,  there is even a MIDI library, the list goes on.

2) Declare. Before we can do things to our numbers the arduino wants to know about them. Are they whole numbers, do they have decimals or are they letters ? Depending on how you're going to use your data, it can be as simple as putting 'int A = 5' into your program to let it know that you want to put an integer with a value of 5 into a box called 'A'.

3) Conditions. This is where computers shine. They can compare data. Easiest implementation is the 'if' statement. You can check for a few conditions: whether something is equal or not, greater than, less than. For example,If some condition is true then do something.

4) CountingFOR loops. These count up/ down from some value to another value. If I had to do something 10 times I'd probably use a FOR loop. Both 3 and 4 are called Control Structures.

5) Interrupts. Although its a hardware feature, sometimes you might want to stop things no matter what. This is where interrupts come in. For example, MIDI note OFF might be sent when an interrupt happens. This is a physical button being pressed.

6)REM. No sleeping while programming! Remark everything you do; when you're stuck, things make more sense when you can read them, unless you're a real nerd and read code better than english. Even if that's the case, REM it for the next guy when your'e filesharing. If there is a particularly hard spot you can REM it and come back to it later. A descriptive REM statement allows you to write code from your REMarks.They dont use up space on your arduino so go mad.


As far as the Arduino IDE goes, it doesn't get much simpler. You download and install a program( from the arduino.cc website), plug a USB cable into the arduino and you're in business,ready to have the microcontroller do your bidding.The stuff you type into the IDE is loosely based on C, a common programming language. Once you've put your program into the arduino it starts running. Remove power, it stops. Come back 20 years later (up to 100), apply power, and your program starts running again.
You can get numbers back from the arduino over a terminal, some of the dial up crowd might remember them. It works well, before your arduino becomes a stand alone unit this is where you do your debugging and see real world numbers from your inputs and processed data. Of course you can directly effect the output pins, or as in our case, send MIDI data.

The program itself can be broken into three main part : structure, values, and functions. , void SETUP and void LOOP are structures. Hey wait, whats a void ? Wiki says ' A completely empty space '. So we might say ' a void is a blank slate where we can put stuff. You can make your own voids and put whatever you like into them.For example, void SETUP will have all the things that only have to happen once when you turn on your microcontroller. '#define MIDI_BAUD_RATE 31250' is one thing you might find in void SETUP.Just to make things confusing some things do get declared outside of void SETUP, we'll look at that more in the actual program.
Inside of  void LOOP is where the magic happens. This is where you look at the instantaneous value of an input, manipulate it, and send it back out, then go around for the next one.You might  wait for something to happen, do something a predetermined number of times. This is where the '55s missing arpeggiator lives, providing you're happy with an external synth. The loop is continuous, when it reaches the end of your program it starts again right after the 'void LOOP' statement.

Without any further ado, our first program :

// A program to read a potentiometer and send its position as a midi CC value
// In order to send a CC message via MIDI we have to send a set of 3  numbers
// These numbers are 176,xx,yy where xx is the control number and yy is the value
// Since things happen fast we have to build in a delay 

int Ain1 = 0;              // we need one variable of type integer
int wait = 50;             // and another int for a delay

void setup( ) {            // lets define what needs to happen at powerup
  Serial.begin(31250);     // starting Midi I/O on the arduino comm port
}

void loop( ) {                // on with the actual program
  int Ain1 = analogRead(A0);  // grab the value from the 1st Analog in channel and put it into Ain1
  Ain1 = map(Ain1, 0, 1023, 0, 127); // map the pot min/max values to midi cc min/max
  Serial.print(176,BYTE);     // 176 = CC command
  Serial.print(16,BYTE);      // 16 = First general purpose controler thats assignable
  Serial.print(Ain1,BYTE);    // pot position
  delay (wait);               // dont flood the midi port, wait 50 milliseconds
 
}


You can see the program starts off with a rem statement to let you know what the intentions are. You can tell its a remark because the line starts with a  '// '. Then we get a couple of variables of type integer ready. In the arduino integers are treated as a 16 bit number, or 2 bytes. There are over a dozen datatypes if you look, even void is a datatype. We're going to meet another one right away.
Next comes our setup. There you see that we set the comm port to 31.250 kHz, the frequency that MIDI devices communicate at. If we were going to talk to a terminal (the computer window where we can see live arduino information ) we could set that number to 9600 or 115000, whatever your terminal is set to.
analogRead(A0) is how the software talks to the first physical analog in pin, a voltage between 0 and 5 volts will producea a number between 0 and 1023 in 'Ain1'.
Have a close look at the next line: Ain1 = map(Ain1, 0, 1023, 0, 127). Since our input value is between 0 and 1023 and our midi CC min/max is 0 and 127 we do some math to our number to scale it properly, putting that variable back into itself.
The next three lines is where the magic happens and our data gets dumped into the MIDI cable. Serial.print is a routine that 'prints' data to the comm port. Notice that after the number to print there is a 'BYTE', this is a datatype that is 8 bits long. If we were to send an 'int' down the wire our device would be confused because a total of 2 bytes would get transmitted. Ah but wait ! I declared 'Ain1' as a type 'int' in the beginning. What happened to the other byte ? In this case, because we explicidly said we wanted to send a byte the number would be truncated. Since we re-mapped the incoming number to a max of 127 it fits into an 8 bit number.
The last thing our program does is wait for 250 millisecond, which happens to be a quarter second, before going around to grab another number and do it all again.
There are many improvements that could be made to our program, for example instead of sending a constant stream of numbers you could check to see if the number changed before sending it, you might want to implement your CC messages in such a way that as you turn the pot through 12 o'clock the messages get sent to the next controller number; its as creative as your imagination. Of course to fill that gap between imagination and implementation is the hard part, much like playing a difficult song.
Earlier I talked about program dialect. If you look at the program you will see that every statement ends in a ';'. This is Arduinoese and must be so. Also look at the voids. Notice that each one has brackets right after it, followed by an open brace, the code, and then a closing brace. If you were going to make your own void it might look something like 'void SOMETHING () { a bit of code goes here; }. Note the semicolon after the statement, then the closing brace.
I hope this section has been useful to you, I urge you get yourself an arduino so you can have a kick at the cat yourself, it can do so much more, who know what you can do around the home.

check back for how to physically connect the arduino and some I/O considerations. Its going to be a few days max, unexpected company.

FreeTime

#2
Technically the physical connection is a network layer if we were to consider midi a type of networking. This connection looks like this :



Note  there is a black ground wire, a blue signal wire and a red power wire. The power wire is connected in series with a component called a 'resistor'. You might notice some color bands around the resistor, in this case red-red-brown. These bands represent the resistance value of the resistor.You start reading the value from the closest band to the edge. The third band is the number of zeroes. Brown represents 1, Red is 2. So to reading the value of this resistor we get 2, another 2, and one zero, or 220 ohms. This resistor limits current. Its as simple as that to get a midi signal out of the arduino and into your midi device.

If we were to add midi input, the circuit would be a bit different; we'd have to make use of a device called an optoisolator, which performs the function of electrically isolating the input. This serves two functions, it eliminates ground loops and also prevents high voltage from getting into your equipment.

Elantric

#3
Thanks for sharing these ideas Freetime!

Perhaps we could define a set of VGuitar Accessories based on the Arduino and create some worthwhile hardware options we can all add to our tool chest.

more here:
http://arduino.cc/en/Tutorial/Midi



Meanwhile, For those who can not solder:

===http://www.sourceaudio.net/products/hothand/midi_exp.php


http://www.sourceaudio.net/products/hothand/wireless_adapter.php


The Hot Hand MIDI-EXP controller takes all of the expressive potential of the Hot Hand sensor and enables use with third-party effects, hardware, and software by converting the Hot Hand signals directly to MIDI and a flexible expression output. With the MIDI-EXP, users can select from multiple MIDI message types, including continuous controllers, pitch wheel, aftertouch, note on/off message, etc. Other controls fine tune the sensor signals to create the desired response with controls like depth, smoothing, inversion and axis select. A useful Ramp Trigger mode lets the user set a threshold and when that threshold is crossed by the sensor signal, it will generate a ramp in the output.

The Hot Hand MIDI-EXP Controller is available to U.S. customers exclusively through the Source Audio Online Store. If you are a non-U.S. customer and would like to purchase the MIDI-EXP controller, please contact us.
Hot Hand MIDI-EXP Interface

Roll your mouse over the panel controls to learn about each one.
Hot Hand MIDI-EXP Features & Specifications

    * Selectable MIDI message types: Continuous Controller, Pitch Wheel, Channel Aftertouch, Note On/Off.
    * Flexible digital resistor expression output with Tip/Ring switch.
    * Ramp Trigger modes for ramping MIDI messages or expression out when the Hot Hand sensor crosses a set threshold.
    * Adjustable start and stop points as well as speed of the ramp.
    * X and Y axes can be set to send separate MIDI messages simultaneously.
    * Depth, Smoothing, and Invert controls for fine tuning the Hot Hand signals.
    * Save and Recall with 8 preset locations.
    * Familiar foot pedal design with enable/disable footswitch.
    * 9V DC power supply included.
    * Dimensions: 7 in./17.8cm (length not including I/O jacks) x 4 in./10.2cm (width) x 2 in./5cm (height, including knobs).



gumtown

COOL !! I like this thread, it reminds me that i a have a few PIC Micro projects kicking around in my garage (some where).

One is a home brew midi EXP pedal using only a pic16F84A micro,
I have mastered using a digital input to read an analog value by reading the discharge rate of a capacitor, varied by the changing load of the EXP pedal pot.

The other project i made was a pitch to midi converter, again using a simple pic16F84A micro and a quad opamp, the opamp changed the monophonic analog signal to square wave, and the micro measured the cycle gap time and sent midi note & on/off data (no velocity), which seemed to be surprisingly very acurate.

 
Free "GR-55 FloorBoard" editor software from https://sourceforge.net/projects/grfloorboard/

Elantric

Lets consider an open source project - I may be co-erced into contributing some PCB design for an ARRAY of boards. Perhaps a Main PCB with option riser boards, to create the best mix of swiching, Buffering, Hex break out I/O, ADAT optical I/O, Ethernet AVB I/O, MADI I/O.



(forgive me  - perhaps I'm just dreaming  a bit too much, or gone mad!  . . . . .

big_jan

No Elantric, you are steps ahead and because of your talents all these are possible. Many amongst us here are not blessed with skills, we await production, we can only add bit by bit some tools we could only dream of.

It is time consuming and projects like you mentioned are noble. So here's a little push from me. Maybe the rest of the gang can chip in. Hopefully most of us will be able to afford it. I love switches and controls. Now time to play music and wait for your good news!

FreeTime

#7
Quote from: gumtown on May 04, 2011, 08:46:57 PM

The other project i made was a pitch to midi converter, again using a simple pic16F84A micro and a quad opamp, the opamp changed the monophonic analog signal to square wave, and the micro measured the cycle gap time and sent midi note & on/off data (no velocity), which seemed to be surprisingly very acurate.



I wonder if you were to average or RMS the individual signals before the opamp, and compare them to a min/max for velocity data. Did the micro keep up ?

Elantric


MCK

What a great thread. Before life took a twist for me and I stopped spending as much time here I was jumping in the pool with similar thoughts. I think an easy place to start is the Sparkfun MidiShields + an Arduino Uno. Its quick and easy to get a prototype going which is the whole essence behind the Arduino movement. Once you are on a stable ground with regards to functionality / code you can then look to getting one of the Arduino boards with additional PCB space where you can move your additional circuitry so you do away with the bread-board. For most applications you wouldn't even need to build your own PCB as long as you accept a slighly bulky end-result. Look at the Missing Link video on YouTube. They had a real nice start with off the shelf Arduino h/w and then moved on to commercializing through a more integrated PCB (I'm guessing this part as I have not yet seen my Missing Link). So anyways, lets get the ball rolling and it will go places.

FreeTime

The Mega would be nice for a project with a 40x4 LCD display and several knobs in an enclosure. That puts it over $150 right there. Also the mega can be hard to get. But with 16 analog ins (pot) and 54 Digital I/O along with 4 comm ports (nice!) and 256k ram its pretty powerful.
While you could still put a display on the 328 based one, its strength lies in a tiny footprint, depending on your input method (wireless) it can be about the size of a Pez container. (something that would plug into your midi port). You get 8 analog ins, 14 Digital I/O and 1 comm port with 32k of ram.

I wonder where they run out of steam, 16 mhz with an 8 bit bus, driving a display and a bunch of LEDs while processing 16 channels of input might get to be too much, mind you one of my early computers ran at 0.9mhz and did midi just fine while running an editor program.

gumtown

#11
Quote from: FreeTime on May 06, 2011, 01:09:06 AM
#define int Ain1 = Analog I/O port 0;           
#define int wait = 50;           
void setup( ) {           
                    Serial.begin(31250);   
                   }
void loop( )
{
    int old_value = Ain1;   
    int Ain1 = analogRead(A0); 
    if(old_value != Ain1)   //if the pot position has changed then send midi cc# data, when the old pot position value is not equal to the newly read pot value                               
                                {  Serial.print(176,BYTE);   
                                    Serial.print(16,BYTE);     
                                    Serial.print(Ain1,BYTE);   
                                    delay (wait);   
                                 };         
}
Just needs a minor change as highlighted in blue, to only send midi data if there is pedal movement, or else flood the midi port with continuous pedal cc# data.

Quote from: FreeTime on May 06, 2011, 01:09:06 AM
The Mega would be nice for a project with a 40x4 LCD display and several knobs in an enclosure. That puts it over $150 right there. Also the mega can be hard to get. But with 16 analog ins (pot) and 54 Digital I/O along with 4 comm ports (nice!) and 256k ram its pretty powerful.
While you could still put a display on the 328 based one, its strength lies in a tiny footprint, depending on your input method (wireless) it can be about the size of a Pez container. (something that would plug into your midi port). You get 8 analog ins, 14 Digital I/O and 1 comm port with 32k of ram.

I wonder where they run out of steam, 16 mhz with an 8 bit bus, driving a display and a bunch of LEDs while processing 16 channels of input might get to be too much, mind you one of my early computers ran at 0.9mhz and did midi just fine while running an editor program.
Those micro's are like high reving two stroke engines, where a PC type processor might use 4~8 cycles to process a long complex instruction, while short instruction micro's do the same in one clock cycle.
I use a lowly 4Mhz pic16F84 to run my homemade wireless intelligent lighting system, in 1k of memory i have it running a 2 x 16 lcd display, 6 footswitches, 5 menu buttons, and 2 inputs from audio filters to input 'the groove' and calculate interesting lighting scenes from audio input. Controlling lighting banks each with 8 lights, 4 strobes and 2 gobos via 800Mhz radio modules.

If you look at what is inside the GT-10 for example, a dual 32bit micro running at around 60Mhz, won't be too far away when we will be building in cosm modeling and effects into our own foot controller projects.

I still program in assembly language on the pic micro's.
Free "GR-55 FloorBoard" editor software from https://sourceforge.net/projects/grfloorboard/

FreeTime

If anyone wants to try their hand at a microcontroller HAD posted a good link here :

http://tronixstuff.wordpress.com/tutorials/

MCK

Interesting development ... Google Launches Android Open Accessory Development Kit Based On Arduino -

http://arduino.cc/blog/2011/05/10/google-launches-android-open-accessory-development-kit-based-on-arduino/

This could open up some new opportunities to an Arduino based development effort for front-end UI offerings on the Android platform.

FreeTime

#14
Quote from: MCK on May 10, 2011, 01:50:56 PM
Google Launches Android Open Accessory Development Kit Based On Arduino -

The USB host is nice ! and based on the mega means lots of I/O.

Update: Some people like $5 pots, some people like $10 pots. This Dev board is selling for $400 !!!

FreeTime

#15
This is shipping as of may 21st 2011:

http://www.digilentinc.com/Products/Detail.cfm?NavPath=2,719,895&Prod=CHIPKIT-MAX32

I think I have enough left on my pre-paid credit card that I use for inet purchases. For those that like schematics have a look at the attachment.

mooncaine

Moonie's mind is boggled. I'm gonna need a week or three to grok all this... but it looks excitin'.

Elantric

#17
Touchsound Podcast (right click and save it here:



Episode #01 of the Touch Sound Podcast is here! We discuss WWDC and Google IO and what it means for mobile music production,  plus we talk about the upcoming Horizon Synth, FL Studio Mobile and we speculate about Native Instruments on iOS and so much more. Also we interview our special guest Rolf Wöhrmann of Tempo Rubato, creator of the powerful NLog Synths for iPhone, iPad and Mac OSX.
http://touchsoundpodcast.com
20minutes in they have a discussion of the Android / Arduino platform - interesting at 27 minutes in they mention the added audio latency of most Android platform devices compared to IOS devices.



MCK

A nice new shield that might be of use to this project :

http://blog.makezine.com/archive/2011/06/in-the-maker-shed-64-button-shield.html

QuoteThe 64 Button Shield not only allows you to use up to 64 buttons with your next Arduino project, it also has a hidden "easter egg" that allows it to output MIDI. [Linked] video demonstrates MIDI functionality by using a 64 Button Shield, a Midivox, and an Arduino together for use as a physical interface for your favorite MIDI compatible music program.


mooncaine

This summer I was very fortunate to have the opportunity to attend SIGGRAPH in Vancouver. There, I encountered the groovy members of the Vancouver hackspace, who had set up tables of hands-on, learn-by-doing activities. I learned the basics of soldering components to a circuit board.

I also saw an Arduino or two, and I learned about the MIDI "Shield" that can be attached to it. I got the sense that I could get one of these going, with help from Arduino MIDI aficionados online, even though I'm not much of a programmer. I'm getting the hang of soldering, though.

I also bought some more sensors from iCubeX while I was there, and got to meet Axel Mulder of Infusion Systems. Since SIGGRAPH, I bought myself a soldering station and some other tools, and I've spent a weekend practicing basics, like splicing wires.

I took all the electronics out of my wooden Steinberger GT-PRO, leaving just the external Roland GK, and began cramming iCubeX sensors into and on it. When the weather turns cold here, I'll have something to do: wire them all up to the iCubeX brain with my new soldering skills.

After that, if I managed not to burn anything up, I'll want to try this Arduino thingamajig as a brain for a pitch-bending controller.

So... thanks again for starting this thread! I feel less boggled and more like it's a manageable task now (though surely not simple). I also hope the experience of doing this might lead me to install my own internal GK pickup kit.