6502 Forth like tiny OS#

;
; LCD.AS
;
; Implements a "FORTH-like" operating system on a small 6502 SBC.
; The hardware includes a 6502 running at 1 Mhz, a 6522, 2 KB of RAM,
; 10 KB of EEPROM, a 4-line by 16-char LCD display, and a 22-key keyboard.
; The keyboard is scanned via the 6522 ports. Keys include hex chars 0 thru
; F, Space, <CR>, and <BS>. The keyboard is scanned via polling, whenever no
; other code is executing.
; The LCD display is mapped into memory.
; The SBC has other hardware features that are not currently used.
;
; All keystrokes are in hex. The OS identifies the purpose of a keyword
; based on it's length:
;   1-char symbols are simple functions (currently Examine and Deposit)
;   2-char symbols are byte values
;   3-char symbols are FORTH-like 'words'
;   4-char symbols are word values.
; Example: A3C2 5B F00
; The above line would do the following: push the word $A3C2 onto the stack,
; push the byte $5B onto the stack, then execute word 'F00'.
;
; 'Word' definitions are stored in an 8K EEPROM at $C000. The storage is
; divided into 32-byte blocks - all words start on a 32-byte boundary.
; The first byte of a block indicates the contents of the block:
;   0 - deleted or unused block
;   1 - block contains space-delimited tokens
;   2 - block contains executable code, ending with RTS
; The 2nd thru 4th bytes of a block contain the word's name, in ASCII.
; The remainder of the block contains either tokens or code.
;
; A number of words are defined so far:
;   E   examine memory (addr on top of stack)
;   D   deposit to memory (addr and data on stack)
;   CCC   compile a new word into EEPROM (finds an empty block)
;   001   POP - pop a byte from the stack
;   002   INCW - increment a word on the top of the stack
;   003   DUPW - duplicate a word
;   004   READ - read an addr - pop/read the addr, push the result byte
;   005   PRINTBNS - print a byte value
;   006   PRINTB - print a byte value plus a trailing space
;   007   PRINTW - print a word value plus a trailing space
;   008   DELAY - a short time delay - param is a byte
;   009   LDELAY - time delay, 1-second increments
;   00A   WRITE - write a location - addr word and data byte are on stack
;   00B   ADD - add 2 bytes on the stack, push the result
;   00C   SUB - subtract 2 bytes
;   00D   SHIFT-R - right-shift a byte
;   00E   SHIFT-L - left-shift a byte
;   00F   INC - increment a byte
;   010   DEC - decrement a byte
;   011   DO - the 'do' of a do-while loop
;   012   WHILE - the 'while' of a do-while loop
;
; The 'E' word examines/displays a memory location, but formats the
; output to be a subsequent 'D' command. For example, you enter:
;   0400 E
; then the next display line becomes:
;   0400 12 D
; where 12 is the current contents of address 0400. The cursor is
; sitting on the '1' in '12', so you can enter a new value easily
; if desired (just press Enter and the value is unchanged).
; After entering a new value, press Enter, and the display is now:
;   0401 AB D
; - note that the address incremented, and 'AB' is the current contents.
;
; The compile (CCC) word creates a new token-style word definition in
; the first available unused block (code-style words must be entered
; manually, using the 'D' command).
; Example:  CCC BAA 89 005
; This example compiles a new word, named 'BAA'. The function of BAA
; is to push $89 on the stack, then print that value.


;
; RAM is 0000-0800
; 6522 I/O is at "VIA" (2000-200F)
;   CA1 is for falling-edge priority interrupts
;   CA2
;   CB2 is SR out
;   CB1 is SR clock out
;   PA0-2 are inputs for keyboard scan
;     PA3
;     PA4-6 is interrupt priority
;     PA7
;   PB0-7 are outputs for keyboard scan

