A Midi Library for Pascal

By Kirk Austin, MacTutor Contributing Editor, Austin Development, San Rafael, CA

What is MIDI?

Before I get too much into the nuts and bolts of this whole thing perhaps we should take a look at what it’s all about. MIDI is an acronym for Musical Instrument Digital Interface, and really came into being somewhere around 1983. Originally, it was created to allow music synthesizers to communicate with each other, but there was enough foresight in the minds of the originators to leave room for future enhancements. As far as the scope of this article is concerned, the most important thing about MIDI is that it allows music synthesizers to communicate with computers, specifically, the Macintosh.

The need for a standard

To really understand why MIDI came about, you have to know a little bit about the history of music synthesizers. In the late 1960’s synthesizers were, for the most part, voltage controlled devices. That is, you could control the frequency of an oscillator (a tone generating device) by varying a DC voltage that was routed to one of its control inputs. The higher the voltage, the higher the note and vice versa. The standard that was used by companies like Moog and ARP was 1 volt/octave. This meant that if your control voltage changed from 4 volts to 5 volts the oscillator would shift its pitch higher by one octave.

This “voltage control” concept worked pretty well at the time, but you have to remember that the hardware itself was pretty primitive by today’s standards. For instance, most synthesizers in that era could only play one note at a time. Chords could only be created by using a multitrack tape recorder and overdubbing the different notes. This was how recordings like “Switched On Bach” were produced.

Now, when you’re only dealing with a note at a time things aren’t too complicated. Still, you had to make sure all of your oscillators were in tune, because typically you would have to use more than one oscillator to produce a respectable sounding note. Then all of the oscillators would have to be scaled so that they would track accurately. These last two points were no small problem, because the analog oscillators at that time had a very large problem -- thermal drift. This meant that you could tune and scale all of the oscillators very carefully, and 5 minutes later they would be out of calibration because the temperature of the semiconductor junctions had changed. Ahh, those were fun days.

But, those problems aside, there were other signals that were needed to produce a note besides just a control voltage for the oscillator. You also needed a trigger pulse to tell the synthesizer when to start playing a note. Then you needed a way to let the synthesizer know that you wanted to stop a note when you lifted your finger from the keyboard. This was usually in the form of a “gate” signal. Okay, so now we’re up to three signals just to produce one note at a time. Then, as if that weren’t enough, some manufacturers were using a positive going pulse as the trigger and others were using a negative going pulse. You could get around this problem with special adaptor boxes and the like, but then a much larger problem came looming over the horizon -- polyphony.

Polyphony means the ability to play more than one note at a time, and even though it was a tremendous breakthrough for the musician, it multiplied the problems for electronic musical instrument designers. Now, to the best of my knowledge, the polyphonic synthesizer keyboard that we know and love today came into being around 1978 thanks to the advent of the microprocessor and the talents of a couple of guys named Dave Rossum and Scott Wedge of Emu Systems. Their ideas led to the use of microprocessor based keyboards by virtually all of the synthesizer manufacturers. Oberheim was one of the first companies to bring out a polyphonic instrument. It had a keyboard that was scanned by the microprocessor which then converted the information into DC control voltages and gate signals for controlling its analog oscillators, filters, and amplifiers. The amazing thing about this instrument was that it actually worked, and it provided a great leap forward for synthesizers in general. But, now another problem began to appear.

Musicians wanted to have a remote keyboard controller that could be worn around their neck and send signals down a cable to their synthesizers which might be offstage somewhere. Or maybe they didn’t want a keyboard at all! Maybe they wanted to control a synthesizer from a guitar or a drum set! Instrument designers were really starting to get overwhelmed by all of the options that musicians were demanding at this point, and it became clear that there was a need for some kind of standard way for controllers (keyboards, guitars, drums) and synthesizers (the sound producing electronics) to communicate with each other so that instruments made by different manufacturers could work together.

MIDI is born

In late 1981 a paper was presented to the Audio Engineering Society suggesting a digital, serial interface for electronic music synthesizers. This scheme was referred to as the Universal Synthesizer Interface, and was authored by Dave Smith and Chet Wood of Sequential Circuits. This proposal was, in fact, the precursor to MIDI, and served as the impetus to get manufacturers of electronic musical equipment to talk with each other about some sort of communications standard. What finally came out of all of the discussions was the MIDI specification 1.0.

The data not the sound

Now, probably the most confusing thing about MIDI to the beginner is understanding that MIDI is concerned with control data, and not the actual sound itself. For instance, if we talk about a MIDI recorder that emulates many of the functions of a traditional tape recorder you must understand that the MIDI information that is being recorded is simply the note on and note off signals. When a key is pressed on a synthesizer keyboard 3 bytes of MIDI information are sent over the serial connection telling the sound producing electronics to start playing a note (the details of these 3 bytes will be explained shortly). When that same key is finally released another 3 bytes of information is sent over the MIDI cable telling the sound producing electronics to stop playing that note. As you can readily conclude from this simple example, a note of any length requires the same amount of information -- 6 bytes. This is what makes for such compact use of memory in MIDI recorders. By comparison, actually recording the sound itself by an analog to digital conversion would take tens of thousands of bytes even for a very short sound, and a longer sound would require more memory still. But, even more importantly, the use of MIDI control signals allows musicians to factor out the actual sound from the note choices and timing information. This means that I can play a part on a piano-style keyboard, record it on a MIDI recorder, and then play it back with the ability to change the actual sound as it is playing. So now what I recorded as a piano sound can be played back as a trumpet sound, or a violin sound, or a marimba sound. This is what gives tremendous power to MIDI recorders. A musician can enter in all of the notes without prior knowledge of what the final arrangement is going to be, then change instruments on the fly to help with the decision making process that is necessary to create a final arrangement. In this regard, the MIDI recorder is to the traditional tape recorder as the Word Processor is to the typewriter. It is a powerful tool that goes far beyond emulating its traditional counterpart.

The command set

Here are a few of the more common MIDI commands that are used to control synthesizers. For a copy of the full specification (which is much longer than this article allows), write to:

International MIDI User’s Group

8426 Vine Valley Dr.

Sun Valley, CA 91352

Note on

This is the data that is sent when a key goes down on a synthesizer keyboard.

 %1001nnnn
 Where nnnn is the MIDI Channel Number (0-15)
 %0kkkkkkk
 Where kkkkkkk is the Key Number (0-127) 60 = middle C
 %0vvvvvvv
 Where vvvvvvv is the velocity

Note off

This is the data that is sent when a key is released on a

