;  ****************************************************************
;  *   PCkb.asm 
;  *
;  *     version 1.32   Oct 12, 2003   Alan Probandt   Portland Oregon USA
;  *
;  *  [ Use TimesNewRoman font in text editor to format this file correctly ]
;  *
;  *  [ when programming the AVR chip, don't forget to include the EEPROM file]
;  *
;  *    Read keypresses from PC Keyboard into Atmel AVR 90S2313
;  *        -Assemble logic changes on AVR pin 6 into PC keyboard scan codes.
;  *    	-Decode keyboard scancodes into MIDI note numbers.
;  *     	-Send MIDI messages out the MIDI out port  31250/8/N/1
;  *
;     Key Pad - pressing two digits on the keypad changes the voice number.
;   			for example,  pressing '3' then '7' selects voice number 37 (in decimal).
;
;  *   PC keyboard clock signal on AVR pin 6 (INT1)
;  *   PC keyboard data signal on AVR pin 7 (PORTD bit 4)
;  *	MIDI out (31250 baud - 8/N/1) on AVR pin 8 (PB4)
;    
;					Atmel AVR 2313
;   	RESET low	PIN 1 		| VCC  PIN 20 +5V
;   				PIN 2 PD0	| PB7  PIN 19  SCK 
;   				PIN 3 PD1 	| PB6  PIN 18  
;   	3.579MHz 	PIN 4 XTAL1	| PB5  PIN 17  
;    must use only  PIN 5 XTAL2	| PB4  PIN 16  
;  	INT0 kbd clk	PIN 6 PD2 	| PB3  PIN 15  
;   INT1 kbd data 	PIN 7 PD3 	| PB2  PIN 14  
;   	MIDI out	PIN 8 PD4  	| PB1  PIN 13  
;   	 			PIN 9 PD5  	| PB0  PIN 12 
;   				PIN 10 GND	| PD6  PIN 11 
;    
;  ************************************************************

.nolist
.include "2313def.inc"
.list


.equ	MIDItx				= 4	 ; MIDI Transmit pin 8 (PB4)
.equ	INITIAL_BITCOUNT 	= 11   ;  used by Get_Scan
.equ	PARITY_BITCOUNT 	= 3    ;  used by Get_Scan
.equ	NOTEOFFSET			= 34  ; check for adjustment -- Is 'Z' key really Middle C?
.equ	CHANGE_VOICE_OFFSET = $2e
.equ	SPACEBAR_OFFSET		= $2d
.equ	REGISTER_AVAILABLE	= $FF
.equ	POSSIBLE_NOTES 		= 8
.equ	NOTE_ON_VELOCITY  	= 0x50
.equ	NOTE_OFF_VELOCITY  	= 0
.equ	NOTE_ON_MSG 		= $90
.equ	CHANGE_VOICE_MSG 	= $c0
.equ	MIDI_CONTROLLER_MSG = $b0
.equ	ALL_NOTES_OFF_BYTE 	= 123 ; standard cmd $7b doesn't work on TQ5
.equ	ALL_NOTES_OFF_2nd 	= 0
.equ	CapsToggleValue		= 0b01000000

.equ	T_flag 		= 6
.equ	Sign_flag	= 4
.equ	KeyboardClock  = 2
.equ	KeyboardData= 3
.equ	SM_flag		= 4 ; Sleep Mode (unused) - delay loop counter bit flag { 0 = long period is timed out}
.equ PushSwitch1  	= 4

; keyflag register's bit values
.equ	Edge_flag	= 7 	; use up or down edge while inputting char from keyboard
.equ	Caps_flag	= 6   ; Caps Lock pressed on -- no NoteOff transmitted
.equ	Shift_flag	= 5	; the shift key (either right or left) is being pressed  
.equ	Break_flag	= 4	; the last scancode was an $f0 - the break code sent when a key is released
.equ	OnOff_flag	= 3	; set means turn on the note whose MIDI number was decoded from the most recent scancode
.equ	Alt_flag	= 2	;  the Alternate (Alt) key (either right or left) is being pressed  
.equ	E0_flag		= 1	; the extended scancode $E0 was sent


;*********************************************************************************************
;  Register definitions
;
;  lower registers  r0 - r15
; r0 is temporary storage of byte retrieved from LPM instruction
.def	OctaveOffset		= r1 
.def  	CurrentVoiceNumber 	= r2
.def  	txbitcnt			= r3		; used by PutMIDI
.def	TableOffset 		= r5		;  used by PCKB_main to keep track of where a keypress has been found in a table
.def	MIDIcounter			= r6		; FastMIDINumbers, SlowMIDINumbers - which MIDI number is being sent
.def	regcnt				= r6		;  used by PCKB_main to keep track of which notes are playing by having keys held down
.def	OverflowCount		= r6		;  used by T0_overflow IRQ to time a quarter-second
.def	KPtemp				= r6		; used by PCKB_main to multiply keypad digit by 10
.def	ParityCounter		= r7        ; count the number of logic hi bits transmitted by the keyboard command output routine
.def	SustainValue		= r7

;  upper registers
.def	temp				= r16	; scratch register
.def	irqtemp				= r17  	; interrupt's scratch register
.def	bitcount			= r18	; used by INT0 irq  [getscan]	
.def  	scancode			= r19	; storage of data bits received from PC keyboard 
.def	scanbits			= r20 	; shift register for holding PC keyboard data while being assembled
.def	keyflags			= r21	; status of previous scancodes. used to decode multiple scancode keypresses
.def	DecodeValue			= r22  	; PC keyboard char decoded to NoteOn value, ChangeVoice value, or AllNotesOff cmd
.def	KPvalue				= r23	; the binary value of the pressed keypad digits. Used for new voice value.
.def	Velocity			= r24	; the MIDI note-On volume value
.def  	TxData  			= r25  	; the byte being sent out the MIDI port - PutMIDI

.dseg
.org 0x60
FNtable:			.BYTE	12
SoundingNotes:		.BYTE	POSSIBLE_NOTES

.cseg
.org $0000     
; AT90S2313 interrupt table                                                    
	rjmp		reset		; Reset handler   $000

.org INT0addr
	rjmp		get_scan	; External interrupt 0 handler  $001 (pin 6)  PC keyboard clock

.org INT1addr
	reti					; External interrupt 1 handler  $002

.org ICP1addr
	reti					; Timer1 capture event handler  $003     

.org OC1addr
	reti					; Timer1 compare match     $004

.org OVF1addr
	reti					; Timer1 overflow handler  $005

.org OVF0addr
	reti					; Timer0 overflow handler  $006

.org URXCaddr
	reti					; UART Rx Complete	$007

.org UDREaddr
	reti					; UART Data Register empty $008

.org UTXCaddr
	reti					; UART Tx Complete	$009

.org ACIaddr
	reti					; Analog comparator handler $00a

reset:
		ldi		temp, RAMEND
		out		SPL ,temp			; init Stack Pointer 
        	
; set-up ports for input/output and pull-up resistors
		ser		temp
		out		portb,temp	; port B pull-up resistors are all on
		out		portd,temp	; port D pull-up resistors are all on 
		clr		temp
		out		ddrb,temp  ; port b is all inputs  
		ldi		temp,(1<<MIDItx) 
		out		ddrd,temp  ; port D4 is output for MIDI


;*******************************************************************************************
;
;    	Get keypresses from standalone PC keyboard - convert to notes and send to MIDI port
;
;    	Subroutines:	'decode_data'
;
;	Interrupt procedures:	external interrupt int0 -- 'getscan'
;
;   Most time spent in 'GetChar' which checks T flag for fully received keypress from PC keybrd
;   When T is set, 'decode_data' called to convert keypress to note or cmd.
;*******************************************************************************************
;
PCkb_Main:
		ldi		temp,(1<<ISC01) ; setup INT0 interrupt on falling edge
		out		MCUCR, temp  	
		ldi		temp, (1<<INT0)
		out		GIMSK,temp      ;  enable external INT0 - General Interrupt Mask Register
		sei		; switch on the AVR general interrupt enabler
		clr		keyflags 
		clr		KPvalue
		ldi		bitcount,INITIAL_BITCOUNT ; = 11
		clt		;   T flag used to indicate that a char from kybd is ready to transmit
		ldi		temp, NOTEOFFSET
		mov		OctaveOffset, temp
		
		clr		temp				; set up the Function key voice select table with voices 00 - 0b
		ldi		ZH, high (FNtable)
		ldi		ZL, low (FNtable)
rst2:	st		z+, temp
		inc		temp
		cpi		temp, 12			; the number of Function keys on a PC keyboard
		brlo	rst2
		
		clr		CurrentVoiceNumber		; set synth voice to 00h on AVR reset
		rcall	ChangeVoice

		
; setup completed -------- enter MAIN LOOP here
	    
GetChar:in		temp, SREG ; MAIN LOOP of program  99.9% of time spent here
	   ; if T flag (SREG bit 6) is set, then char from keyboard is ready to transmit
		sbrs	temp,T_flag   ; if T flag (SREG bit 6) is set, then char from keyboard is ready to transmit
		rjmp	GetChar

		clt			 ; clear T flag - prepare for next char
		rcall	decode_data  ; convert the scancode from the keyboard into an ASCII character
								; send scancode and keyflags - return DecodeValue
		tst		DecodeValue    ; if DecodeValue =0, then ignore scancode - it's a shift character or break scancode
		brne	Valid_key     
		rjmp	GetChar

; DecodeValue less than $3f turns on/off note, $80-$89 are keypad numbers, $40-$4b map function keys F1 to F12, $c0 is spacebar
Valid_key:
		cpi		DecodeValue, $c0	; space bar key
		breq	DoSubAllNotesOff
		
		mov		temp, DecodeValue
		andi	temp,0xc0
		cpi		temp,0x40			; is the scancode a Function key activation?
		brne	VkyKP			; no, check for keypad press
		rjmp	FnKeyChangeVoice
		
VkyKP:	mov		temp, DecodeValue	; is the scancode a keypad press?
		andi	temp,0xc0			;  isolate the two most significant bits   1100 0000
		cpi		temp,0x80			;  test if the two most sig bits are '10'
		brne	VkyMN			; no, not a keypad press. So must be a note on/off.
		rjmp	DoKeyPad		; yes, scancode is a keypad activation.
		
VkyMN:	andi	DecodeValue,0b00111111 ; DecodeValue is lower than $3f
		rjmp	DoNote  
	
DoSubAllNotesOff:
		rcall	AllNotesOff
		rjmp	GetChar
		
;*********************************************************
;  Function Key Press  -  Assign Voice number to Fn key
;*********************************************************
FnKeyChangeVoice:
		mov 	temp,DecodeValue  ; DV will be $40 to $4b
		andi	temp, 0b00001111
		; check Alt flag, if set then assign the Current Voice Number into the selected Function key.
		;  if Alt flag is clear, then change voice to the number assigned to the selected Function key.
		sbrs	keyflags, Alt_Flag
		rjmp	FKCV0			; Alt_flag is set so jump to FKCV0
		ldi		ZH, high (FNtable)   ; get the Function key's voice number
		ldi		ZL, low (FNtable)
		add		ZL, temp			; ZL plus Function key number will never be greater than $ff
		st		z, CurrentVoiceNumber
		rjmp	FKCV2
FKCV0:	ldi		ZH, high (FNtable)   	; Alt_key is not pressed - Fn key pressed by itself
		ldi		ZL, low (FNtable)	;- send to the synth the number assigned to the pressed Function key
		add		ZL, temp			; ZL plus Function key number will never be greater than $ff
FKCV1:	ld		temp, z
		mov		CurrentVoiceNumber, temp
		rcall	ChangeVoice
FKCV2:	rjmp	GetChar	
	
;***************************************************************************
;   Key Pad  - pressing two digits on the keypad changes the voice number.
;   for example,  pressing '3' then '7' selects voice number 37 (in decimal).
;****************************************************************************
DoKeyPad: 
		mov 	temp,DecodeValue  ; DV will be $80 to $8f
		andi	temp, 0b00001111
;  check if keypress is a digit.  If yes, then check if 1st, 2nd, or third digit of voice number in base10
		cpi		temp, 10
		brlo	KP_digit    ; yes it's a digit (0 to 9)
		cpi		temp, $0a ; was the NumLock key pressed
		brne	KP_isStar  ; no
		rjmp	GetChar	; yes,  do nothing for now
KP_isStar: cpi	temp, $0b  ; was the multiply on the keypad pressed?	
		brne	KP_isMinus  ; no
		rjmp	GetChar	; yes,  do nothing for now	
KP_isMinus: cpi	temp, $0c ; was the minus sign on the keypad pressed?	
		brne	KP_isPlus ; no
		rjmp	GetChar	; yes,  do nothing for now	
KP_isPlus: cpi	temp, $0d  ; was the plus sign on the keypad pressed?	
		brne	KP_isPoint ; no
		rjmp	GetChar	; yes,  do nothing for now		
KP_isPoint: cpi	temp, $0d  ; was the decimal point on the keypad pressed?	
		brne	KP_exit 	; no
		rjmp	GetChar	; yes,  do nothing for now						
KP_exit: rjmp	GetChar 	; code should never get here

;  get two digits; the ten's value comes first, then the one's value
KP_digit:	tst		KPvalue  
		brne	KP1digit
		mov		KPvalue,temp
		sbr		KPvalue, 0b10000000  ; the highest bit acts as a flag for 1st or 2nd digit 
		rjmp	GetChar
		
KP1digit:	;cli
		cbr		KPvalue,0b10000000
		mov		KPtemp,KPvalue   ; received 2nd digit, so multiply 1st digit by 10 and add 2nd
		lsl		KPvalue
		lsl		KPvalue
		lsl		KPvalue
		add		KPvalue, KPtemp
		add		KPvalue, KPtemp
		add		KPvalue, temp		;  max value 99 decimal in KPvalue
		mov		CurrentVoiceNumber, KPvalue
		clr		KPvalue
		rcall	ChangeVoice
		rjmp	GetChar
							
;************************************
;   DoNote   -  Turn a note off or on
;************************************						
DoNote:  
		sbrc	keyflags,OnOff_flag   ; if OnOff flag is set, then char is a MIDI note number to be played
		rcall	playMIDInote
		sbrs	keyflags,OnOff_flag  ; if OnOff flag is clear, then char is a playing MIDI note to be turned off
		rcall	TurnOffMIDInote
		rjmp	GetChar


;**************************************************************************************************************************
;  DECODE_DATA  -- subroutine to convert the scancode from the keyboard into a general category.
;   input: scancode (register value)   output = DecodeValue (register value)
;
;   DecodeValue < $40 (alphanumeric keys) == turn on or off MIDI note (depending on whether key is pressed down or released)
;   DecodeValue = $40 to $4b ( function keys)    == change voice or assign voice number to Fn key
;   DecodeValue = $80 to $8f  ( key pad)    == input a decimal number using keypad digits, then <enter>
;   DecodeValue = $c0 (SPACE key pressed)    == turn off all notes
;   DecodeValue = $f0 to $fe   ( special keys)    Each value between $f0 and $fe has its own handler code 
;   DecodeValue = $ff  == ignore this scancode
;
;**************************************************************************************************************************  
decode_data:
;   first check that Break flag is clear *** 
chkBreakFlag:
		sbrc	keyflags, Break_flag   ; the previous scancode was $f0 when break_flag is set
		rjmp	Break_set
;		sbrc	keyflags, E0_flag   ; the previous scancode was $f0 when break_flag is set
;		rjmp	Do_E0char
		
;   Break and Extended are clear, so do check the first three special conditions	
		cpi		scancode,$f0  ; 	$F0 =Breakcode  finger-off-the-key identifier
		brne	isLeftAltKey
		sbr		keyflags, (1<<Break_flag)  ; set Break flag  so that the next scancode will not be seen a keypress down	
		rjmp	setZero
	
isLeftAltKey: 
		cpi		scancode, $11
		brne	isCapsLock
		sbr		keyflags, (1<<Alt_flag)
		rjmp	setZero
		
isCapsLock:
		cpi		scancode, $58  ; caps lock key
		brne	isExtendedCode
		ldi		temp, CapsToggleValue
		eor		keyflags, temp

 ; Code to turn off / on Sustain Petal		
		nop
		sbrc	keyflags, Caps_flag
		rjmp	TurnOnSustain
		clr		SustainValue ; turn off sustain petal
		rcall	Sustain
		rjmp	setZero
TurnOnSustain:	
		ldi		temp,127
		mov		SustainValue,temp
		rcall	Sustain
		rjmp	SetZero

Sustain:
		ldi		TxData, MIDI_CONTROLLER_MSG
		rcall	PutMIDI
		ldi		TxData,64
		rcall	PutMIDI
		mov		TxData, SustainValue
		rcall	PutMIDI
		ret
		
isExtendedCode: ; check for E0 flag
		cpi		scancode,$e0  ;  $e0  extended char table
		brne	isE0set  ; scancode is not one of the three special cases
		sbr		keyflags,(1<<E0_flag) ; set E0 flag			
		rjmp	setZero	
	
isE0set: ; check if extended char scancode was previously sent
		sbrc	keyflags, E0_flag 	; test extended char flag 
		rjmp	Do_E0char		; determine the action to take for the extended keypress 
;-------------------------------------------------------------------------------------------------------------------	
;not shift, $E0, or $F0, and no flags are set;  so do a table lookup for a MIDI note key
isScan83:	cpi		scancode,$83
		brne	MIDIOnTableLookUp
		ldi		DecodeValue, $46
		rjmp	exit_decode
		
MIDIOnTableLookUp:
		out 	EEAR, scancode   ;Set the EEPROM's address
		sbi 	EECR, EERE        ;Send the Read strobe
		in		DecodeValue, EEDR           ;Put the data in the transmit register
		cpi		DecodeValue, $40
		brsh	exit_decode
		
		sbr		keyflags,(1<<OnOff_flag)  ; set the note on/off flag to turn note on
		rjmp 	exit_decode

;  Break flag is set - this means the previous scancode was $f0 (a key release)
;     This scancode is either the Extended sentinel ($e0) or the number of the key being released, which is either a shift or message key.
;     If the key being released is a shift key, clear the shift flag, set DecodeValue to zero and exit.
;     if the released key has an extended code, then the clear the break and the extended flags, set DecodeValue to zero and exit.
Break_set:
		cbr		keyflags,(1<<Break_flag) ; clear Break flag
		
 ;		If scancode is E0, then reset Break flag so that the next scancode is recognized as the last of an extended release sequence
;		instead of a normal keypress down.		
isE0:	cpi		scancode, $e0	; extended key press sentinel
		brne	isE0flagOn
		sbr		keyflags,(1<<Break_flag)
		sbr		keyflags,(1<<E0_flag) ; set extended flag		
		rjmp	setZero
isE0flagOn:		;  if the E0flag is on then this scancode is the extended character number that is being released.  Just clear flags.
		sbrs	keyflags, E0_flag   ; Extended flag on?
		rjmp	isAltflagOn		
		cbr		keyflags,(1<<Break_flag) ; yes, clear Break flag
		cbr		keyflags,(1<<E0_flag) ; clear extended flag
		rjmp	setZero	
		
isAltflagOn:
		sbrs	keyflags, Alt_flag
		rjmp	TableLookUp2 ;no, a note key is being released.  Determine the note and send MIDI note off message.
		cbr		keyflags,(1<<Alt_flag) ; clear Alt flag
		rjmp	setZero	
				
TableLookUp2:				;  find the offset of the note to be turned off
		out 	EEAR,scancode	;Set the EEPROM's address
		sbi 	EECR,EERE        ;Send the Read strobe
		in		DecodeValue ,EEDR           ;Put the data in the transmit register
		cpi		DecodeValue, $40
		brsh	setZero
		cbr		keyflags,(1<<OnOff_flag)  ;clear the note on/off flag to turn note off
		rjmp	exit_decode
setZero:  
		clr		DecodeValue
exit_decode: 				; subroutine single exit point
		ret
		
; *********************************************************************
;  previous scancode was $e0, so this is an extended character code
;  Program will come here when an extended key is pressed, not released
;**********************************************************************
Do_E0char:
		cbr		keyflags,(1<<E0_flag)  ; clear the E0 flag
		cpi 	scancode,$72  ; up arrow  LOWER the octave range
		brne	isDownArrow
		mov		temp, OctaveOffset
		cpi		temp,$7f - 12	; 12 is number of semitones in an octave
		brsh	setZero 		
		subi	temp,-12		; add (by subtracting minus number) one octave (12 semitones)
		cpi		temp,$7f		; $7f is max note number
		brsh	setZero 		; branch is same or higher (unsigned)		
		mov		OctaveOffset,temp
		rjmp	setZero
	
isDownArrow:
		cpi 	scancode,$75	; down arrow
		brne	isLeftArrow
		mov		temp, OctaveOffset
		cpi		temp,12  		; can't send a MIDI note on message note value that is less than zero
		brlo	setZero  		; branch is same or higher (unsigned)
		subi	temp,12		; number of semitone notes in a octave
		mov		OctaveOffset,temp
		rjmp		setZero
		
isLeftArrow:
		cpi 	scancode,$6b	; left arrow - change voice to previous in sequence
		brne	isRightArrow	
		mov		temp, CurrentVoiceNumber
		dec		temp
		andi	temp, 0b01111111
		mov		CurrentVoiceNumber, temp
		rcall	ChangeVoice
		rjmp	setZero
		
isRightArrow:
		cpi 	scancode,$74	; right arrow  - change voice to next in sequence
		brne	isRightAlt			
		mov		temp, CurrentVoiceNumber
		inc		temp
		andi	temp, 0b01111111
		mov		CurrentVoiceNumber, temp		
		rcall	ChangeVoice
		rjmp	setZero
		
isRightAlt:
		cpi 	scancode,$11	; right Alt key 
		brne	isRightCntrl
		sbr		keyflags, (1 << Alt_Flag)
		rjmp	setZero

isRightCntrl:
		cpi 	scancode,$14	; right Control key 
		brne	isInsert
		rjmp	setZero
		
isInsert:
		cpi 	scancode,$70	; Insert key 
		brne	isHomeKey
		rjmp	setZero
		
isHomeKey:
		cpi 	scancode,$6c	; Home key 
		brne	isDeleteKey
		rjmp	setZero

isDeleteKey:
		cpi 	scancode,$71	; Delete key 
		brne	isEndKey
		rjmp	setZero
	
isEndKey:
		cpi 	scancode,$69	; End key 
		brne	isPageUp
		rjmp	setZero
	
isPageUp:
		cpi 	scancode,$7d	; PageUp key 
		brne	isPageDown
		rjmp	setZero
				
isPageDown:
		cpi 	scancode,$7a	; PageDown key 
		brne	isKPenter
		rjmp	setZero
				
isKPenter:
		cpi 	scancode,$5a	; KeyPad Enter key 
		brne	isKPdivide
		rjmp	setZero
						
isKPdivide:
		cpi 	scancode,$5a	; KeyPad divide key 
		brne	isExtOther
		rjmp	setZero					

isPrtScrFirst:
		cpi 	scancode,$12	; First extended byte of PrintScreen key
		brne	isPrtScrSecond
		rjmp	setZero
		
isPrtScrSecond:
		cpi 	scancode,$7c	; second extended byte of PrintScreen key
		brne	isExtOther		; same as Keypad multiply  
		rjmp	setZero
		
isExtOther: 
		rjmp	setZero
; ***** end of Decode_Data subroutine *******************


;.include "PCkb2.asm"


; *********************************************************************************************
;  AllNotesOff   -  subroutine
;		1) 	Put Note_Available sentinel into the SRAM MIDI note bank for all possible notes.
;			This indicates that all possible note spaces are available because all notes are off.
;		2)	Send the All_Notes_Off  MIDI control message to the synthesizer.
;		3)     return to the GetChar routine
;*********************************************************************************************
AllNotesOff:  
		clr		ZH		
		ldi		ZL,SoundingNotes - 1
		ldi		temp, POSSIBLE_NOTES
		mov		regcnt, temp

