system.asm

// ***********************************************************************************************************************************************
// ***********************************************************************************************************************************************
//
//															Microvision System Code
//															=======================
//
//	Functionality:
//
//		LCD Interface : bit writing, polarity reversal, update, number font generation, number area clear, number screen rendering.
//		Speaker : 		Sound managed through update (overall pitch) and polarity reversal (length)
//		Other :			Random Number Generation
//
//	Pages Occupied:
//		Page 15 ($3C0), 0 ($000), 1 ($040), 2 ($080)
//
//	Written by Paul Robson January 2014
//
// ***********************************************************************************************************************************************
// ***********************************************************************************************************************************************

HWNotDataClock = 7												// R Latch connected to not- dataclock on LCD
HWLatchPulse = 6												// R Latch connected to Latch Pulse on LCD

HWKeyLeftCol = 10 												// Keyboard column selection R Latches
HWKeyMiddleCol = 9
HWKeyRightCol = 8

HWSpeaker = 0 													// Speaker line

//	Page 0 of RAM Allocation
//	========================
//	0-3		Lookup Table (8,4,2,1)
//	4 		Sound Timer - off when zero
//	5 		Pitch
//	6 		Pitch Counter - adds Pitch to Pitch Counter, bit 3 is copied to the sound bit
//	7 		Temporary value used by WriteBits routine. Note that WriteBitsX routines can operate with X register non zero
//			provided memory location (X,7) is kept as this will be overwritten.
//	8 		Line pointer (y position on screen)
// 	9 		Offset pointer (in page X+4)
//	10,11 	Seed values for the 4 bit RNG.

OSDSoundTimer = 4 												// Non-zero for sound to play - decremented when > zero ever polarity reversal (frame)
OSDPitch = 5 													// Pitch - added to PitchCounter every time Address Latch->Holding latch is performed
__PitchCounter = 6 												// Bit 3 of the PitchCounter is mirrored to the speaker line.
__LinePointer = 8
__OffsetPointer = 9
__XNRandom = 10 												// Random Number seeds.
__CNRandom = 11

// ***********************************************************************************************************************************************
//
//															Program starts here
//	
// ***********************************************************************************************************************************************
//														Page 15 ($3C0) [2 bytes spare]
// ***********************************************************************************************************************************************

StartLibrary
	ldx		0 													// Set up the bit table at M(0,0)
	tcy 	0
	tcmiy	8
	tcmiy	4
	tcmiy	2
	tcmiy	1
	tcmiy 	0 													//  Turn sound off by setting timer to zero.

	tcy		HWNotDataClock										// 	set !dataclock 1, latch pulse 0
	setr 														//  Initial state of control lines.
	tcy 	HWLatchPulse
	rstr

	lbr 	__StartProgram

// ***********************************************************************************************************************************************
//
//	Output a bit position to the LCD Driver, either row or column. There are four near identical subroutines, which output
//	M(M(XY)), M(XY), Y or A. It converts the value to a sequence of nibbles with the nth bit set, (where 0 is the left most bit/upper bit)
//
//	Four phases - it one's complements the position so 15 is now the left most
//				- it outputs zeros before the position
//				- it outputs the bit pattern at the position
//				- it outputs the bit pattern after the position
//
//	Requires a table at (X0) to contain 8,4,2,1 (bit lookup)
//	Uses (X7) as temporary storage - this is used for efficiency (so we don't keep changing Y)
//
// ***********************************************************************************************************************************************

OSWriteBitsM 													// Position in M(XY)
	tmy 
OSWriteBitsY													// Position in Y
	tya 
OSWriteBitsA 													// A = 0..15, Bit position (15 = right most)
	cpaiz														// Invert A so that 15 is now the left most pixel.	
	dan 
	tcy 	HWNotDataClock 										// Y = Not Data Clock
	tam 														// Save to 0:HWNotDataClock
	cla
	tdo 														// set the output lines to $00.
	tma 														// Restore the value.

__WBStart
	a4aac 														// Add 4 to the Bit position - if 12..15 (e.g. the right position),status will be set and it will be 0..3
	br 		__WBEndStart 
	rstr 														// Pulse Not(Data Clock) to write out leading zero nibbles.
	setr
	br 		__WBStart

__WBEndStart 														
	tay															// Point to the look up table
	tma 														// Read it to get the nibble to write
	tdo 														// Write to the O lines
	tcy 	HWNotDataClock 										// Pulse the not data clock to write it out.
	rstr 									
	setr

	cla															// Clear the O line again
	tdo 
	tma 														// Read the original value back (e.g. the value at the start)