synthesizer keyboard.

 %1000nnnn
 Where nnnn is the MIDI Channel Number (0-15)
 %0kkkkkkk
 Where kkkkkkk is the Key Number (0-127) 60 = middle C
 %0vvvvvvv
 Where vvvvvvv is the velocity

All notes off

This is a useful command that is typically sent when a sequence is terminated before the end of the file. This command turns off all of the notes that are playing to avoid the disastrous problem of “stuck notes” (what happens when a note on command is not followed by a corresponding note off command).

%1011nnnn
 Where nnnn is the MIDI Channel Number (0-15)
 %01111011
 %00000000

Aftertouch

This is the data that is sent when pressure is applied to the synthesizer keyboard while the key is being held down.

 %1101nnnn
 Where nnnn is the MIDI Channel Number (0-15)
 %0vvvvvvv
 Where vvvvvvv is the amount of aftertouch

Program change

This command changes the current sound that the synthesizer is playing.

 %1100nnnn
 Where nnnn is the MIDI Channel Number (0-15)
 0ppppppp
 Where ppppppp is the Program Change Number (0-127)

Pitch Wheel

This is the data that is sent when the pitch bend wheel on a synthesizer is moved from its center position.

 %1110nnnn
 Where nnnn is the MIDI Channel Number (0-15)
 %0vvvvvvv
 Where vvvvvvv is the LSB of the Pitch Wheel Change
 %0vvvvvvv
 Where vvvvvvv is the MSB of the Pitch Wheel Change

Continuous controllers

These are generalized controllers that could correspond to knobs on a particular synthesizer. Continuous controller #1 is the Modulation Wheel by default.

 %1011nnnn
 Where nnnn is the MIDI Channel Number (0-15)
 %0ccccccc
 Where ccccccc is the control number (0-121)
 %0vvvvvvv
 Where vvvvvvv is the control value

The serial ports

The Macintosh serial ports were not really constructed with MIDI in mind, unfortunately, but you can make them work by using a few special techniques that we’ll talk about now.

Hardware

The outputs of the Mac serial ports have to be level shifted and translated to a standard TTL gate output in order to meet the MIDI spec. The inputs have to be optoisolated. If you want a quick and dirty schematic of the necessary hardware check MacTutor’s October 1985 issue, or The Best of MacTutor, volume 1.

Software

The timing of MIDI information is one of the more difficult demands that the Macintosh has to deal with. I mean, it doesn’t really matter if your spreadsheet calculates a formula in 2 seconds or 2.02 seconds, but that much difference in a musical performance is totally unacceptable. In order for the information to be processed as quickly as possible we have to use interrupts to handle tasks like transmitting and receiving bytes of MIDI data, and updating the timing reference.

Time-Stamping

Now, just sending and receiving bytes of MIDI information is just fine for a lot of applications, but typically you want to not only get the incoming data, but also know when it arrived. This is necessary for applications like recorders where you log the time that the data came in so you can play it back with the correct timing. Sounds simple huh? Well, it is and it isn’t. For one thing, in order to accurately record the time you have to use a technique called “time-stamping”, and you have to do it on an interrupt level. That is, when the interrupt routine is called because the SCC chip has a byte that has just arrived at the Mac, the routine not only has to get that byte from the SCC chip and place it in a buffer area, but it also has to get a counter value (that has been set up previously) and tag it onto the incoming MIDI byte. Then when it’s time to play the data back the counter is started up and you sit there and watch the counter for each byte of information to be sent out at the appropriate time (this is a really crude example involving no data compression).

Okay, not to difficult, but it gets more complicated. To set up a counter that you can use to reference all of this stuff to you have to use one of the timers in the 6522 chip. There are two timers, appropriately called timer1 and timer2. Unfortunately, timer1 is the most accurate timer to use if you want to create continuous interrupts at a specified time interval (the interval we will be using will be in the millisecond range). This is because timer1 automatically reloads itself after it times out. Timer2 requires that your interrupt routine reload it after it times out, and you never know how long it is going to take before your interrupt routine can respond to a timer2 interrupt. Now, if your timing doesn’t have to be that accurate you can go ahead and use timer2, in fact, this is the way that the Time Manager routines in Inside Macintosh vol. 4 appear to work. So, you can simply use the Time Manager routines if you find that to be easier, and aren’t that concerned with absolute timing accuracy.

The reason that you might want to use timer2 it that timer1 is used by the Sound Manager routines, so if you are using timer1 for time-stamping incoming MIDI data you can’t use any of the Sound Manager routines, you have to write to the sound hardware directly in order to produce a click track or whatever. Anyway, that’s the tradeoff. I have written the following code using timer1 since you can simply ignore it if you want to use the Time Manager routines and everything will be fine. If you want to use timer1 call InitTimer at the beginning of your application, and QuitTimer at the end of it. Conversely, if you don’t want to use it don’t call either of those routines (or any of the other timer/counter routines).

Overview

Okay, here’s how you go about using these routines for MIDI software. Now, let me say in advance that I know you’re not supposed to write data to your own code segments, but I did it this way because alot of people complained about the use of (A5) variables in the November 1985 MacTutor article. In a future article I’ll present another way to do MIDI that doesn’t use the approach I’m using here, but for now, this should get you going since the problems won’t appear until the Macintosh II starts using the memory management chip.

Initialization

When your application starts up it should call InitSCCA and/or InitSCCB depending on whether you are going to use one or both channels (A is the modem port, B is the printer port). If you are going to use the counter then you should also call InitTimer when your application starts up.

Receiving data

To receive a MIDI byte call RxMIDIA or RxMIDIB depending on which port you are using. When you call these routines you must leave space on the stack for a longword result. The MIDI byte is in the lower 8 bits of the longword, and the upper 3 bytes contain the value of the counter when the byte arrived at the SCC chip.

Transmitting data

To send a byte of MIDI data use the routines TxMIDIA or TxMIDIB depending on which port you want to use. To use these routines simply place a word on the stack with the MIDI byte in the lower 8 bits and call the appropriate routine.

The Counter

To set the counter to a value of 1 call StartTimer. The value of 1 is used instead of 0 because the 0 value is used as a special flag. You should know that the counter value defaults to 1 when your application starts up.

To get the current value of the counter call GetCounter. This routine requires that you leave space on the stack for a longword result. The longword contains the counter value.

UNIT LSPMIDI;