;    Put Note_Available sentinel into every location of the SRAM MIDInote bank.
ANO1:	inc		zl  
;		ld		DecodeValue,z
;		sub		DecodeValue, OctaveOffset
;		ldi		velocity, NOTE_OFF_VELOCITY
;		rcall	NoteOnMessage
		ldi		temp, REGISTER_AVAILABLE		
		st		z,temp
		dec		regcnt
		brne	ANO1 ; make every SRAM MIDI note location available for new notes at space-bar press

		ldi		temp, MIDI_CONTROLLER_MSG
		mov		TxData, temp
		rcall	putMIDI
		ldi		Temp, ALL_NOTES_OFF_BYTE
		mov		TxData, temp
		rcall	putMIDI
		clr		TxData
		rcall	putMIDI
		ret
	            	
; *********************************************************************************************
;  ChangeVoice   -  subroutine -- receives 'CurrentVoiceNumber' register with the MIDI voice number (00-7f)
;	1) 	Put Note_Available sentinel into the register bank for all possible notes.
;		This indicates that all possible note spaces are available because all notes are off.
;	2)     Send the MIDI program change message to the synthesizer.  This will turn off all
;		sounding notes for the selected MIDI channel (channel 1 by default).
;
;*********************************************************************************************	            	
ChangeVoice:
		clr		ZH		
		ldi		ZL,SoundingNotes - 1
		ldi		temp, POSSIBLE_NOTES
		mov		regcnt, temp
		ser		temp