OUTBUF     EQU     $0040           ; transmit buffer
INBUFF     EQU     $0080           ; receiver buffer
ZPIND      EQU   $00FC      ; for indirect LDA/STA
DSTACK      EQU   $0700      ; bottom of Data Stack
VIA             EQU     $2000           ; address of 6522 VIA
ACIA            EQU     $4000           ; address of 6551 ACIA
LCD0      EQU   $6000      ; LCD display
LCD1      EQU   $6001
EE8K      EQU   $C000      ; FORTH 'word' storage, 8KB
EEPROM      EQU   $F800      ; boot and kernel code, 2KB

;
; 6522 VIA definitions
;
ORG     VIA
ORB     .DS     1               ;Output Register B
IRB     EQU     ORB             ;Input Register B
ORA     .DS     1               ;Output Register A
IRA     EQU     ORA             ;Input Register A
DDRB    .DS     1               ;Data Direction Register B
DDRA    .DS     1               ;Data Direction Register A
T1CL    .DS     1               ;read:  T1 counter, low-order
;write: T1 latches, low-order
T1CH    .DS     1               ;T1 counter, high-order
T1LL    .DS     1               ;T1 latches, low-order
T1LH    .DS     1               ;T1 latches, high-order
T2CL    .DS     1               ;read:  T2 counter, low-order
;write: T2 latches, low-order
T2CH    .DS     1               ;T2 counter, high-order
SR      .DS     1               ;Shift Register
ACR     .DS     1               ;Auxiliary Control Register
PCR     .DS     1               ;Peripheral Control Register
IFR     .DS     1               ;Interrupt Flag Register
IER     .DS     1               ;Interrupt Enable Register

;
; 6551 ACIA definitions
;
ORG     ACIA
ATXM    .DS     1               ;Transmitter Register (write only)
ARCX    EQU     ATXM            ;Receiver Register (read only)
ASTS    .DS     1               ;Status Register (read only)
ARES    EQU     ASTS            ;Soft Reset  (write only)
ACMD    .DS     1               ;Command Register
ACTL    .DS     1               ;Control Register

;
; page zero variable declarations
;
ORG     $0000
KBUFF   .DS   32   ; keyboard input buffer
ORACOP  .DS     1       ; copy of 6522 ORA
IFRCOP  .DS     1       ; copy of 6522 IFR
DLYCNT  .DS     1       ; delay counter
OUTNDX  .DS     1       ; output char index
UASTAT  .DS     1       ; UART status
FDA     .DS     1
CURSOR  .DS     1   ; LCD cursor location
TEMP    .DS     1
FRADLO  .DS     1
FRADHI  .DS     1
FCNT    .DS     1
FFDA    .DS     1
FRENLO  .DS     1
FRENHI  .DS     1
ECNTLO  .DS     1
ECNTHI  .DS     1
TOADLO  .DS     1
TOADHI  .DS     1
KEY   .DS   1
TOKEN1   .DS   1   ; ptr: beginning of token
TOKEN2   .DS   1   ; ptr: end of token
DSP   .DS   1   ; data stack pointer
ASCBYT   .DS   2
TKLEN   .DS   1   ; token length
EEPTR   .DS   2   ;
WLETT   .DS   1   ;
BTYPE   .DS   1   ; type: tokens, code, deleted
BUFFPTR   .DS   2   ; ptr to current token buffer
TKTMP   .DS   1
COMPTR   .DS   2   ; ptr used by Compile

ORG     INBUFF
INNDX   .DS     1       ; input buffer index



ORG   EEPROM   ; $F800

LCDBUSY:
; wait for the LCD to not be busy
PHA
L1:   LDA   LCD0
AND   #$80
BNE   L1
PLA
RTS