INTERFACE
 PROCEDURE InitSCCA;
 {call this once at the beginning of your application if} 
 {you are going to use the modem port for MIDI}

 PROCEDURE TxMIDIA (TheData : integer);
 {use this procedure to transmit a byte of MIDI data }
 {through the modem port the MIDI byte is in the }
 {lower 8 bits of the word}

 FUNCTION RxMIDIA : LongInt;
 {use this function to get a byte of MIDI data and} 
 {the counter value associated}
 {with that byte through the modem port}
 {the MIDI byte is in the lower 8 bits of the longword}
 {the upper 3 bytes of the longword contain the counter }
 {value when the byte arrived at the Macintosh}

 PROCEDURE ResetSCCA;
 {call this procedure when your application is done if} 
 {you called InitSCCA at the beginning of your }
 {application or the system will crash}

 PROCEDURE InitSCCB;
 {call this once at the beginning of your application} 
 {if you are going to use the printer port for MIDI}

 PROCEDURE TxMIDIB (TheData : integer);
 {use this procedure to transmit a byte of MIDI data}
 {through the printer port the MIDI byte is in the lower }
 {8 bits of the word}

 FUNCTION RxMIDIB : LongInt;
 {use this function to get a byte of MIDI data and} 
 {the counter value associated}
 {with that byte through the printer port}
 {the MIDI byte is in the lower 8 bits of the longword}
 {the upper 3 bytes of the longword contain the counter}
 {value when the byte arrived at the Macintosh}

 PROCEDURE ResetSCCB;
 {call this procedure when your application is done }
 {if you called InitSCCB at the beginning of your}
 {application or the system will crash}

 PROCEDURE InitTimer (TimrValue : integer);
 {call this procedure once at the beginning of your}     {application 
if you are going to}
 {make use of time-stamping.  1 millisecond = decimal 782}

 PROCEDURE LoadTimer (TimrValue : integer);
 {call this procedure if you want to change the} 
 {interval of time that the counter}
 {is incremented.  1 millisecond = decimal 782}

 PROCEDURE StartCounter;
 {call this procedure to set the counter value to 1}

 FUNCTION GetCounter : LongInt;
 {call this function to get the current value} 
 {of the counter}

 PROCEDURE QuitTimer;
 {call this procedure when your application is done}
 {if you called InitTimer at}
 {the beginning of your application or the system }
 {will crash}

IMPLEMENTATION
{$A+}
 PROCEDURE InitSCCA;
 external;
 PROCEDURE TxMIDIA;
 external;
 FUNCTION RxMIDIA;
 external;
 PROCEDURE ResetSCCA;
 external;
 PROCEDURE InitSCCB;
 external;
 PROCEDURE TxMIDIB;
 external;
 FUNCTION RxMIDIB;
 external;
 PROCEDURE ResetSCCB;
 external;
 PROCEDURE InitTimer;
 external;
 PROCEDURE LoadTimer;
 external;
 PROCEDURE StartCounter;
 external;
 FUNCTION GetCounter;
 external;
 PROCEDURE QuitTimer;
 external;
{$A-}

END.

; Low Level MIDI routines with time-stamping
; Written by Kirk Austin 5/17/87
; This code is in the public domain and is absolutely free
; Note: Be sure and turn off range checking in LS Pascal
;       to prevent a crash. 

; Serial Chip equates
SCCRd   EQU $1D8
SCCWr   EQU $1DC
aData   EQU 6
aCtl    EQU 2
bData   EQU 4
bCtl    EQU 0
TBEEQU  2

;  Interrupt vector equates
Lvl1DT  EQU $192
Lvl2DT  EQU $1B2
RxIntOffsetAEQU  24
TxIntOffsetAEQU  16
SpecRecCondAEQU  28
RxIntOffsetBEQU  8
TxIntOffsetBEQU  0
SpecRecCondBEQU  12

;  6522 equates
VIAEQU  $1D4
vT1C    EQU $800
vT1CH   EQU $A00
vT1L    EQU $C00
vACR    EQU $1600
vIER    EQU $1C00

; XDEF all routines that need to be accessed externally.

 XDEF   InitSCCA
 XDEF   InitSCCB
 XDEF   TxMIDIA
 XDEF   TxMIDIB
 XDEF   RxMIDIA
 XDEF   RxMIDIB
 XDEF   ResetSCCA
 XDEF   ResetSCCB
 XDEF   InitTimer
 XDEF   LoadTimer
 XDEF   StartCounter
 XDEF   GetCounter
 XDEF   QuitTimer

; These are the routines for the Modem Port


;PROCEDURE InitSCCA;
; Call this routine at the beginning of your application if 
; using the modem port for MIDI information transfers.
InitSCCA
 MOVE   SR,-(SP) ; Save interrupts
 MOVEM.LD0/A0-A2,-(SP)  ; Save registers
 ORI    #$0300,SR; Disable interrupts

 MOVE.L SCCRd,A1 ; Get base Read address
 ADD    #aCtl,A1 ; Add offset for control
 MOVE.B (A1),D0  ; Dummy read
 MOVE.L (SP),(SP); Delay
 MOVE.L SCCWr,A0 ; Get base Write address
 ADD    #aCtl,A0 ; Add offset for control
 MOVE.B #9,(A0)  ; pointer for SCC reg 9
 MOVE.L (SP),(SP); Delay
 MOVE.B #%10000000,(A0) ; Reset channel
 MOVE.L (SP),(SP); Delay
 BSR    InitSCCChan; branch to common init routine

; set up the interrupt vectors

 MOVE.L #Lvl2DT,A0 ; get dispatch table ptr
 MOVE   #RxIntOffsetA,D0  ; get offset to Rx vector
 LEA    PRxIntHandA,A1  ; point to previous vector stor
 MOVE.L 0(A0,D0),(A1); save previous int vector
 LEA    RxIntHandA,A1; set Rx vector
 MOVE.L A1,0(A0,D0)
 MOVE   #TxIntOffsetA,D0  ; get offset to Tx vector
 LEA    PTxIntHandA,A1  ; point to previous vector stor
 MOVE.L 0(A0,D0),(A1); save previous int vector
 LEA    TxIntHandA,A1; set Tx vector
 MOVE.L A1,0(A0,D0)
 MOVE   #SpecRecCondA,D0  ; offset to Special vector
 LEA    StubA,A1
 MOVE.L A1,0(A0,D0)

; initialize the flags & pointers

 LEA    RxByteInA,A2 ; get the address
 CLR    (A2)
 LEA    RxByteOutA,A2; get the address
 CLR    (A2)
 LEA    RxQEmptyA,A2 ; get the address
 MOVE #$FFFF,(A2)
 LEA    TxByteInA,A2 ; get the address
 CLR    (A2)
 LEA    TxByteOutA,A2; get the address
 CLR    (A2)
 LEA    TxQEmptyA,A2 ; get the address
 MOVE #$FFFF,(A2)

 MOVEM.L(SP)+,D0/A0-A2  ; Restore registers
 MOVE   (SP)+,SR ; Restore interrupts
 RTS    ; and return