CV1: 	inc		zl  ;a change voice command turns off all sounding notes
		st		z,temp
		dec		regcnt
		brne	CV1 ; make all storage registers available for new notes when voice changes
		ldi		temp, CHANGE_VOICE_MSG
		mov		TxData, temp	
		rcall	putMIDI
		mov		TxData, CurrentVoiceNumber
		rcall	putMIDI
		ret
	
;*********************************************************
;. playMIDInote    subroutine -- receives the Keypress offset in 'DecodeValue'.
;  	To this value gets added the Octave offset value to get the final MIDI note number.
;
;   receives: keyflags, DecodeValue 
;   registers used:  TxData
playMIDInote:
; if the OctaveOffset is not added to the MIDI note value before this value is stored into the SoundingNotes array,
; then every note that is one or more octaves above or below that note will not be able to be sounded.
		add		DecodeValue, OctaveOffset
		ldi		temp, 44
		add		temp, OctaveOffset
		cp		DecodeValue, temp
		brsh	PMN_Out
		clr		ZH		
		ldi		ZL,SoundingNotes - 1
		ldi		temp, POSSIBLE_NOTES
		mov		regcnt, temp
PMN1:	inc		zl  ; first check SRAM array of SoundingNotes to see if the note is already playing
		ld		temp,z
		cp		temp, DecodeValue
		breq	PMN_Out ; found identical note number, which means that the Note had been already playing.