LCDINIT:
; init the LCD display
LDX   #$04      ; do it 4 times
L0:   LDA   #$38      ;
STA   LCD0
JSR   LCDBUSY
DEX
BNE   L0
LDA   #$06      ;
STA   LCD0
JSR   LCDBUSY
LDA   #$0E      ;
STA   LCD0
JSR   LCDBUSY
LDA   #$01      ; clear display
STA   LCD0
JSR   LCDBUSY
LDA   #$90      ; start on 3rd line
STA   CURSOR      ; init cursor location
STA   LCD0
JSR   LCDBUSY
RTS



ORG   $F850
SCROLL:
; Treat the 4 X 16 display as 2 lines of 32 char each.
; scroll everything up one line
; leave cursor at start of 2nd line (3rd physical line)
LDX   #$00      ; index, beginning of kybd buffer
LDA   #$90      ; 3rd line
S6:   STA   LCD0      ; set cursor pos
JSR   LCDBUSY
S1:   LDA   LCD1      ; get char from display
STA   KBUFF,X      ; copy char to buffer
JSR   LCDBUSY
INX         ; next char
CPX   #$20      ; all done?
BEQ   S2      ; yes
CPX   #$10      ; end of line?
BNE   S1      ; no
LDA   #$D0      ; yes, goto 4th display line
BNE   S6
S2:   ; copy buffer to 1st line
LDX   #$00      ; beginning of buffer
LDA   #$80      ; 1st line
S5:   STA   LCD0      ; set cursor pos
JSR   LCDBUSY
S3:   LDA   KBUFF,X      ; get char from buffer
STA   LCD1      ; write to display
JSR   LCDBUSY
INX         ; next char
CPX   #$20      ; all done?
BEQ   S4      ; yes
CPX   #$10      ; end of line?
BNE   S3      ; no
LDA   #$C0      ; yes, goto 2nd line
BNE   S5
S4:   ; fill 3rd and 4th lines with spaces
LDA   #$90      ; goto 3rd line
JSR   BLNKLN
LDA   #$D0      ; goto 4th line
JSR   BLNKLN
; move cursor to start of 3rd physical line
LDA   #$90
STA   CURSOR
STA   LCD0
JSR   LCDBUSY
RTS

BLNKLN:
; fill a 16-char line with spaces
STA   LCD0
JSR   LCDBUSY
LDX   #$10      ; line len is 16.
BL1:   LDA   #$20      ; write a space
STA   LCD1
JSR   LCDBUSY
DEX
BNE   BL1
RTS


ORG   $F8E0

PRINTCH:
; Display a char at the current cursor location.
;   80...8F 1st line
;   C0...CF 2nd line
;   90...9F 3rd line
;   D0...DF 4th line
CMP   #$0D      ; <CR> ?
BNE   P1      ; no
JMP   SCROLL      ; yes, just scroll and return
P1:   CMP   #$08      ; backspace ?
BNE   P2      ; no
JMP   BACKSPACE   ; yes, just BS and return
P2:   STA   LCD1      ; display it
JSR   LCDBUSY
; decide where the next char should go
LDX   CURSOR      ; get cursor location
INX         ; move cursor forward
CPX   #$E0      ; end of 4th line?
BNE   P4      ; no
DEX         ; yes, stay where we were
P4:   CPX   #$A0      ; end of 3rd line?
BNE   P3      ; no
LDX   #$D0      ; yes, begin 4th line
P3:   STX   CURSOR      ; remember new location
STX   LCD0      ; set the new location
JSR   LCDBUSY
RTS


ORG   $F90F

BACKSPACE:
; backup the cursor one space
LDX   CURSOR
CPX   #$D0      ; beginning of 4th line?
BNE   BS1      ; no
LDX   #$A0      ; yes, goto end of 3rd line
BS1:   CPX   #$90      ; beginning of 3rd line?
BEQ   BS2      ; yes, do nothing
DEX         ; no, backup one space
NOP
BS2:   STX   CURSOR      ; remember new location
STX   LCD0      ; set new location
JSR   LCDBUSY
LDA   #$20      ; print a space to overwrite old char
STA   LCD1
JSR   LCDBUSY
LDA   CURSOR      ; put cursor back on the space
STA   LCD0
JSR   LCDBUSY
RTS