; This is the common initialzation routine for both channels

InitSCCChan
 MOVE.B #4,(A0)  ; pointer for SCC reg 4
 MOVE.L (SP),(SP); Delay
 MOVE.B #%10000100,(A0) ; 32x clock, 1 stop bit
 MOVE.L (SP),(SP); Delay
 MOVE.B #1,(A0)  ; pointer for SCC reg 1
 MOVE.L (SP),(SP); Delay
 MOVE.B #%00000000,(A0) ; No W/Req
 MOVE.L (SP),(SP); Delay
 MOVE.B #3,(A0)  ; pointer for SCC reg 3
 MOVE.L (SP),(SP); Delay
 MOVE.B #%00000000,(A0) ; Turn off Rx
 MOVE.L (SP),(SP); Delay
 MOVE.B #5,(A0)  ; pointer for SCC reg 5
 MOVE.L (SP),(SP); Delay
 MOVE.B #%00000000,(A0) ; Turn off Tx
 MOVE.L (SP),(SP); Delay
 MOVE.B #11,(A0) ; pointer for SCC reg 11
 MOVE.L (SP),(SP); Delay
 MOVE.B #%00101000,(A0) ; Make TRxC clock source
 MOVE.L (SP),(SP); Delay
 MOVE.B #14,(A0) ; pointer for SCC reg 14
 MOVE.L (SP),(SP); Delay
 MOVE.B #%00000000,(A0) ; Disable BRGen
 MOVE.L (SP),(SP); Delay
 MOVE.B #3,(A0)  ; pointer for SCC reg 3
 MOVE.L (SP),(SP); Delay
 MOVE.B #%11000001,(A0) ; Enable Rx
 MOVE.L (SP),(SP); Delay
 MOVE.B #5,(A0)  ; pointer for SCC reg 5
 MOVE.L (SP),(SP); Delay
 MOVE.B #%01101010,(A0) ; Enable Tx and drivers
 MOVE.L (SP),(SP); Delay
 MOVE.B #15,(A0) ; pointer for SCC reg 15
 MOVE.L (SP),(SP); Delay
 MOVE.B #%00001000,(A0) ; Enable DCD int for mouse
 MOVE.L (SP),(SP); Delay
 MOVE.B #0,(A0)  ; pointer for SCC reg 0
 MOVE.L (SP),(SP); Delay
 MOVE.B #%00010000,(A0) ; Reset EXT/STATUS
 MOVE.L (SP),(SP); Delay
 MOVE.B #0,(A0)  ; pointer for SCC reg 0
 MOVE.L (SP),(SP); Delay
 MOVE.B #%00010000,(A0) ; Reset EXT/STATUS again
 MOVE.L (SP),(SP); Delay
 MOVE.B #1,(A0)  ; pointer for SCC reg 1
 MOVE.L (SP),(SP); Delay
 MOVE.B #%00010011,(A0) ; Enable interrupts
 MOVE.L (SP),(SP); Delay
 MOVE.B #9,(A0)  ; pointer for SCC reg 9
 MOVE.L (SP),(SP); Delay
 MOVE.B #%00001010,(A0) ; Set master int enable
 MOVE.L (SP),(SP); Delay
 RTS
 
;PROCEDURE TxMIDIA (TheData : integer);
; This is the routine to transmit a MIDI byte of data
; through the Modem Port.To use this routine place 
; the byte to be transmitted as the lower 8 bits
; of a word on the stack, then call TxMIDIA.
TxMIDIA
 LINK   A6,#0    ; set frame pointer
 MOVE   SR,-(SP) ; Save interrupts
 MOVEM.LD0/A0-A3,-(SP)  ; Save registers
 ORI    #$0300,SR; Disable interrupts

 LEA    TxQEmptyA,A3 ; get the address
 TST.B  (A3); is TxQueue empty?
 BNE    TxQEA    ; if so branch
 LEA    TxByteInA,A3 ; get the address
 MOVE   (A3),D0  ; if not add byte to queue
 LEA    TxQueueA,A2; point to queue
 MOVE.B 9(A6),0(A2,D0)  ; place byte in queue
 ADDQ   #1,D0    ; update TxByteIn
 CMP    #$100,D0
 BNE    @1
 MOVE   #0,D0
@1 MOVE D0,(A3)
 BRA    TxExitA  ; and exit
 
TxQEA 
 MOVE.L SCCRd,A0 ; get SCC Read Address
 MOVE.L SCCWr,A1 ; get SCC Write address
 MOVE   #aCtl,D0 ; get index for Ctl
 BTST.B #TBE,0(A0,D0); transmit buffer empty?
 BNE    FirstByteA ; if so branch
 LEA    TxByteInA,A3 ; get the address
 MOVE   (A3),D0  ; if not add to queue
 LEA    TxQueueA,A2; point to queue
 MOVE.B 9(A6),0(A2,D0)  ; place byte in queue
 ADDQ   #1,D0    ; update pointer
 CMP    #$100,D0
 BNE    @1
 MOVE   #0,D0
@1 MOVE D0,(A3)
 LEA    TxQEmptyA,A3 ; get the address
 MOVE   #0,(A3)  ; reset queue empty flag
 BRA    TxExitA  ; and exit
 
FirstByteA
 MOVE   #aData,D0; get index to data
 MOVE.L (SP),(SP); delay
 MOVE.B 9(A6),0(A1,D0)  ; write data to SCC
 MOVE.L (SP),(SP); Delay
 

TxExitA 
 MOVEM.L(SP)+,D0/A0-A3  ; Restore registers
 MOVE   (SP)+,SR ; Restore interrupts
 UNLK   A6; release frame pointer
 MOVE.L (SP)+,A1 ; save return address
 ADD.L  #2,SP    ; move past data word
 MOVE.L A1,-(SP) ; put address back on stack
 RTS    ; and return

;FUNCTION RxMIDIA : LongInt;
; This routine gets a byte through the modem port. 
; To use this routine treat it like a Pascal 
; function.  Leave space on the stack for a longword
; of data before calling this routine.  If the data 
; on the stack after
; the routine executes is 0 there was no MIDI data available. 
; If it’s non-0 the upper 3 bytes contain the counter 
; value, the MIDI byte is the low byte.
RxMIDIA
 LINK   A6,#0    ; set frame pointer
 MOVE   SR,-(SP) ; Save interrupts
 MOVEM.LD0-D1/A0-A3,-(SP) ; Save registers
 ORI    #$0300,SR; disable interrupts

 LEA    RxQEmptyA,A3 ; get the address
 TST.B  (A3); any data available?
 BEQ    @1; if so, branch
 MOVE.L #0,8(A6) ; if not, return with 0
 BRA    RxExitA