;						The key was held down long enough trigger typematic auto-repeat.
		dec		regcnt
		breq	NewNote
		rjmp	PMN1
				
;  the DecodeValue is not the number of a MIDI note being sounded
NewNote: 	ldi		ZL,SoundingNotes - 1
		ldi		temp, POSSIBLE_NOTES
		mov		regcnt, temp
PMN2:	inc		zl  
		dec		regcnt
		breq	PMN_Out
; now check the SRAM array of SoundingNotes to see if there is a voice available 		
		ld		temp,z  ; to play the new note
		cpi		temp,REGISTER_AVAILABLE  
		brne	PMN2
		st		z,DecodeValue
		
		ldi		velocity, NOTE_ON_VELOCITY
		rcall	NoteOnMessage
	
PMN_Out:
		ret

;*********************************************************
;. TurnOffMIDInote --  subroutine
;   receives: keyflags, DecodeValue 
;   registers used:  TxData,keyflags, regcnt
TurnOffMIDInote:
; if the OctaveOffset is not added to the MIDI note value before this value is stored into the SoundingNotes array,
; then every note that is one or more octaves above or below that note will not be able to be sounded.
		add		DecodeValue, OctaveOffset
; Search the SRAM array from the beginning to find the note that corresponds to the key that was just released.	
		clr		ZH					; set up Z pointer to the beginning of the SRAM array
		ldi		ZL,SoundingNotes - 1
		ldi		temp, POSSIBLE_NOTES  ; size of the SRAM array 
		mov		regcnt, temp