ORG   $F950

DOKEY:
; handle an input char
PHA         ; save A
JSR   PRINTCH      ; print it
PLA         ; restore A
CMP   #$0D      ; <CR> ?
BNE   D1      ; no, we're done
JSR   PARSEK      ; yes, parse the input line
D1:   RTS

KBDINIT:
LDA     #$82            ; enable CA1 ints from 6522
; STA     IER
NOP
NOP
NOP
LDA     #$00
STA     DDRA            ; port A is input
STA     ORB             ; all 0's on output port
STA     INNDX           ; init inbuff index
LDA     #$FF
STA     DDRB            ; port B is output
RTS

CHKKBD:
; get the key (if pressed)
; the key is returned in A
; if no key pressed, return 00
LDY   #$FE      ; start with 11111110
C1:   STY   ORB      ; scan 1 of 8 rows
LDA   IRA      ; read the column
AND   #$07      ; lower 3 bits only
CMP   #$07      ; key ?
BNE   C2      ; yes, go decode it
TYA         ; no
BMI   C3      ; is it 01111111 yet?
LDA   #$00      ; yes, no key was pressed
RTS         ;   quit - return 00
C3:   SEC         ; no
ROL   A      ; shift left
TAY         ; put the pattern back in Y
CLC         ; go scan the next row
BCC   C1
C2:   STA   KEY      ; save the column info
TYA         ; get the row
LDY   #$00      ; init counter
C4:   INY         ; count
LSR   A      ; shift the row
BCS   C4      ; until the 0 falls out
TYA         ; get the row-count
ASL   A      ; move it to the higher bits
ASL   A
ASL   A
ORA   KEY      ; combine row and column
; decode the key value into ASCII
LDX   #$17
C6:   CMP   KEYTAB,X
BEQ   C5
DEX
BPL   C6
LDA   #$00
BEQ   C7
C5:   LDA   ASCTAB,X
C7:   STA   KEY      ; save the ASCII key
LDA   #$14      ; wait for debounce
JSR   DELAY
JSR   WAITNOKEY   ; wait for no key
LDA   #$30      ; wait for debounce
JSR   DELAY
JSR   WAITNOKEY   ; wait for no key
LDA   KEY      ; get the ASCII key char
RTS         ; return the char

WAITNOKEY:
; wait for no key being pressed
LDA   #$00
STA   ORB
W1:   LDA   IRA
AND   #$07
CMP   #$07
BNE   W1
RTS

KEYTAB:            ; keyboard codes
.BYTE   $0D
.BYTE   $3E
.BYTE   $3D
.BYTE   $26
.BYTE   $25
.BYTE   $36
.BYTE   $35
.BYTE   $2E
.BYTE   $2D
.BYTE   $46
.BYTE   $45
.BYTE   $16
.BYTE   $15
.BYTE   $1E
.BYTE   $1D
.BYTE   $0E
.BYTE   $23
.BYTE   $13
.BYTE   $2B
.BYTE   $0B
.BYTE   $33
.BYTE   $1B
.BYTE   $00   ; not used
.BYTE   $00   ; not used
ASCTAB:         ; ASCII codes
.BYTE   $30   ; 0
.BYTE   $31
.BYTE   $32
.BYTE   $33
.BYTE   $34
.BYTE   $35
.BYTE   $36
.BYTE   $37
.BYTE   $38
.BYTE   $39   ; 9
.BYTE   $41   ; A
.BYTE   $42
.BYTE   $43
.BYTE   $44
.BYTE   $45
.BYTE   $46   ; F
.BYTE   $00
.BYTE   $00
.BYTE   $00
.BYTE   $20   ; space
.BYTE   $08   ; backspace
.BYTE   $0D   ; <CR>
.BYTE   $00   ; not used
.BYTE   $00   ; not used