@1 LEA  RxByteOutA,A3; get the address
 MOVE   (A3),D0  ; get index to byte out
 LEA    RxQueueA,A2; point to queue
 MOVE.L #0,D1    ; clear data register
 MOVE.L 0(A2,D0),D1; get MIDI data
 MOVE.L D1,8(A6) ; place on stack for return 
 ADDQ   #4,D0    ; update index
 CMP    #$400,D0
 BNE    @2
 MOVE   #0,D0
@2 LEA  RxByteOutA,A3; get the address
 MOVE   D0,(A3)
 LEA    RxByteInA,A3 ; get the address
 MOVE   (A3),D1
 CMP    D0,D1    ; is queue empty?
 BNE    RxExitA  ; if not exit
 LEA    RxQEmptyA,A3 ; get the address
 MOVE   #$FFFF,(A3); if empty, set flag

RxExitA 
 MOVEM.L(SP)+,D0-D1/A0-A3 ; Restore registers
 MOVE   (SP)+,SR ; restore interrupts
 UNLK   A6
 RTS    ; and return
 
; This is the interrupt routine for receiving through
; the modem port. It places the counter value and the 
; MIDI byte in a circular queue to be
; accessed later by the application.
; When the system gets this far, A0 contains the 
; SCC base read Ctl address
; and A1 contains the SCC base write Ctl address
; for this channel.The data addresses are offset by 4 
; from the control addresses.
; D0-D3/A0-A3 are already preserved, so they may 
; be used freely.
RxIntHandA
 MOVE   SR,-(SP)
 ORI    #$0300,SR; disable interrupts

@3 MOVE #4,D0    ; get data offset
 CLR.L  D1; prepare for data
 MOVE.L (SP),(SP); Delay
 MOVE.B 0(A0,D0),D1; read data from SCC
 MOVE.L (SP),(SP); Delay
 LEA    RxQueueA,A2; point to queue
 LEA    RxByteInA,A3 ; get the address
 MOVE   (A3),D0  ; get offset to next cell
 LEA    Counter,A3 ; get the address
 MOVE.L (A3),D2  ; put counter value in D2
 LSL.L  #8,D2    ; shift counter one byte
 ADD.L  D2,D1    ; combine counter and data
 MOVE.L D1,0(A2,D0); put longword in queue
 LEA    RxQEmptyA,A3 ; get the address
 MOVE   #0,(A3)  ; reset queue empty flag
 ADDQ   #4,D0    ; update index
 CMP    #$400,D0
 BNE    @1
 MOVE   #0,D0
@1 LEA  RxByteInA,A3 ; get the address
 MOVE   D0,(A3)

@2 BTST.B #0,(A0); is there more data?
 BNE    @3; do it again if there is

 MOVE   (SP)+,SR ; enable interrupts
 RTS    ; and return
 
; This is the interrupt routine for transmitting a byte
; through the modem port.It checks to see if there 
; is any data to send, and if there is it sends it to 
; the SCC.  If there isn’t it resets the TBE interrupt 
; in the SCC and exits.
; When the system gets this far, A0 contains the SCC
; base read Ctl address and A1 contains the SCC base 
; write Ctl address for this channel.
; The data addresses are offset by 4 from the control
; addresses. D0-D3/A0-A3 are already preserved, so 
; they may be used freely.
TxIntHandA
 MOVE   SR,-(SP)
 ORI    #$0300,SR; disable interrupts
 
 LEA    TxQEmptyA,A3 ; get the address
 TST.B  (A3); Is queue empty?
 BEQ    @1; if not branch
 MOVE.B #$28,(A1); if so, reset TBE interrupt
 MOVE.L (SP),(SP); Delay
 BRA    TxIExitA ; and exit
@1 LEA  TxByteOutA,A3; get the address
 MOVE   (A3),D0  ; get index to next data byte
 LEA    TxQueueA,A2; point to queue
 MOVE   #4,D1    ; get data offset
 MOVE.B 0(A2,D0),0(A1,D1) ; write data to SCC
 MOVE.L (SP),(SP); Delay
 ADDQ   #1,D0    ; update index
 CMP    #$100,D0
 BNE    @2
 MOVE   #0,D0
@2 LEA  TxByteOutA,A3; get the address
 MOVE   D0,(A3)
 LEA    TxByteInA,A3 ; get the address
 MOVE   (A3),D1
 CMP    D0,D1    ; is TxQueue empty?
 BNE    TxIExitA ; if not exit
 LEA    TxQEmptyA,A3 ; get the address
 MOVE   #$FFFF,(A3); if empty set flag

TxIExitA
 MOVE   (SP)+,SR ; enable interrupts
 RTS    ; and return
 

;PROCEDURE ResetSCCA;
; If you called InitSCCA at the beginning of your 
; application this routine must be called when 
; the application quits or the system will
; crash due to the interrupt handling pointers 
; becoming invalid.
ResetSCCA
 MOVEM.LD0/A0-A1,-(SP)  ; save registers
 MOVE   SR,-(SP) ; Save interrupts
 ORI    #$0300,SR; Disable interrupts
 
 MOVE.L SCCWr,A0 ; Get base Write address
 ADD    #aCtl,A0 ; Add offset for control
 MOVE.B #9,(A0)  ; pointer for SCC reg 9
 MOVE.L (SP),(SP); Delay
 MOVE.B #%10000000,(A0) ; Reset channel
 MOVE.L (SP),(SP); Delay
 BSR    ResetSCCChan ; branch to common reset routine

 MOVE.L #Lvl2DT,A0 ; dispatch table pointer
 MOVE   #RxIntOffsetA,D0  ; get offset to Rx vector
 LEA    PRxIntHandA,A1  ; point to previous vector stor
 MOVE.L (A1),0(A0,D0); restore previous int vector
 MOVE   #TxIntOffsetA,D0  ; get offset to Tx vector
 LEA    PTxIntHandA,A1    ; set Rx vector
 MOVE.L (A1),0(A0,D0); restore previous int vector
 MOVE   (SP)+,SR ; Restore interrupts
 MOVEM.L(SP)+,D0/A0-A1  ; restore registers
 RTS    ; and return