ToMN1:	inc		zl
		ld		temp, z			; test each value in the SRAM array to see if it is the note
		cp		temp, DecodeValue
		breq	ToMN2			; found it, now turn it off
		dec		regcnt
		breq	ToMN_Out
		rjmp	ToMN1			; note was not found in this SRAM location, so check next location in the array
	
ToMN2: ; found note number in SRAM array storage, so send the MIDI Note-Off message to the synthesizer
		ser		temp	 ; put the Note_Available sentinel into the SRAM array position that held the note being turned off.
		st		z,temp  ; let program that this reg is available
		sbrc	keyflags, Caps_Flag
		rjmp	toMN_Out
		ldi		Velocity, NOTE_OFF_VELOCITY
		rcall	NoteOnMessage

ToMN_Out:		ret
	
NoteOnMessage:
		ldi		temp,NOTE_ON_MSG		
		mov		TxData, temp
		rcall	putMIDI
		mov		TxData,DecodeValue
		rcall	putMIDI
		mov		TxData, Velocity
		rcall	putMIDI
		ret
		
;***************************************************************************
;*
;* "putMIDI"   Data bits are fed to an output using a timing loop, not an interrupt.
;*                    This is a subroutine.  It returns to the code that called it after the data is finished 
;*			transmitting (after about 325 microseconds).
;*
;* This subroutine transmits the byte stored in the "TxData" register
;*
;* Number of words	:14 including return
;* Number of cycles	:Depends on bit rate
;* Low registers used	:None
;* High registers used	:2 (txbitcnt,TxData)
;* Pointers used	:None
;*
;*  time used  == 10 * halfbit_delay + @120 cycles
;*  subroutine does not exit until finished
;
;delay----|----|----|----|---|----|-----|---|----|----|------
;data-\___/----\___/-----\___/-----\___/----\___/-----------
;Txbit  10 9  9 8 8 7  7 6 6 5  5 4 4 3  3 2 2 1  1 0
;Tx    start    0     1     2      3      4      5     6     7   stop  
.equ	b	= 36	; ((b-1)*3) +10 = 116 cycles = 32uSec [clock period = 279.4nS]
;***************************************************************************