__WBEnd
	a12aac 														// Subtract 4. Status set if value was >= 4
	br 		__WBEndNibble 										// so output one zero nibble
	retn 														
__WBEndNibble
	rstr 														// Pulse the not data clock line
	setr
	br 		__WBEnd 											// And try it again.

// ***********************************************************************************************************************************************
//
//			   Copy addressed latches to holding latches, updating the display. Play sound if the sound counter is non-zero
//
// ***********************************************************************************************************************************************

OSUpdateDisplay
	ldx 	0
	tcy 	OSDSoundTimer 										// Check sound timer
	mnez 														// If it is non-zero
	br 		__UDMakeSound 										// If so, go to make sound ....
OSUpdateDisplayNoSound
	tcy 	HWLatchPulse 										// Pulse the latch pulse
	setr
	rstr
	retn

__UDMakeSound
	tcy 	OSDPitch 											// Read pitch
	tma
	tcy 	__PitchCounter 										// Add into pitch counter
	amaac
	tam 														// Write pitch counter back
	tbit1 	3 													// Is MSB set ?
	br 		__UDBitSet
	tcy 	HWSpeaker 											// No, clear speaker bit
	rstr
	br 		OSUpdateDisplayNoSound
__UDBitSet 														// Yes, set speaker bit
	tcy 	HWSpeaker
	setr
	br  	OSUpdateDisplayNoSound

	page

// ***********************************************************************************************************************************************
//
//						Create/Update Digit Pattern for Row X : X = 4..7. Pattern# is in (X,0), data starts at (X,1)
//
//									(Note: all bit patterns are reversed, assuming BlockBuster PLA + Wiring)
// ***********************************************************************************************************************************************
//																Page 0 ($000) [1 byte spare]
// ***********************************************************************************************************************************************

OSCreateGraphicY 												// Use graphic Y in column X
	tya
OSCreateGraphicA 												// Use graphic A in column X
	tcy 	0 													// Store A in offset 0
	tam
OSUpdateGraphic 												// Update image in column X
	tcy 	0 													// Start at location zero.
	tma 														// Load the character value
	tcy 	1 													// Point to the store area.
	tam 														// Store it in M(X,Y)
	a6aac 														// is it >= 10 
	br 		__CGExit1 											// if so, exit now after erasing the tam before

	mnez 														// If non zero goto 1-9 code
	br 		__CG1To9
	tcmiy 	7 													// Output a zero. ***
	tcmiy 	5													// 				  * *
	tcmiy	5													// 				  * *
__CG0b
	tcmiy	5 													// 				  * *
__CG0a 
	tcmiy	7 													// 				  ***
	br 		__CGExit

__CG1To9														// M(X,Y) contains the number
	tma 														// Load into A
	a11aac 														// Will cause carry to be set if 5,6,7,8,9
	br 		__CG5To9

__CG1To4														// Process 1 to 4.
	dman 														// Now 0-3 representing 1-4
	cpaiz 														// Now S will be set if it was 0 (was originally 1)
	br 		__CG1 												// So draw the 1 code if so, a vertical line.
	tma 														// Otherwise, reload the number from A, it is 2,3 or 4.
	a12aac 														// This will cause a carry if it was originally 4
	br 		__CG4 												// If so , do 4 code. Now it is 2 or 3 (now A = 14 and 15 for these)
	tcmiy 	7 													// So do *** which is the top 3 lines for both 2 and 3.
	tcmiy 	4 													// then    *
	tcmiy 	7 													// then  ***
	iac 														// Carry will be set if it is 3 (it was 15), in which case do the tail to 5 (backwards L)
	br 		__CG5a
	tcmiy 	1 													// do *.. then solid tail and exit (e.g. bottom rows of 2) (e.g. forwards L)
	br 		__CG0a

__CG4 															// Output a '4'.
	tcmiy 	5													// *.*
	tcmiy 	5													// *.*
	tcmiy	7													// ***
	br 		__CG1a												// Use last two lines of 1 code to output the rest of the 4.

__CG1 															// Output a '1'.
	tcmiy	4 				
__CG1b 															// 4 x ..*
	tcmiy	4
	tcmiy	4
__CG1a 															// 2 x ..*
	tcmiy	4
	tcmiy 	4
	br 		__CGExit