; This is the common reset routine for both channels
ResetSCCChan
 MOVE.B #15,(A0) ; pointer for SCC reg 15
 MOVE.L (SP),(SP); Delay
 MOVE.B #%00001000,(A0) ; Enable DCD int
 MOVE.L (SP),(SP); Delay
 MOVE.B #0,(A0)  ; pointer for SCC reg 0
 MOVE.L (SP),(SP); Delay
 MOVE.B #%00010000,(A0) ; Reset EXT/STATUS
 MOVE.L (SP),(SP); Delay
 MOVE.B #0,(A0)  ; pointer for SCC reg 0
 MOVE.L (SP),(SP); Delay
 MOVE.B #%00010000,(A0) ; Reset EXT/STATUS again
 MOVE.L (SP),(SP); Delay
 MOVE.B #1,(A0)  ; pointer for SCC reg 1
 MOVE.L (SP),(SP); Delay
 MOVE.B #%00000001,(A0) ; Enable mouse interrupts
 MOVE.L (SP),(SP); Delay
 MOVE.B #9,(A0)  ; pointer for SCC reg 9
 MOVE.L (SP),(SP); Delay
 MOVE.B #%00001010,(A0) ; Set master int enable
 MOVE.L (SP),(SP); Delay
 RTS

TxQueueADCB.B  $100,0; this is the queue
TxQEmptyA DC0    ; the queue empty flag
TxByteInA DC0    ; index to next cell in
TxByteOutADC0    ; index to next cell out
RxQueueADCB.B  $400,0; this is the queue
RxQEmptyA DC0    ; the queue empty flag
RxByteInA DC0    ; index to next cell in
RxByteOutADC0    ; index to next cell out
PRxIntHandA DC.L 0 ; Previous interrupt vector
PTxIntHandA DC.L 0 ; Previous interrupt vector

; These are the routines for the Printer Port
;PROCEDURE InitSCCB;
; Call this routine at the beginning of your 
; application if you are going
; to be using the printer port for MIDI 
; information transfers.
InitSCCB

 MOVE   SR,-(SP) ; Save interrupts
 MOVEM.LD0/A0-A2,-(SP)  ; Save registers
 ORI    #$0300,SR; Disable interrupts
 MOVE.L SCCRd,A1 ; Get base Read address
 ADD    #bCtl,A1 ; Add offset for control
 MOVE.B (A1),D0  ; Dummy read
 MOVE.L (SP),(SP); Delay
 MOVE.L SCCWr,A0 ; Get base Write address
 ADD    #bCtl,A0 ; Add offset for control
 MOVE.B #9,(A0)  ; pointer for SCC reg 9
 MOVE.L (SP),(SP); Delay
 MOVE.B #%01000000,(A0) ; Reset channel
 MOVE.L (SP),(SP); Delay
 BSR    InitSCCChan; branch to common init routine
 
; set up the interrupt vectors

 MOVE.L #Lvl2DT,A0 ; get dispatch table pointer
 MOVE   #RxIntOffsetB,D0  ; get offset to Rx vector
 LEA    PRxIntHandB,A1  ; point to previous vector stor
 MOVE.L 0(A0,D0),(A1); save previous int vector
 LEA    RxIntHandB,A1; set Rx vector
 MOVE.L A1,0(A0,D0)
 MOVE   #TxIntOffsetB,D0  ; get offset to Tx vector
 LEA    PTxIntHandB,A1    ; set Rx vector
 MOVE.L 0(A0,D0),(A1); save previous int vector
 LEA    TxIntHandB,A1; set Tx vector
 MOVE.L A1,0(A0,D0)
 MOVE   #SpecRecCondB,D0  ; offset to Special vector
 LEA    StubB,A1
 MOVE.L A1,0(A0,D0)
 
; initialize the flags & pointers
 LEA    RxByteInB,A2 ; get the address
 CLR    (A2)
 LEA    RxByteOutB,A2; get the address
 CLR    (A2)
 LEA    RxQEmptyB,A2 ; get the address
 MOVE #$FFFF,(A2)
 LEA    TxByteInB,A2 ; get the address
 CLR    (A2)
 LEA    TxByteOutB,A2; get the address
 CLR    (A2)
 LEA    TxQEmptyB,A2 ; get the address
 MOVE #$FFFF,(A2)
 MOVEM.L(SP)+,D0/A0-A2  ; Restore registers
 MOVE (SP)+,SR   ; Restore interrupts
 RTS    ; and return

;PROCEDURE TxMIDIB (TheData : integer);
; This is the routine to transmit a MIDI byte of 
; data through the Printer Port.
; To use this routine place the byte to be transmitted 
; as the lower 8 bits
; of a word on the stack, then call TxMIDIB.
TxMIDIB
 LINK   A6,#0    ; set frame pointer
 MOVE   SR,-(SP) ; Save interrupts
 MOVEM.LD0/A0-A3,-(SP)  ; Save registers
 ORI    #$0300,SR; Disable interrupts
 LEA    TxQEmptyB,A3 ; get the address
 TST.B  (A3); is TxQueue empty?
 BNE    TxQEB    ; if so branch
 LEA    TxByteInB,A3 ; get the address
 MOVE   (A3),D0  ; if not add byte to queue
 LEA    TxQueueB,A2; point to queue
 MOVE.B 9(A6),0(A2,D0)  ; place byte in queue
 ADDQ   #1,D0    ; update TxByteIn
 CMP    #$100,D0
 BNE    @1
 MOVE   #0,D0
@1 MOVE D0,(A3)
 BRA    TxExitB  ; and exit
TxQEB 
 MOVE.L SCCRd,A0 ; get SCC Read Address
 MOVE.L SCCWr,A1 ; get SCC Write address
 MOVE   #bCtl,D0 ; get index for Ctl
 BTST.B #TBE,0(A0,D0); transmit buffer empty?
 BNE    FirstByteB ; if so branch
 LEA    TxByteInB,A3 ; get the address
 MOVE   (A3),D0  ; if not add to queue
 LEA    TxQueueB,A2; point to queue
 MOVE.B 9(A6),0(A2,D0)  ; place byte in queue
 ADDQ   #1,D0    ; update pointer
 CMP    #$100,D0
 BNE    @1
 MOVE   #0,D0
@1 MOVE D0,(A3)
 LEA    TxQEmptyB,A3 ; get the address
 MOVE   #0,(A3)  ; reset queue empty flag
 BRA    TxExitB  ; and exit
FirstByteB
 MOVE   #bData,D0; get index to data
 MOVE.L (SP),(SP); delay
 MOVE.B 9(A6),0(A1,D0)  ; write data to SCC
 MOVE.L (SP),(SP); Delay
TxExitB 
 MOVEM.L(SP)+,D0/A0-A3  ; Restore registers
 MOVE   (SP)+,SR ; Restore interrupts
 UNLK   A6; release frame pointer
 MOVE.L (SP)+,A1 ; save return address
 ADD.L  #2,SP    ; move past data word
 MOVE.L A1,-(SP) ; put address back on stack
 RTS    ; and return

