This is the second of two features by Scott Mackie on the MIDI interface - his introduction and guide to building your own MIDI interface were contained in AMPLINEX 006.

MIDI Performance Code for AMPLE

Scott Mackie

Having, I hope, constructed your MIDI interface and got it running, you can now start on the code needed to make AMPLE run as a MIDI expander.

The 'Xpander' code comes as two parts: an assembler i/o section and an AMPLE handling routine. This has the benefits of machine code speed and AMPLE flexibility. I originally wrote the code entirely in AMPLE but it was really too slow to use properly, and resulted in arpeggios on chordal work - nice effect, but pretty unusable!

Although the assembler routine has its limitations (it slows down a bit after more than 5 notes are pressed simultaneously) it is much more efficient than AMPLE. Chordal work is still slightly slurred but the overall performance is much better.

The code is positioned in memory at &900 and &D00, with buffers at &A00 and &C00 (which unfortunately will corrupt the Staff editor - sorry!). At &D00 is the interrupt code which loads the data from the 6850 (the chip at the 'core' of the MIDI interface) into a circular buffer and updates a pointer. It also 'echoes' the data to the MIDI Out to simulate a MIDI Thru. There is a very small propagation delay, but this almost unnoticable.

The code at &900 is the data handler. It 'chases' the interrupt routine around the loop, reading the data back out and updating the output pointer accordingly.

This method has the benefit of not missing any data, but the performance can be slowed slightly under heavy data input. The buffer size is a complete page, i.e. 256 bytes, which should be more than enough - if it isn't, you're either Rick Wakeman or playing with the system exclusive dump on the synthesiser!

After reading the buffer, the assembler code interprets the data and stores it accordingly. I use the Econet workspace (&90 to &9F) as variable space, so I'm afraid if the system is to be used on Econet some rewrites may be needed.

The workspace is configured as:

&90: Input pointer. Where the latest input data is in the buffer. Updated by the interrupt routine.

&91: Output pointer. Where the program has got to in the buffer. Updated by the foreground program.

&92: ID byte for the following data 0: Noteon/off 1: Pitchbend 2: Patch change

&93: <ID dependant data> &94: <ID dependant data> &95: Voice to be used for current event &96: Blank &97: . : Voice assignment data held here. . : 128 indicates unused voice &9F:

The assembler routine also provides voice allocation routines for AMPLE, including a keysplit system. When a note is pressed, the code goes to a lookup table at &C80, which contains the details of the currently setup keysplit. The code finds the current zone the key pressed is in and then allocates the voice accordingly. This system allows multi-timbral (i.e. using more than one instrument) music to be played across the entire range of the keyboard.

When a free voice is found for the note to be played on, the note number is placed in the table between &97 and &9F for future reference. A value of 128 indicates that the voice is clear. When a Noteoff is issued, the code checks the table for the note number and places a 128 in the voice location it finds, freeing that voice for future use.

A simple wrap-around system operates so that if the number of notes played in any one zone exceeds the maximum allowed, the overspill notes are played on the first voice of the split. This compromise seems to be the best solution to a rather grey area of synthesiser programming.

Having completed all the data preparation, the assembler routine returns to AMPLE, where the header block is checked and the relevant routines called. The notes are played using the ACT command, and a rest is played for a Noteoff. This allows envelopes such as Swell and Soft to complete.

If required, the code will release a channel to be used again, without issuing a rest. This is achieved by use of the MNOTEOFF command. OFF MNOTEOFF stops Noteoffs issuing rests and is very useful with envelopes that actually tail away to zero, as the sound is more continuous with no rests being issued.

Upright, in particular, is very effective like this and can be played much like a normal piano. A foot pedal can be used to trigger this, connected to the fire button for Joystick 1 on the Analogue port. A simple push-to-make footswitch will do, and the code will detect its depression and act accordingly (see the 'help!' information in the actual program about this).

Right, having waded your way through all that information, how do you use the code?

Having loaded the file F.Xpander, try the following:

RUN

The disc drive should run and load in the file 'F.Xcode'. Set the transmit channel on your synthesiser to channel 1 and enable its MIDI output if required. Pressing a few keys on the synthesiser should now result in AMPLE playing Upright at the right pitch.