__CG5To9 														// Do 5,6,7,8,9, represented by 0,1,2,3,4 at this point due to the A11AAC.
	tcmiy 	7 													// always a top line *** for 5-9.
	a14aac 														// will drop through if 5 or 6 (14 and 15), 7,8,9 are 0,1,2.
	br 		__CG7To9 											
	tcmiy 	1 													// Output *.. - these are common for both 5 and 6.
	tcmiy 	7 													// Output ***
	iac 														// Will set carry if it was 6 (6 -> 1 -> 15 after a11aac and a15aac)
	br 		__CG0b 												// In which case draw the bottom two lines of '0' 
__CG5a
	tcmiy 	4 													// Draw ..* - this is the reverse L and the bottom two lines of '5'
	br 		__CG0a 												// Draw Bottom line and exit.

__CG7To9
	cpaiz 														// (0,1,2 representing 7,8,9). S will be set if A was zero following cpaiz.
	br 		__CG1b 												// In which case it was 7, so draw the tail (4 x ..*)
	tcmiy 	5 													// Draw *.* which are commonalities for 8 and 9.
	tcmiy 	7	 												// Draw ***
	iac 														// if it was 8, then draw the *.* and *** e.g. bottom of 8
	br 		__CG0b
	br 		__CG5a 												// Draw tail of 9

__CGExit1 														// >= 10, a value was stored though so clear it
	tcmiy 	0
__CGExit
	tcy 	0 													// Load current value into A
	tma 
	retn 														// End of routine.

	page

// ***********************************************************************************************************************************************
//
//													Render the text/number display.
//
//	On entry, Y contains the vertical position of the top line of the text. This needs a label 'RenderTextExit' to be defined as this is a 
//	jump in, jump out routine *not* a subroutine, as it uses subroutines and we only have one level.
//
//	This does the *whole* of the rendering including polarity switching.
//	
// ***********************************************************************************************************************************************
//														Page 1 ($040) [1 byte spare]
// ***********************************************************************************************************************************************

OSRenderTextDisplay
	tya
	ldx 	0 													// Point to page zero
	tcy 	__LinePointer 										// Write vertical screen position to line pointer
	tamiyc 						
	tcmiy 	1 													// Write offset (initially 1) to offset pointer
	call	OSSwitchPolarity 									// Switch polarity, start of frame.

__RTDLoop
	tcy 	__LinePointer 										// Read line pointer 
	lcall 	OSWriteBitsM 										// and write that column value.	

	call 	__RTDNibble2										// Read offset pointer into Y
	ldx 	4 													// Output nibble from 4,5,6 and 7.
	call 	__RTDNibble 										// offset pointer is reloaded on exit.
	ldx 	5
	call 	__RTDNibble
	ldx 	6
	call 	__RTDNibble
	ldx 	7
	call 	__RTDNibble

	lcall 	OSUpdateDisplay 									// Update the display.
	tcy 	__LinePointer										// Bump line pointer
	imac
	tamiyc 														// Save and point to offset pointer
	imac 														// Read and increment and update
	tam 														// Write back
	tay 														// Put in Y
	ynec 	6 													// Do for offsets 1-5.
	br 		__RTDLoop

	lbr 	OSExternalRenderTextExit 							// Exit the rendering.

__RTDNibble
	tma 														// Read the (X,Offset) into 
	tdo 														// Put on output lines.
	ldx 	0 													// Back to page 0.
	tcy 	HWNotDataClock 										// now controlling the data clock
	rstr  														// 1->0->1 pulse on data clock
	setr
__RTDNibble2
	tcy 	__OffsetPointer 									// Read the offset pointer into Y for next time
	tmy
	retn			

// ***********************************************************************************************************************************************
//
//	Call to switch polarity. Leaves !DC = 0 on exit, so that the next word latch (a rising edge on !DC) clocks in the data
//	at the right time - setting it back to 1 would cause a clock here. Decrement the sound timer if it is greater than zero.
//
// ***********************************************************************************************************************************************

OSSwitchPolarity
 	ldx 	0
	tcy 	OSDSoundTimer 										// Point Y to sound timer
	dman 														// Load and decrement, S set if wasn't zero.
	br 		__SPNotZero
	cla 														// If was zero, leave it at zero
__SPNotZero
	tam 														// Write it back.
	tcy 	HWLatchPulse										// On Entry, !DC = 1, LP = 0
	setr														// !DC = 1, LP = 1 - copies the addressed latches to the holding latches (no effect)
	tcy		HWNotDataClock 										// set !dataclock to 0
	rstr
	tcy 	HWLatchPulse 										// Falling Edge on Latch Pulse with !DC = 0, toggles polarity
	rstr
	retn 														// Leave !DC = 0 for latching next word.