;FUNCTION RxMIDIB : LongInt;
; This routine gets a byte through the printer port. 
; To use this routine treat it like a Pascal function.  
; Leave space on the stack for a longword
; of data before calling this routine.  If the 
; data on the stack after
; the routine executes is 0 there was no MIDI 
; data available.  If it’s non-0
; the upper 3 bytes contain the counter value, 
; the MIDI byte is the low byte.
RxMIDIB
 LINK   A6,#0    ; set frame pointer
 MOVE   SR,-(SP) ; Save interrupts
 MOVEM.LD0-D1/A0-A3,-(SP) ; Save registers
 ORI    #$0300,SR; disable interrupts
 LEA    RxQEmptyB,A3 ; get the address
 TST.B  (A3); any data available?
 BEQ    @1; if so, branch
 MOVE.L #0,8(A6) ; if not, return with 0
 BRA    RxExitB
@1 LEA  RxByteOutB,A3; get the address
 MOVE   (A3),D0  ; get index to byte out
 LEA    RxQueueB,A2; point to queue
 MOVE.L #0,D1    ; clear data register
 MOVE.L 0(A2,D0),D1; get MIDI data
 MOVE.L D1,8(A6) ; place it on stack for return 
 ADDQ   #4,D0    ; update index
 CMP    #$400,D0
 BNE    @2
 MOVE   #0,D0
@2 LEA  RxByteOutB,A3; get the address
 MOVE   D0,(A3)
 LEA    RxByteInB,A3 ; get the address
 MOVE   (A3),D1
 CMP    D0,D1    ; is queue empty?
 BNE    RxExitB  ; if not exit
 LEA    RxQEmptyB,A3 ; get the address
 MOVE   #$FFFF,(A3); if empty, set flag
RxExitB 
 MOVEM.L(SP)+,D0-D1/A0-A3 ; Restore registers
 MOVE   (SP)+,SR ; restore interrupts
 UNLK   A6
 RTS    ; and return
 
; This is the interrupt routine for receiving through 
; the printer port. 
; It places the counter value and the MIDI byte in a 
; circular queue to be
; accessed later by the application.
; When the system gets this far, A0 contains the 
; SCC base read Ctl address
; and A1 contains the SCC base write Ctl address 
; for this channel.
; The data addresses are offset by 4 from the 
; control addresses.
; D0-D3/A0-A3 are already preserved, so they 
; may be used freely.
RxIntHandB
 MOVE   SR,-(SP)
 ORI    #$0300,SR; disable interrupts
@3 MOVE #4,D0    ; get data offset
 CLR.L  D1; prepare for data
 MOVE.L (SP),(SP); Delay
 MOVE.B 0(A0,D0),D1; read data from SCC
 MOVE.L (SP),(SP); Delay
 LEA    RxQueueB,A2; point to queue
 LEA    RxByteInB,A3 ; get the address
 MOVE   (A3),D0  ; get offset to next cell
 LEA    Counter,A3 ; get the address
 MOVE.L (A3),D2  ; put counter value in D2
 LSL.L  #8,D2    ; shift counter one byte
 ADD.L  D2,D1    ; combine counter and data
 MOVE.L D1,0(A2,D0); put longword in queue
 LEA    RxQEmptyB,A3 ; get the address
 MOVE   #0,(A3)  ; reset queue empty flag
 ADDQ   #4,D0    ; update index
 CMP    #$400,D0
 BNE    @1
 MOVE   #0,D0
@1 LEA  RxByteInB,A3 ; get the address
 MOVE   D0,(A3)
@2 BTST.B #0,(A0); is there more data?
 BNE    @3; do it again if there is
 MOVE   (SP)+,SR ; enable interrupts
 RTS    ; and return
 
; This is the interrupt routine for transmitting 
; a byte through the printer port.
; It checks to see if there is any data to send, 
; and if there is it sends it to 
; the SCC.  If there isn’t it resets the TBE 
; interrupt in the SCC and exits.
; When the system gets this far, A0 contains 
; the SCC base read Ctl address
; and A1 contains the SCC base write Ctl address 
; for this channel.
; The data addresses are offset by 4 from the 
; control addresses.
; D0-D3/A0-A3 are already preserved, so they may 
; be used freely.
TxIntHandB
 MOVE   SR,-(SP)
 ORI    #$0300,SR; disable interrupts
 LEA    TxQEmptyB,A3 ; get the address
 TST.B  (A3); Is queue empty?
 BEQ    @1; if not branch
 MOVE.B #$28,(A1); if so, reset TBE interrupt
 MOVE.L (SP),(SP); Delay
 BRA    TxIExitB ; and exit
@1 LEA  TxByteOutB,A3; get the address
 MOVE   (A3),D0  ; get index to next data byte
 LEA    TxQueueB,A2; point to queue
 MOVE   #4,D1    ; get data offset
 MOVE.B 0(A2,D0),0(A1,D1) ; write data to SCC
 MOVE.L (SP),(SP); Delay
 ADDQ   #1,D0    ; update index
 CMP    #$100,D0
 BNE    @2
 MOVE   #0,D0
@2 LEA  TxByteOutB,A3; get the address
 MOVE   D0,(A3)
 LEA    TxByteInB,A3 ; get the address
 MOVE   (A3),D1
 CMP    D0,D1    ; is TxQueue empty?
 BNE    TxIExitB ; if not exit
 LEA    TxQEmptyB,A3 ; get the address
 MOVE   #$FFFF,(A3); if empty set flag
TxIExitB
 MOVE   (SP)+,SR ; enable interrupts
 RTS    ; and return
 
;PROCEDURE ResetSCCB;
; If you called InitSCCB at the beginning of your 
; application this
; routine must be called when the application 
; quits or the system will
; crash due to the interrupt handling pointers 
; becoming invalid.
ResetSCCB
 MOVEM.LD0/A0-A1,-(SP)  ; save registers
 MOVE   SR,-(SP) ; Save interrupts
 ORI    #$0300,SR; Disable interrupts
 MOVE.L SCCWr,A0 ; Get base Write address
 ADD    #bCtl,A0 ; Add offset for control
 MOVE.B #9,(A0)  ; pointer for SCC reg 9
 MOVE.L (SP),(SP); Delay
 MOVE.B #%01000000,(A0) ; Reset channel
 MOVE.L (SP),(SP); Delay
 BSR    ResetSCCChan ; branch to common reset routine
 MOVE.L #Lvl2DT,A0 ; get dispatch table pointer
 MOVE   #RxIntOffsetB,D0  ; get offset to Rx vector
 LEA    PRxIntHandB,A1  ; point to previous vector stor
 MOVE.L (A1),0(A0,D0); restore previous int vector
 MOVE   #TxIntOffsetB,D0  ; get offset to Tx vector
 LEA    PTxIntHandB,A1    ; set Rx vector
 MOVE.L (A1),0(A0,D0); restore previous int vector
 MOVE   (SP)+,SR ; Restore interrupts
 MOVEM.L(SP)+,D0/A0-A1  ; restore registers
 RTS    ; and return