If this doesn't work, check that the interface is paged into the right position in memory. The details about this are in the assembler listing file 'F.Xsource' which is included on this disc.

Also included in the 'Xpander' program is an AMPLE word called 'test' that will print out all the data arriving at the MIDI port. This should help with debugging if there's a problem. With luck, the code will work and the fun can start!

Holding the SHIFT key down while pressing a note on the master keyboard should take you back to the AMPLE prompt. The command 'RUN' is intelligent and checks to see if the NMI code is still present. If not, the code will boot in the NMI routines again from disc. If any problem should occur, just press BREAK and type 'RUN' again. This should cure any minor problems (especially if a disc is accessed, as this will overwrite the MIDI interrupt code).

Any sound can be used with the keyboard, just by defining the maximum number of MIDI voices, i.e.

4 MSINGLE viola4

will provide 4-note polyphony with a 4-channel viola sound.

Changing the MIDI receive channel is easy. All that you have to do is type, for example,

6 MCHAN

to set the interface to channel 6. The channel is defaulted to 1 initially.

The MIDI interface also accepts velocity information so the sounds produced will be responsive to velocity data. I haven't tried this feature yet as I can't afford a velocity-sensitive keyboard, but I hope it will work!

Moving the pitch bend wheel on your synthesiser should result in AMPLE changing the pitch of the sound. Incidentally, there's no reason why the pitch bend wheel should cause the pitch to change. It could alter the stereo position, volume, or voice parameters if required. Be experimental with the AMPLE code!

Issuing a patch change from your synthesiser should cause AMPLE to select a new sound for the voices. Edit the word 'Mpatchc' to suit your own tastes and sounds. The word is set up at the moment to provide a general selection of patches.

The last topic to be covered is key splits. All key splits do is to allow different instruments to be used depending on where the note pressed is on the keyboard. Up to 8 instrument zones can be defined, but within the confines of 8 notes of polyphony. For example, you can have a split of 2+6, but not 1+2+6 because this means having to use 9 voices, exceeding the internal limit for AMPLE. The two commands to drive the key split definition process are MSPLIT and KEYSPLIT.

If you type

MSPLIT

the screen will clear and you will be prompted for the number of zones to be used across the keyboard. Having typed this in, you will then be prompted for the number of notes to be used in zone 1 (which is the lowest zone in the keyboard). The code will then wait for you to press the key on the MIDI keyboard that indicates the top of the zone. This definition process will continue until all the zones have been defined.

When MSPLIT finishes, it calls KEYSPLIT and prints out a list of numbers. This sequence of numbers is the input to the routine KEYSPLIT. This is the raw (very!) routine for processing splits. If that exact key split setup is needed again then the string of numbers output can be used to call KEYSPLIT, without having to go through the process again. The words mix1, mix2 and mix3 all illustrate this technique and should be studied in order to fully understand this topic.

A complete listing of all the words used is included in the AMPLE file 'F.Xpander'. Just type 'help!' to get the information.

And now for what the code doesn't do! The code will not allow you to play along with existing music in AMPLE, although I am working on that. I'm afraid this is due to the need for a quick response time in the input routine (the program loops in the assembler domain to save time jumping between AMPLE and the code). It also forbids use of Echo for, I presume, the same reason. Maybe some AMPLINEX members can advise me on this aspect of the code.

Apart from these things, the code does run reasonably reliably and doesn't seem to be prone to leaving 'hanging' notes.

I hope these articles have provided some AMPLINEX members with enough material to experiment with MIDI. The basic code works well, but changes can be made to it to allow further MIDI data to be processed, such as modulation or aftertouch. Any comments on the code or queries could be sent to AMPLINEX or, if preferred, to myself at the address below.

Scott Mackie 48 Milford East Kilbride GLASGOW G75 9BU

Note: An error was spotted in the previous article with reference to the AMPLE hardware paging addresses. It does actually map into the whole of the &FD page, between page numbers &30 and &3F and not &FD30 and &FD3F as stated.

Related files on this disc:

F.Xpander - 'Xpander' AMPLE program

F.Xcode - 'Xpander' machine code

F.Xsource - assembler source for the 'Xpander' machine code (in *EXEC format)