ORG   $FA30
PARSEK:
; Check the input line, see what to do.
; Process each token found on the line.
LDA   #$00      ; beginning of input line
STA   BUFFPTR      ; point to kybd buffer
STA   BUFFPTR+1
STA   TOKEN1
PK1:   JSR   GETTOKEN   ; get the next token
JSR   DOTOKEN      ; process it
BNE   PK1      ; more tokens?
RTS

NOP
NOP

NOP
NOP
NOP
NOP

GETTOKEN:
; identify the next token in the current buffer
; BUFFPTR points to the buffer
; max buffer length is 32.
; TOKEN1 points to first char in token.
; TOKEN2 points to first space after token.
LDY   TOKEN1      ; start from here
GTLOOP:   LDA   (BUFFPTR),Y   ; get a char
CMP   #$00      ; end of buffer marker?
BEQ   G3      ; yes - quit
CMP   #$20      ; space?
BNE   SYM      ; no - it's a token
INY         ; yes - skip it
CPY   #$20      ; end of buffer?
BNE   GTLOOP      ; no, loop
G3:   LDA   #$00      ; yes, report no more tokens
STA   TOKEN2
GTDONE:   RTS         ; return
SYM:   STY   TOKEN1      ; point to beginning of token
GTL2:   INY         ; next char
CPY   #$20      ; end of buffer?
BNE   G1      ; no
G2:   STY   TOKEN2      ; yes, point to end of token
RTS
G1:   LDA   (BUFFPTR),Y   ; get next char
CMP   #$20      ; space?
BNE   GTL2      ; no, loop
BEQ   G2      ; yes, quit

NOP
NOP
NOP
NOP
NOP
NOP

DOTOKEN:
; Process a token from the current buffer.
; Process each token based on it's length.
; Len of 1 is a 'kernel' command.
; Len of 3 is a command word.
; Len of 2 is a byte value.
; Len of 4 is a word value.
LDA   TOKEN2      ; was a token found?
BEQ   DT1      ; no, quit
SEC         ; yes, determine it's length
SBC   TOKEN1      ; subtract
STA   TKLEN      ; save the length
CMP   #$01
BNE   DT2
JSR   ONE
CLC
BCC   DT1
DT2:   LDA   TKLEN
CMP   #$02
BNE   DT3
JSR   TWO
CLC
BCC   DT1
DT3:   LDA   TKLEN
CMP   #$03
BNE   DT4
JSR   THREE
CLC
BCC   DT1
DT4:   LDA   TKLEN
CMP   #$04
BNE   DT5
JSR   FOUR
CLC
BCC   DT1
DT5:   LDA   #$00      ; unsupported token length
STA   TOKEN2
DT1:   LDA   TOKEN2
STA   TOKEN1
RTS

ONE:
; Is it a 'D'?
LDY   TOKEN1
LDA   (BUFFPTR),Y   ; get the letter
CMP   #'D
BEQ   DEPOSIT
CMP   #'E
BEQ   EXAMINE
RTS

TWO:
; push a byte onto the dstack
; convert ASCII byte to binary
LDY   TOKEN1      ; point to hi-order char
JSR   CVTBYT
JMP   PUSH      ; push onto dstack

THREE:
; It's a command 'word'. Execute it.
JMP   DOWORD

FOUR:
; Push a word onto the dstack. Do it hi-byte first,
; so that it can be used as a pointer directly.
LDY   TOKEN1
JSR   CVTBYT
NOP
NOP
NOP
NOP
JSR   PUSH
NOP
NOP
JSR   CVTBYT
JMP   PUSH      ; push lo byte

DEPOSIT:
JSR   POP
JSR   DUPW
JSR   WRITEA
LDA   #$01
JSR   DELAY
JSR   INCW
EXAMINE:
JSR   DUPW
JSR   PRINTW
JSR   READ
JSR   PRINTB
LDA   #'D
JSR   PRINTCH
; backup cursor 4 spaces
LDX   CURSOR
DEX
DEX
DEX
DEX
STX   CURSOR      ; remember new location
STX   LCD0      ; set new location
JSR   LCDBUSY
RTS