TxQueueBDCB.B  $100,0; this is the queue
TxQEmptyB DC0    ; the queue empty flag
TxByteInB DC0    ; index to next cell in
TxByteOutBDC0    ; index to next cell out
RxQueueBDCB.B  $400,0; this is the queue
RxQEmptyB DC0    ; the queue empty flag
RxByteInB DC0    ; index to next cell in
RxByteOutBDC0    ; index to next cell out
PRxIntHandB DC.L 0 ; Previous interrupt vector
PTxIntHandB DC.L 0 ; Previous interrupt vector

; This is the space for a special condition interrupt
; routine. All I do here is reset the error flag in the SCC
; and return. When the system gets this far, A0 contains 
; the SCC base read Ctl address
; and A1 contains the SCC base write Ctl address 
; for this channel.
; The data addresses are offset by 4 from the control
; addresses. D0-D3/A0-A3 are already preserved, so 
; they may be used freely.
StubA
 ORI    #$0300,SR; Disable interrupts
 MOVE.B #%00110000,(A1) ; Reset Error
 MOVE.L (SP),(SP); Delay
 ANDI   #$F8FF,SR; Restore interrupts
 RTS
; This is the space for a special condition interrupt
; routine.All I do here is reset the error flag in
; the SCC and return. When the system gets this far, 
; A0 contains the SCC base read Ctl address
; and A1 contains the SCC base write Ctl address 
; for this channel.
; The data addresses are offset by 4 from the 
; control addresses.
; D0-D3/A0-A3 are already preserved, so they may be 
; used freely.
StubB 
 ORI    #$0300,SR; Disable interrupts
 MOVE.B #%00110000,(A1) ; Reset Error
 MOVE.L (SP),(SP); Delay
 ANDI   #$F8FF,SR; Restore interrupts
 RTS

; These are the routines for the counter you can use for 
; time-stamping the incoming MIDI data.  This is useful 
; for writing sequencer type applications.
; The time-stamping is done on an interrupt level, 
; is extremely accurate,
; and uses the VIA timer #1.  This means that you can’t 
; use any of the Sound Manager routines because they use 
; timer #1 too.  If you want to create a metronome click 
; you have to write your own code that accesses
; the sound hardware directly without using timer #1.
; InitTimer and LoadTimer expect a word on the stack 
; to load the timer.
; To increment the counter every millisecond, load the 
; timer with decimal 782. If you aren’t going to use 
; time-stamping you can ignore these routines.
;PROCEDURE InitTimer (TimrValue : integer);
; Only call InitTimer once at the beginning 
; of your application 1 millisecond is decimal 782.
InitTimer
 LINK   A6,#0    ; set frame pointer
 MOVEM.LD0/A0-A1,-(SP)
 MOVE.L #Lvl1DT,A0 ; Point to level 1 dispatch table
 LEA    PrevIVC,A1 ; point to interrupt vector storage
 MOVE.L 24(A0),(A1); save previous interrupt vector
 LEA    CounterIntHand,A1 ;point to new interrupt handler
 MOVE.L A1,24(A0); put it in the dispatch table
 MOVE.L VIA,A1   ; point to the 6522 chip
 ORI.B  #$40,vACR(A1); set the timer to freerun mode
 MOVE.B #$C0,vIER(A1); Enable timer interrupts
 MOVE   8(A6),D0 ; Get timer value
 MOVE.B D0,vT1L(A1); set timer lo byte
 LSR    #8,D0    ; shift to hi byte
 MOVE.B D0,vT1CH(A1) ; set timer hi byte
 MOVEM.L(SP)+,D0/A0-A1
 UNLK   A6
 MOVE.L (SP)+,A0 ; save return address
 ADDQ   #2,SP    ; move past timer value
 MOVE.L A0,-(SP) ; replace return address
 RTS

;PROCEDURE LoadTimer (TimrValue : integer);
; Call LoadTimer whenever you want to change the timer value.
; 1 millisecond is decimal 782.
LoadTimer
 LINK   A6,#0    ; set frame pointer
 MOVEM.LD0/A0-A1,-(SP)
 MOVE.L VIA,A1   ; point to the 6522 chip
 MOVE   8(A6),D0 ; Get timer value
 MOVE.B D0,vT1L(A1); set timer lo byte
 LSR    #8,D0    ; shift to hi byte
 MOVE.B D0,vT1CH(A1) ; set timer hi byte
 MOVEM.L(SP)+,D0/A0-A1
 UNLK   A6
 MOVE.L (SP)+,A0 ; save return address
 ADDQ   #2,SP    ; move past timer value
 MOVE.L A0,-(SP) ; replace return address
 RTS

;PROCEDURE StartCounter;
; StartCounter sets the counter value to 1
StartCounter
 LEA    Counter,A0 ; point to the counter
 MOVE.L #1,(A0)  ; set it to 1
 RTS
;FUNCTION GetCounter : LongInt;
; GetCounter returns a longword that is the value 
; of the counter 
GetCounter
 MOVE.L A0,-(SP)
 LEA    Counter,A0 ; point to the counter
 MOVE.L (A0),8(SP) ; return it as function result
 MOVE.L (SP)+,A0
 RTS
;PROCEDURE QuitTimer;
; Call QuitTimer when your application is done or the system will crash.
QuitTimer
 MOVEM.LA0-A1,-(SP)
 MOVE.L VIA,A1   ; Disable 6522 interrupts
 MOVE.B #$40,vIER(A1)
 LEA    PrevIVC,A1 ; Restore previous interrupt vector
 MOVE.L #Lvl1dt,A0
 MOVE.L (A1),24(A0)
 MOVEM.L(SP)+,A0-A1
 RTS
; This is the interrupt handler routine for the counter. 
; When the system gets this far A1 contains the base 
; address of the VIA.
; It also preserves D0-D3/A0-A3.
CounterIntHand
 LEA    Counter,A0 ; point to the counter
 ADDQ.L #1,(A0)  ; Increment it
 MOVE.B vT1C(A1),D0; Clear interrupt flag on 6522
 RTS
Counter DC.L1  ; The counter
PrevIVC DC.L0  ; Previous interrupt vector
 END