STYLOPHONE MIDI CONTROLLER

A good choice is an Arduino compatible board, as you can download free software for programming it and there are loads of projects out there to try. Here I am using a Miduino board (http://tomscarff.110mb.com/miduino/miduino.htm). This as a couple of special adaptations for MIDI and also makes a nice general purpose Arduino clone, but any Arduino or compatible clone will do for this project.

OK, first we need to get into the guts of the Stylophone and hook up some wires that will allow us to hijack its keyboard. Mine is an "original" 1980s one which is pretty easy to take apart, just be careful not to break any wires or bend components... I've not seen inside the "reissue" Stylophone but I guess its much the same.

You need to attach a wire to the point (Connection 4) at which the stylus joins the PCB - this is the brown wire in my pictures - and a wire to the "bottom" of the keyboard (Connection 1) - this is the orange wire in my pics.

Now you need to attach a wire to the top end of the keyboard (Connection 2).. on my Stylophone this joins to the synthesiser circuitry and I thought the circuitry between this point and the stylus might cause problems.. especially when putting a voltage across the keyboard.. so I cut the PCB track at this point and added a wire (Connection 3) to the other side of the break so that the wires can be joined together to play the Stylophone normally. The pic does not show the break too well.. it is on the track which joins Connections 2 and 3... the top one of the pair of tracks there. I scraped a break with a small screwdriver.

Now reassemble everything. Connect the wires from Connection 1 and Connection 2 to GND and +5V output of the Microcontroller board and connect the wire coming from Connection 4 to one of the analog input pins of the Microcontroller board.

One additional thing is that we need to add a "pull up" resistor to our analog input. Without this, the voltage coming from the stylus will be changing randomly all over the place and will give us all kinds of false readings when the stylus is not touching the keypad.

I added a 1 Megaohm resistor, which I placed between the analog input and the +5V power pin. The idea is that when the stylus is not touching the keyboard, it will be "pulled up" to 5 volts through the resistor, so we will read a predictable value for "stylus not touching keyboard" but when we do touch the keyboard, the resistor has sufficiently high resistance to not affect the voltage we pick up from the keyboard. Its a crazy plan but it just works...

Here is the Microcontroller board with the wires and resistor in place. On my board the analog inputs are marked A0, A1 etc (I am using A0) and the power outputs are marked +5V and GND. My board has header pins sticking out the bottom so I can pop it in a breadboard for easy tinkering!

Note that for now the wire from Connection 3 is not connected to anything. The Stylophone should be switched off and does not even require a battery for this.

void setup(){
  Serial.begin(9600);
}
void loop(){
  int a = analogRead(0);   
  delay(100);
  Serial.println(a);
}

To see the output from the program (with the serial cable connected to the board), open Arduino's Serial Monitor window using the toolbar button

Ensure that 9600 baud is selected. Touch the stylus to each keypad in turn and note the value that is shown

You will see the values vary a bit, but try to get an "average" value of each note. You shoudl find the values across the keyboard range from 0 at the bottom to something like 1000 at the top. When the stylus is not touching the keyboard you should see a value around 1020.

Make a note of the value for each note, and then edit the following Arduino program to use your values (which might be different to mine). The numbers you need to change are in the scale array...

#define LedPin 13

// MIDI Functions from Tom Scarff's MIDIUNO projects

// Send a MIDI note-on message. 
void noteOn(byte channel, byte note, byte velocity) {
  midiMsg( (0x90 | channel), note, velocity);
}

// Send a MIDI note-off message.
void noteOff(byte channel, byte note, byte velocity) {
  midiMsg( (0x80 | channel), note, velocity);
}

// Send a general MIDI message
void midiMsg(byte cmd, byte data1, byte data2) {
  digitalWrite(LedPin,HIGH);  // indicate we're sending MIDI data
  Serial.print(cmd, BYTE);
  Serial.print(data1, BYTE);
  Serial.print(data2, BYTE);
  digitalWrite(LedPin,LOW);
}

#define NOTES 21
#define MIDI_A 45
#define MIDI_CHANNEL 1
#define MIDI_VELOCITY 127

int scale[NOTES] = { 
/*A*/    0,          // THESE ARE THE NUMBERS TO EDIT!!
/*A#*/   175,
/*B*/    312,
/*C*/    441,
/*C#*/   544,
/*D*/    622,
/*D#*/   689,
/*E*/    746,
/*F*/    795,
/*F#*/   833,
/*G*/    867,
/*G#*/   895,
/*A*/    918,
/*A#*/   938,
/*B*/    954,
/*C*/    968,
/*C#*/   977,
/*D*/    987,
/*D#*/   994,
/*E*/    1001,
/*X*/    1010        // X IS "STYLUS NOT ON KEYBOARD"
};

int getNote(int input)
{
    for(int i = 0; i < NOTES; ++i)
    {
      int lo = 0;
      int hi = 1024;
      if(i>0)
      {
        lo = (scale[i-1] + scale[i]) / 2;
      }
      if(i<NOTES-1)
      {
        hi = (scale[i] + scale[i+1]) / 2;
      }
      if(input >=lo && input <=hi)
      {
        if(i==NOTES-1)
          return -1;
        return MIDI_A+i;
      }
    }
    return -1;
}

void setup(){
  pinMode(LedPin,OUTPUT);
  Serial.begin(31250);   // set MIDI baud rate
  Serial.flush();
  delay(200);
}
int lastNote = -1; // -1 is used to mean "no note"
void loop(){
 
  // read voltage
  int a = analogRead(0);   
 
  // convert to MIDI note
  int n = getNote(a);
 
  // different to last time?
  if(n!=lastNote)
  {
    // any note to turn off?
    if(lastNote != -1)
      noteOff(MIDI_CHANNEL,lastNote,MIDI_VELOCITY);
     
    // any note to turn on?
    if(n != -1)
      noteOn(MIDI_CHANNEL,n,MIDI_VELOCITY);
     
    // remember where we are
    lastNote = n;
  }
}

You can change the values of MIDI_CHANNEL and MIDI_VELOCITY. MIDI_A is the bottom note value (for the low A on the stylophone). You can shift octaves by adding or subtracting multiples of 12.

Now take the other ends of the wire and connect them to the serial port OUTPUT of your Arduino board (My Miduino board has a dedicated MIDI out header, but this duplicates the serial output)

Compile and upload the above program to your board (disconnect any MIDI hardware first... the serial interface is shared with MIDI a lot of non-MIDI garbage goes out during program uploads... this has a tendency to crash most MIDI software!)

Once the upload is complete you should see the pin 13 diagnostic LED flash when you touch notes on the Stylophone.. this indicates outgoing MIDI traffic. If you use a program like MIDI-OX (http://www.midiox.com/) you should be able to see the MIDI events (if you can't, first thing to try is to reverse the wires of your MIDI out connection in case you have them back to front)

Now connect up your favorite soft syth or sound module and enjoy!!

To get your Stylophone back in working order you need to join the wires from Connection 2 and Connection 3 together. I've put a 3.5mm stereo jack socket on mine to run the 3-wire Arduino connection (when you pull the plug out the connection to restore working order is made automatically)