CVTBYT:
; Get an ASCII byte from the buffer, convert to binary.
LDA   (BUFFPTR),Y
JSR   BINBYT      ; convert to binary
ASL   A      ; move to upper nibble
ASL   A
ASL   A
ASL   A
STA   TEMP      ; save it
INY         ; get lo-order char
LDA   (BUFFPTR),Y
JSR   BINBYT      ; convert to binary
CLC         ; add upper nibble
ADC   TEMP
INY         ; point to next char
RTS

NOP
NOP
NOP
NOP
NOP
NOP


ORG   $FB80

PUSH:
; push A onto the dstack
LDX   DSP
STA   DSTACK,X
DEC   DSP
RTS

POP:
; pop A from the dstack
INC   DSP
LDX   DSP
LDA   DSTACK,X
RTS

INCW:
; Increment the word on the top of the stack,
; but don't pop it.
LDX   DSP
INX
INC   DSTACK,X
BNE   IW1
INX
INC   DSTACK,X
IW1:   RTS

WRITEA:
; Write A to the location indicated by the word
; on the top of the stack.
; Preserve A, pop the address.
PHA
LDA   #$8D
STA   ZPIND
JSR   POP
STA   ZPIND+1
JSR   POP
STA   ZPIND+2
LDA   #$60
STA   ZPIND+3
PLA
JSR   ZPIND
RTS

DUPW:
; Push a duplicate of the word that is already
; on the top of the stack.
; Preserve A.
PHA
LDY   DSP
INY
INY
LDA   DSTACK,Y
JSR   PUSH
DEY
LDA   DSTACK,Y
JSR   PUSH
PLA
RTS

READ:
; Read a memory location, specified by the addr
; on the stack. Pop the address, and push the
; result. Also return the result in A.
LDA   #$AD
STA   ZPIND
JSR   POP
STA   ZPIND+1
JSR   POP
STA   ZPIND+2
LDA   #$60
STA   ZPIND+3
JSR   ZPIND
JSR   PUSH
RTS

PRINTBNS:
; Print a byte value in hex at the
; current cursor location. Do NOT include a space.
JSR   POP
JSR   BYTEHEX
LDA   ASCBYT
JSR   PRINTCH
LDA   ASCBYT+1
JSR   PRINTCH
RTS

PRINTB:
; Print a byte value in hex at the
; current cursor location. Include a space.
JSR   PRINTBNS
LDA   #$20
JSR   PRINTCH
RTS

PRINTW:
; Print a word value in hex at the
; current cursor location. Include a space.
JSR   POP
PHA
JSR   PRINTBNS
PLA
JSR   PUSH
JSR   PRINTB
RTS

DOWORD:
; process a 3-letter word from the current buffer
; save the current BUFFPTR and TOKEN2
LDA   BUFFPTR
PHA
LDA   BUFFPTR+1
PHA
LDA   TOKEN2
PHA
; find the word's definition block
LDA   #$00      ; point to start of word defs
STA   EEPTR
LDA   #$C0
STA   EEPTR+1
DW3:   LDA   TOKEN1
STA   TKTMP
LDY   #$00      ; check block type
LDA   (EEPTR),Y
STA   BTYPE
BNE   DW1      ; deleted?
DW2:   LDA   EEPTR      ; yes - goto next block
CLC
ADC   #$20      ; blk size is 32.
STA   EEPTR
BCC   DW5
INC   EEPTR+1
LDA   EEPTR+1
CMP   #$D8      ; end of EE ?
BEQ   DWDONE
DW5:   CLC         ; loop back
BCC   DW3
DW1:   INY         ; check the symbol
LDA   (EEPTR),Y
STA   WLETT
TYA         ; save Y
TAX
LDY   TKTMP      ; get token letter
LDA   (BUFFPTR),Y
CMP   WLETT      ; letter match?
BNE   DW2      ; no - goto next block
TXA         ; restore Y
TAY
INC   TKTMP      ; yes - next letter
CPY   #$03      ; done?
BNE   DW1      ; no - next letter
; found matching word block!
LDA   BTYPE      ; check blk type
CMP   #$01      ; tokens?
BEQ   DW7      ; yes
CMP   #$02      ; code?
BEQ   DW4      ; yes
BNE   DWDONE      ; unknown - quit