putMIDI: ldi	temp, 10	; 1+8+sb (sb is # of stop bits)
		mov		txbitcnt,temp
		com		TxData		; Invert everything [the lsr always puts a 0 into the carry]
		sec			; Start bit
putMIDI0:	brcc		putMIDI1		; 1 or 2
		cbi		PORTD,MIDItx	; 2   send a '0' (clear bit I/O)
		rjmp	putMIDI2		; 2   else	
putMIDI1:	sbi	PORTD,MIDItx	; 2   send a '1'
		nop				; 1  	
putMIDI2:	ldi	temp,b 		; 1 cycle
bit_delay1: dec	temp		; 1 cycle
		brne	bit_delay1	; 2 if true, 1 if false
		lsr		TxData		; 1  Get next bit
		dec		txbitcnt	; 1  If not all bit sent
		brne	putMIDI0	; 2  send next
		ret			

ClearNoteArray:
		clr		zh
		ldi		zl, (low (SoundingNotes)) - 1  ; fill SRAM array for note storage with REGISTER_AVAILABLE sentinels
		ldi		temp, POSSIBLE_NOTES
		mov		regcnt, temp
		ldi		temp, REGISTER_AVAILABLE	
CNA1:	inc		zl
		st		z, temp
		dec		regcnt
		brne	CNA1
		ret


;********************************************************************************
; GET_SCAN:  ; signal handler for external interrupt int0 (AVR pin 6)
;   called by each transition of the keyboard clock signal
;   assemble the scancode from keyboard data signal- data valid when clock is low
; (  use Terminal font to see correctly )
;clk---|_|--|_|--|_|--|_|--|_|--|_|--|_|--|_|--|_|---|_|---|_|----------   (---- = logic high +5v)
;data-\___/-----\___/-----\___/-----\___/-----\___/--------------------
;      11   10    9    8    7    6    5    4    3     2     1 bitcount on falledg
;   start    0    1    2    3    4    5    6    7     P   stop   data bit
;  Bitcnt 3 to 10 is data. start bit = 11, parity bit=bit 2;  stop bit = bit 1
;*********************************************************************************
get_scan: ;    Routine first entered at falling edge; then on both edges

		sbrc	keyflags,Edge_flag  ; test edge flag
		rjmp	up_edge  ; bit 7 (edge) = 0 => falling  ;; bit 7 (edge) = ff => rising
		cpi 	bitcount,INITIAL_BITCOUNT ; falling edge of the FIRST clock pulse from the PC keyboard ; start bit so do nothing
		breq	I1two
		cpi		bitcount,PARITY_BITCOUNT ; = 3  ; test for parity bit and stop bit
		brlo	I1two  ; must use bitcount 3 for compare because branch tests only for lower
		lsr		scanbits   ; shift data right one bit - data bit 7 gets 0
		sbic	PIND,PD3  ;set scancode bit if  bit 3 on input port D is set (pin 7 on 2313 chip)
		ori		scanbits,$80 ; if data from kbrd is 1, then set bit 7 only and let other bits unchanged
		ldi 	irqtemp, ( (1<<ISC01) | (1<<ISC00) )
		out 	MCUCR, irqtemp  ; Set interrupt on rising edge - INT0
		sbr		keyflags,(1<<Edge_flag) ; set edge flag
		reti	    	
I1two:	ldi 	irqtemp, ( (1<<ISC01) | (1<<ISC00) ) ;  just exit if bitcnt is 11, 2, or 1
		out		MCUCR, irqtemp ; Set interrupt on rising clock edge - INT0
		sbr		keyflags,(1<< Edge_flag)  ; set edge flag
		reti    		
up_edge: ldi 	irqtemp, 1<<ISC01
		out		MCUCR, irqtemp ; Set interrupt on falling clock edge - INT0
		cbr		keyflags,1<<Edge_flag  ; clear edge flag
		dec 	bitcount
		brne	exit_int1	; All bits received?
		ldi		bitcount,INITIAL_BITCOUNT
		set			; set T flag to let main program know a new char is ready
		mov		scancode,scanbits ; scanbits can be used to assemble new char while scancode is being decoded
exit_int1:  	  ; clear any pending interrrupt
		clr		irqtemp
		out		GIMSK,irqtemp      ;  disable external INT0 - General Interrupt Mask Register		
		out		MCUCR,irqtemp
		ldi		irqtemp, (1<<ISC01) ; interrupt on falling edge
		out		MCUCR,irqtemp
		ldi		irqtemp, (1<<INT0)
		out		GIMSK,irqtemp      ;  enable external INT0 - General Interrupt Mask Register
		reti       	


;  shows program and version information when code data downloaded from an AVR is viewed with a hex editor
                                      
;ID:    .db  "          ****  PCKB3.asm v1.31 Alan Probandt Oct 12, 2003"
ID:		.db  "          ****  CPBK.3sa mv.113A al nrPbonatdO tc1 ,22 00 3"   

		
;;********************************************************************
;;   EEPROM keypress table  
; scancode is offset into table
;  table value < $3f  keyboard note (octave offset added to get MIDI note value)
;  table value $40 - $4f   function key
;  table value $80 - $8f   keypad press
;  table value $c0	space (All Notes Off)
;  table value $f0 - $fe   special key
;  table value $ff   filler value ignore
;;*********************************************************************                                                          
.eseg
.org 0

EEPROMtable:
;    0   1   2   3   4   5   6   7   8   9   a   b   c   d   e   f
.db $ff,$48,$ff,$44,$42,$40,$41,$4b,$ff,$49,$47,$45,$43, 01, 00,$ff ; 00-0f
.db $ff,$ff, 25,$ff,$f1, 02,$ff,$ff,$ff,$ff, 26, 27,$ff, 04, 03,$ff ; 10-1f
.db $ff, 30, 28, 29, 06,$ff, 05,$ff,$ff,$c0, 31,$ff,  9,  7,  8,$ff ; 20-2f
.db $ff, 35, 33, 34, 32, 11, 10,$ff,$ff,$ff, 37, 36, 13, 12,$ff,$ff ; 30-3f
.db $ff, 38,$ff, 14, 16, 17, 15,$ff,$ff, 40, 42, 39, 41, 18,$ff,$ff ; 40-4f
.db $ff,$ff, 43,$ff, 19, 20,$ff,$ff, 24,$f3,$f4, 21,$ff, 23,$ff,$ff ; 50-5f
.db $ff,$ff,$ff,$ff,$ff,$ff, 22,$ff,$ff,$81,$ff,$84,$87,$ff,$ff,$ff ; 60-6f
.db $80,$8e,$82,$85,$86,$88,$f4,$8a,$8b,$8d,$83,$8c,$8b,$89,$f4,$ff ; 70-7f