// ***********************************************************************************************************************************************
//
//										Clear the display space to 0 (digit) and all spaces
//
// ***********************************************************************************************************************************************

OSClearDisplaySpace
	tcy 	5 													// Start at offset 5
	cla  														// Value to write out
__CDSLoop
	ldx 	4 													// Write to bank 4,5,6,7 in turn.
	tam
	ldx 	5
	tam
	ldx 	6
	tam
	ldx 	7 			
	tamdyn 														// Keep doing until Y goes -ve
	br 		__CDSLoop
	retn

	page

// ***********************************************************************************************************************************************
//
//												Random Number Generator (preserves Y), sets X to zero.
//	
// ***********************************************************************************************************************************************
//														Page 2 ($080) [1 byte spare]
// ***********************************************************************************************************************************************

OSRandomNumber
	ldx 	0 													// Access page 0.
	tya 														// Save Y in NotDataClock temp
	tcy 	HWNotDataClock
	tam 
    tcy     __XNRandom                   						// read XNext
    tma                                 						// A = XNext value
    tcy     __CNRandom                    						// Y points to CNext
    alem                                						// S set if XNext <= CNext
    br      __OSRLNoDecrement           	  					// so clear if CNext < XNext
    dan                           		      					// so A = XNext-1 if CNext < XNext
__OSRLNoDecrement
    xma                                 						// now : A is old CNext, CNext is XNext maybe -1
    tcy     __XNRandom                   						// now calculate XNext := XNext + old CNext + 1
    amaac                               						// add XNext to old CNext
    iac                                 						// add one
    tam                                 						// write back to XNext
    tcy 	HWNotDataClock 										// restore Y
    tmy
    retn

// ***********************************************************************************************************************************************
//
//								Same as render text display but calls OSUpdateGraphic on each bank first
//	
// ***********************************************************************************************************************************************

OSUpdateAllAndRenderTextDisplay
	ldx 	0 													// Save Y (vertical position) in NotDataClock temp in bank 0
	tya
	tcy 	HWNotDataClock
	tam
	ldx 	4 													// Update 4 banks
	lcall 	OSUpdateGraphic
	ldx 	5
	lcall 	OSUpdateGraphic
	ldx 	6
	lcall 	OSUpdateGraphic
	ldx 	7
	lcall 	OSUpdateGraphic
	ldx 	0 													// Restore vertical position
	tcy 	HWNotDataClock
	tmy
	lbr 	OSRenderTextDisplay 								// and then render the text

// ***********************************************************************************************************************************************
//
//									Add 1, 10, 100 to current 'score' in banks 4,5,6,7 - if used as score.
//
//	These routines are jump in jump out routines.
//
// ***********************************************************************************************************************************************

OSIncrementHundred
	tcy 	1 													// Jump into hundreds
	br 		__Increment100
OSIncrementTen
	tcy 	1 													// Jump into tens
	br 		__Increment10
OSIncrementOne
	ldx 	7 													// Start at least significant digit
	tcy 	1 													// Carry forward 1 to start with
	call 	__Increment  										// Add into first digit, carry out is in Y
__Increment10
	ldx 	6 													// tens
	call 	__Increment
__Increment100
	ldx 	5 													// hundreds
	call 	__Increment
	ldx 	4 													// thousands
	call 	__Increment
	lbr 	OSExternalIncrementExit

																// Add Y to (X,0) - fix for decimal - Y is carry out
__Increment
	tya 														// Save carry forward in A
	tcy 	0 													// Point to digit (e.g. M(X,0))
	amaac 														// add current digit to the carry forward
	tam 														// Write it back to M(X,0)
	a6aac 														// add 6, S if overflow (e.g. it was 10, decimal carry)
	br 		__Overflow 
	retn 														// No overflow, return Y = 0 e.g. no carry forward.
__Overflow
	tcmiy 	0 													// reset current digit to zero, set Y to 1 carry forward
	retn 														// and exit - handy instruction :)


// ***********************************************************************************************************************************************
//
//															Start of Main Program
//
// ***********************************************************************************************************************************************

	page

__StartProgram

//	Updates
//
//	17-1-14			Changes OSUpdateDisplay and OSSwitchPolarity to set X = 0 at the start, pretty much compulsory.
//					(all change X except OSWriteBits* which can work in any page if you sacrifice or preserve (X,7))
//