NOP
NOP
DW7:
; found token block - point to 1st token
INY         ; point to space before token
INY         ; point to first letter of token
; process tokens
STY   TOKEN1
STY   TOKEN2
; set the BUFFPTR to match EEPTR
LDA   EEPTR
STA   BUFFPTR
LDA   EEPTR+1
STA   BUFFPTR+1
; recurse
DW6:   JSR   GETTOKEN   ; get a token
JSR   DOTOKEN      ; process it
BNE   DW6      ; more tokens?
DWDONE:
; restore the BUFFPTR and TOKEN1
PLA
STA   TOKEN2
STA   TOKEN1
PLA
STA   BUFFPTR+1
PLA
STA   BUFFPTR
RTS
DW4:   ; process code
LDA   #$4C      ; make a JMP in 0-page
STA   ZPIND
LDA   EEPTR      ; point to the block
CLC
ADC   #$04      ; the 4th byte is the start
STA   ZPIND+1
LDA   EEPTR+1
STA   ZPIND+2
JSR   ZPIND      ; make the call
CLC         ; done
BCC DWDONE

NOP
NOP
NOP
NOP
NOP
NOP

COMPILE:
; Compile a new word into EE. The definition is
; in (BUFFPTR)+TOKEN2 .
; find an unused or deleted block
LDA   #$00      ; EE starts at $C000
STA   COMPTR
LDA   #$C0
STA   COMPTR+1
COM1:   LDY   #$00      ; 1st byte of blk is type
LDA   (COMPTR),Y   ; get block type
CMP   #$01      ; token block?
BEQ   USEDBL      ; yes - find another
CMP   #$02      ; code block?
BEQ   USEDBL      ; yes - find another
; this block is free!
; (BUFFPTR)+TOKEN2 points to space before 1st token
LDA   #$00
STA   TKTMP
; (COMPTR)+TKTMP now points to block type
LDA   #$01      ; write the block type
JSR   EEWRT
COM2:   INC   TKTMP      ; next output index
INC   TOKEN2      ; next input index
LDY   TOKEN2      ; beyond end of input buffer?
CPY   #$20
BEQ   DONULL      ; yes
LDA   (BUFFPTR),Y   ; get a char from buffer
JSR   EEWRT      ; write the char
CLC         ; do next char
BCC   COM2
DONULL:   LDA   #$00      ; write a null terminator
JSR   EEWRT
COMDONE:
LDA   #$00      ; don't process rest of buffer
STA   TOKEN2
RTS         ; return
USEDBL:   LDA   COMPTR      ; goto next block
CLC
ADC   #$20      ; blk size is 32.
STA   COMPTR
BCC   COM1
INC   COMPTR+1
LDA   COMPTR+1
CMP   #$D8      ; limit of blocks ?
BEQ   COMDONE      ; yes - quit
BNE   COM1      ; no - try this block
EEWRT:   LDY   TKTMP      ; get index
STA   (COMPTR),Y   ; write the char
LDA   #$0D      ; wait 50ms for EE to finish
JSR   DELAY
RTS

ORG   $FDA0

BOOT:
;
; The Reset vector (FFFC) points here.
;
SEI                     ; no IRQ interrupts
CLD                     ; no Decimal mode
JSR   LCDINIT
JSR   KBDINIT
LDA   #$C0
STA     ARES            ; ACIA soft reset
LDA     #$1A            ; 8-N-1, 2400 baud
STA     ACTL
LDA   #$FF
STA   DSP
; LDA     #$89            ; enable ACIA xmtr/rcvr
; STA     ACMD
NOP
NOP
NOP
NOP
NOP
CLI         ; enable ints
; print "OK"
LDA   #$4F      ; 'O'
JSR   PRINTCH
LDA   #$4B      ; 'K'
JSR   PRINTCH
LDA   #$0D      ; <CR>
JSR   PRINTCH

; Go into the idle loop.
; Check the kbd, about 60 times/second.
; Any other work must be interrupt-driven.
IDLE:   JSR   CHKKBD
BEQ   IDLE      ; no key
JSR   DOKEY      ; handle the key
LDA   #$04      ; delay
JSR   DELAY
CLC         ; loop
BCC   IDLE



ORG   $FE00
BINBYT:
; Convert a single hex-ascii char to binary.
CMP     #$60
BMI     BB2
AND     #$DF
BB2:
SEC
SBC     #$30
CMP     #$11
BMI     BB1
SEC
SBC     #$07
BB1:
RTS

; Convert the value in A into two hex-ascii bytes, and store
; the two bytes in ASCBYT.
BYTEHEX:
PHA                     ; save the byte
LSR     A               ; do the high nibble first
LSR     A
LSR     A
LSR     A
CLC                     ; make it ascii
ADC     #$30
CMP     #$3A            ; if it's a letter, add a little more
BMI     BH3
CLC
ADC     #$07
BH3:
STA     ASCBYT        ; store the ascii byte
PLA                     ; get the original byte
AND     #$0F            ; do the low nibble
CLC                     ; make it ascii
ADC     #$30
CMP     #$3A
BMI     BH4
CLC
ADC     #$07
BH4:
STA     ASCBYT+1        ; store the 2nd ascii byte
RTS

; Time delay.
; Put the delay value in A. A value of 00 is 256 loops (max delay).
; With 256 loops, the number of machine cycles is: 329479+131072N,
; where N is the number of NOP instructions. If N is 5, and the
; clock is 1 Mhz, then the max delay is 0.985 seconds, or 3.85 ms
; per loop. If N is 12, and the clock is 1.8432 Mhz, then the max
; delay is 1.032 seconds, or 4.03 ms per loop.
; X and Y are preserved, Status is not.
; Location DLYCNT is used for temp storage.
DELAY:
STA DLYCNT
TXA             ; save X
PHA
LDX #$0 ; init X
DLOOP:
INX             ; waste time
NOP
NOP
NOP
NOP
NOP
BNE DLOOP       ; did X wrap?
DEC DLYCNT      ; yes, decrement counter
BNE DLOOP       ; are we done? No - loop again.
PLA             ; we're done - restore X
TAX
RTS             ; return

; Do longer delays, in multiples of about 1 second.
; Put the desired delay in A.
; A value of 00 will return immediately.
LDELAY:
BEQ LDELAY2     ; if 00, return right away
TAX             ; save the counter in X
LDELAY1:
LDA #$00        ; do a 1-second delay
JSR DELAY
DEX             ; DEC the counter
BNE LDELAY1     ; done?
LDELAY2:
RTS             ; yes - return

;
; NMI entry point.
;
NMI:
RTI

;
; IRQ entry point.
;
IRQ:
RTI         ; return from interrupt


; INTERRUPT AND RESTART VECTORS
ORG     $FFFA
.WORD   NMI             ; NMI vector
.WORD   BOOT            ; Cold start & reset vector
.WORD   IRQ             ; IRQ vector (and BRK vector)
.END    BOOT

Add new attachment

Only authorized users are allowed to upload new attachments.
« This page (revision-1) was last changed on 05-Apr-2010 21:53 by Carsten Strotmann