Source code KIM-1
;
; Last update: 5 March 2004
;
;
; The source code is copied from 'KIM-1 MANUAL' released by MOS Technologies.
;
;
; I have checked the SRC line by line and added some comment of my own. I
; have compiled the SRC and found no differences with the original BIN. But
; this does not mean that it is without faults.
;
;
; The SRC can be assembled with my own programmed assembler. This assembler
; for the PC is available as freeware, including source code for FPC, the
; Free Pascal Compiler: http://www.freepascal.org/.
;
;
; Source code of the KIM-1
;
.eq PCL = $EF ; programcounter low
.eq PCH = $F0 ; programcounter high
.eq PREG = $F1 ; statusregister
.eq SPUSER = $F2 ; stackpointer
.eq ACC = $F3
.eq YREG = $F4
.eq XREG = $F5
.eq CHKHI = $F6
.eq CHKSUM = $F7
.eq INL = $F8 ; inputbuffer low
.eq INH = $F9 ; inputbuffer high
.eq POINTL = $FA ; addressL on display
.eq POINTH = $FB ; addressH on display
.eq TEMP = $FC
.eq TMPX = $FD
.eq CHAR = $FE
.eq MODE = $FF
.eq INL_A = $00F8 ; INL as absolute address
.eq CHKL = $17E7
.eq CHKH = CHKL+1
.eq SAVX = CHKL+2
.eq VEB = CHKL+5
.eq CNTL30 = CHKL+11
.eq CNTH30 = CHKL+12
.eq TIMH = CHKL+13
.eq SAL = CHKL+14
.eq SAH = CHKL+15
.eq EAL = CHKL+16
.eq EAH = CHKL+17
.eq ID = CHKL+18
.eq NMIV = CHKL+19 ; NMI-vector
.eq RSTV = CHKL+21 ; RESET-vector
.eq IRQV = CHKL+23 ; IRQ-vector
.eq SAD = $1740
.eq PADD = SAD+1
.eq SBD = SAD+2
.eq PBDD = SAD+3
.eq CLK1T = SAD+4
.eq CLK8T = SAD+5
.eq CLK64T = SAD+6
.eq CLKRDT = SAD+6 ; Read time
.eq CLKKT = SAD+7
.eq CLKRDI = SAD+7 ; Read time out bit
;
;
.ba $1800
;
; Dump memory on tape
DUMPT lda #$AD ; load absolute inst
sta VEB
jsr INTVEB
;
lda #$27 ; turn off datainput PB5
sta SBD
lda #$BF ; PB7 := output
sta PBDD
;
ldx #100 ; 100 characters
DUMPT1 lda #$16 ; sync chars
jsr OUTCHT
dex
bne DUMPT1
;
lda #$2A ; start char
jsr OUTCHT
;
lda ID ; output ID
jsr OUTBT
;
lda SAL ; output start address
jsr OUTBTC
lda SAH
jsr OUTBTC
;
DUMPT2 lda VEB+1 ; compare for last data byte
cmp EAL
lda VEB+2
sbc EAH
bcc DUMPT4
;
lda #$2F ; output EndOfData-char
jsr OUTCHT
lda CHKL ; output checksum
jsr OUTBT
lda CHKH
jsr OUTBT
;
ldx #2 ; 2 chars
DUMPT3 lda #4 ; EOT-char
jsr OUTCHT
dex
bne DUMPT3
;
lda #0 ; display 0000
sta POINTL
sta POINTH
jmp START
;
DUMPT4 jsr VEB ; output data byte
jsr OUTBTC
jsr INCVEB
jmp DUMPT2
;
; Load from tape into memory
TAB .wo LOAD12
LOADT lda #$8D ; initialize volatile execution
sta VEB ; block with sta abs
jsr INTVEB
;
lda #$4C ; code for JMP
sta VEB+3
lda TAB
sta VEB+4
lda TAB+1
sta VEB+5
;
; result: jmp LOAD12 (= $190F)
;
lda #7 ; reset PB5
sta SBD
;
SYNC lda #$FF ; clear SAVX for SYNC-area
sta SAVX
;
SYNC1 jsr RDBIT ; get a bit
lsr SAVX
ora SAVX
sta SAVX
lda SAVX ; get new char
cmp #$16 ; SYNC-char?
bne SYNC1
;
ldx #10 ; test for 10 SYNC-char
SYNC2 jsr RDCHT
cmp #$16 ; SYNC-char?
bne SYNC
dex
bne SYNC2
LOADT4 jsr RDCHT ; look for start of
cmp #$2A ; start char
beq LOAD11 ; yes ->
cmp #$16 ; SYNC-char?
bne SYNC ; no ->
beq LOADT4 ; always ->
;
LOAD11 jsr RDBYT ; read ID
cmp ID ; requested ID?
beq LOADT5 ; yes ->
lda ID
cmp #0 ; ignore ID?
beq LOADT5 ; yes ->
cmp #$FF ; ignore start address?
beq LOADT6 ; yes ->
bne LOADT ; next program, always ->
;
LOADT5 jsr RDBYT ; get SA from tape
jsr CHKT
sta VEB+1
jsr RDBYT
jsr CHKT
sta VEB+2
jmp LOADT7
;
LOADT6 jsr RDBYT ; get SA from tape
jsr CHKT ; but ignore
jsr RDBYT
jsr CHKT
;
LOADT7 ldx #2
LOAD13 jsr RDCHT
cmp #$2F ; last char?
beq LOADT8 ; yes ->
jsr PACKT ; convert to hex
bne LOADT9 ; Y=1, non-hex char
dex ; 2 chars?
bne LOAD13 ; no -> next one
jsr CHKT ; compute checksum
jmp VEB
;
LOAD12 jsr INCVEB ; increment datapointer
jmp LOADT7
;
LOADT8 jsr RDBYT ; EOD compare checksum
cmp CHKL
bne LOADT9
jsr RDBYT
cmp CHKH
bne LOADT9
lda #0
beq LOAD10 ; normal exit, always ->
;
LOADT9 lda #$FF ; error exit
LOAD10 sta POINTL
sta POINTH
jmp START ; display values
;
; Move start address to VEB+1,2
INTVEB lda SAL
sta VEB+1
lda SAH
sta VEB+2
lda #$60 ; code for RTS
sta VEB+3
lda #0
sta CHKL
sta CHKH
rts
;
; Compute checksum for tape load
CHKT tay
clc
adc CHKL
sta CHKL
lda CHKH
adc #0
sta CHKH
tya
rts
;
; Output one byte
OUTBTC jsr CHKT
OUTBT tay
lsr
lsr
lsr
lsr
jsr HEXOUT ; output MSD
tya
jsr HEXOUT ; output LSD
tya
rts
;
; Convert LSD of A to ASCII
HEXOUT and #$0F
cmp #10
clc
bmi HEX1
adc #7
HEX1 adc #$30
;
; Output to tape 1 ASCII
OUTCHT stx SAVX
sty SAVX+1
ldy #8 ; startbit
CHT1 jsr ONE
lsr ; get data bit
bcs CHT2
jsr ONE
jmp CHT3
CHT2 jsr ZRO
CHT3 jsr ZRO
dey ; all bits?
bne CHT1 ; no ->
ldx SAVX
ldy SAVX+1
rts
;
; Output a 1 to tape: 9 pulses of 138 us each
ONE ldx #9
pha
ONE1 bit CLKRDI ; wait for timeout
bpl ONE1
lda #126
sta CLK1T
lda #$A7
sta SBD ; PB7 := 1
ONE2 bit CLKRDI ; wait for timeout
bpl ONE2
lda #126
sta CLK1T
lda #$27
sta SBD ; PB7 := 0
dex ; all pulses?
bne ONE1 ; no ->
pla
rts
;
; Output a 0 to tape: 6 pulses of 207 us each
ZRO ldx #6
pha
ZRO1 bit CLKRDI ; wait for timeout
bpl ZRO1
lda #195
sta CLK1T
lda #$A7
sta SBD ; PB7 := 1
ZRO2 bit CLKRDI ; wait for timeout
bpl ZRO2
lda #195
sta CLK1T
lda #$27
sta SBD ; PB7 := 0
dex ; all pulses?
bne ZRO1 ; no ->
pla
rts
;
; Increment VEB+1,2
INCVEB inc VEB+1
bne INCVE1
inc VEB+2
INCVE1 rts
;
; Read byte from tape
RDBYT jsr RDCHT
jsr PACKT
RDBYT2 jsr RDCHT
jsr PACKT
rts
;
; Pack ASCII in A as hex data
PACKT cmp #$30 ; ASCII ?
bmi PACKT3 ; no ->
cmp #$47
bpl PACKT3 ; no ->
cmp #$40 ; > '9' ?
bmi PACKT1 ; no ->
clc
adc #9
PACKT1 rol
rol
rol
rol
ldy #4
PACKT2 rol
rol SAVX
dey
bne PACKT2
lda SAVX
;
; At this point Y already is 0 (= valid hex char)
ldy #0 ; set the zero flag
rts
;
; Y=0 at this point, done in label RDBIT4
PACKT3 iny ; Y:=1 = invalid hex char
rts
;
; Get 1 char from tape in A
RDCHT stx SAVX+2
ldx #8 ; read 8 bits
RDCHT1 jsr RDBIT
lsr SAVX+1
ora SAVX+1
sta SAVX+1
dex
bne RDCHT1
;
lda SAVX+1
rol
lsr
ldx SAVX+2
rts
;
; Get 1 bit from tape and return it in bit 7 of A
RDBIT bit SBD ; wait for end of startbit
bpl RDBIT
lda CLKRDT ; get start bit time
ldy #$FF ; A := 256 - T1
sty CLK64T
;
ldy #$14
RDBIT3 dey ; delay 100 us
bne RDBIT3
RDBIT2 bit SBD
bmi RDBIT2 ; wait for next start bit
;
sec
sbc CLKRDT
ldy #$FF
sty CLK64T
;
ldy #7
RDBIT4 dey ; delay 50 us
bne RDBIT4
;
eor #$FF ; complement sign
and #$80 ; mask sign
rts
;
; output 166 us pulse string for testing purposes
; No documentation found about this. I think it is used to
; calibrate the 565
PLLCALL lda #$27
sta SBD ; turn off datin PB5=1
lda #$BF
sta PBDD
;
PLL1 bit CLKRDI
bpl PLL1
lda #154 ; wait 166 us
sta CLK1T
lda #$A7 ; output PB7=1
sta SBD
;
PLL2 bit CLKRDI
bpl PLL2
lda #154
sta CLK1T
lda #$27 ; output PB7=0
sta SBD
jmp PLL1
.fb $FF, 356
NMIP27 .wo PLLCALL
RSTP27 .wo PLLCALL
IRQP27 .wo PLLCALL
;
;
;
; KIM-entry via NMI or IRQ [1C00]
SAVE sta ACC
pla
sta PREG
;
; KIM-entry via JSR
SAVEA pla
sta PCL
sta POINTL
pla
sta PCH
sta POINTH
;
SAVEB sty YREG
stx XREG
tsx
stx SPUSER
jsr INITS
jmp START
;
; NMI and IRQ are called via RAM vector. This enables the programmer
; to insert his own routines.
; Comment: is not initialized anywhere, so any accidental NMI or IRQ
; can lead to disaster !
NMIT jmp (NMIV)
IRQT jmp (IRQV)
;
; The KIM starts here after a reset
RESET ldx #$FF
txs ; set stack
stx SPUSER
jsr INITS
;
; Determine characters per second
DETCPS lda #$FF ; count startbit
sta CNTH30 ; zero CNTH30
;
; Test first keyboard or teleprinter
lda #1 ; mask bit 0
DET1 bit SAD ; test for teleprinter
bne START ; no ->
bmi DET1 ; no startbit, wait for it ->
lda #$FC
DET3 clc ; this loop counts startbit time
adc #1 ; A=0 ?
bcc DET2 ; no ->
inc CNTH30
DET2 ldy SAD ; check for end of startbit
bpl DET3 ; no ->
sta CNTL30
ldx #8
jsr GET5 ; get rest of char
;
; Make TTY/KB selection
START jsr INIT1
lda #1 ; read jumper
bit SAD ; TTY ?
bne TTYKB ; no -> keyboard/display routine
jsr CRLF ; print return/linefeed
ldx #$0A
jsr PRTST ; print 'KIM'
jmp SHOW1
;
;
CLEAR lda #0
sta INL ; clear inputbuffer
sta INH
;
READ jsr GETCH ; get char from TTY
cmp #1 ; 1 has no meaning for TTY
beq TTYKB ; 1 = KB-mode ->
jsr PACK
jmp SCAN
;
; Main routine for keyboard and display
TTYKB jsr SCAND ; wait until NO key pressed
bne START ; if pressed, wait again ->
TTYKB1 lda #1 ; check KB/TTY mode
bit SAD ; TTY?
beq START ; yes ->
jsr SCAND ; Wait for key...
beq TTYKB1 ; no key ->
jsr SCAND ; debounce key
beq TTYKB1 ; no key ->
;
GETK jsr GETKEY
cmp #$15 ; >= $15 = illegal
bpl START ; yes ->
cmp #$14
beq PCCMD ; display Program Counter
cmp #$10
beq ADDRM ; Addressmode
cmp #$11
beq DATAM ; datamode
cmp #$12
beq STEP ; step
cmp #$13
beq GOV ; execute program
;
; One of the hexadecimal buttons has been pushed
DATA asl ; move LSB key number to MSB
asl
asl
asl
sta TEMP ; store for datamode
ldx #4
DATA1 ldy MODE ; part of address?
bne ADDR ; yes ->
lda (POINTL),Y ; get data
asl TEMP
rol ; MSB-TEMP = MSB-key -> A
sta (POINTL),Y ; store new data
jmp DATA2
ADDR asl ; TEMP not needed here
rol POINTL ; MSB-key -> POINTL
rol POINTH ; POINTL -> POINTH
DATA2 dex ; 4 times = complete nibble?
bne DATA1 ; no ->
beq DATAM2 ; -> always
;
; Switch to address mode
ADDRM lda #1
bne DATAM1 ; -> always
;
; Switch to data mode
DATAM lda #0
DATAM1 sta MODE
DATAM2 jmp START
;
; Increment address on display
STEP jsr INCPT
jmp START
;
GOV jmp GOEXEC
;
; Display PC by moving it to POINT
PCCMD lda PCL
sta POINTL
lda PCH
sta POINTH
jmp START
;
; Load papertape from TTY
LOAD jsr GETCH
cmp #$3B ; ":", semicolon?
bne LOAD ; No -> again
LOADS lda #0
sta CHKSUM
sta CHKHI
;
jsr GETBYT ; get byte CNT
tax
jsr CHK ; Compute checksum
;
jsr GETBYT ; get address HI
sta POINTH
jsr CHK ; Compute checksum
;
jsr GETBYT ; get address LO
sta POINTL
jsr CHK ; Compute checksum
;
txa ; CNT = 0 ?
beq LOAD3
;
LOAD2 jsr GETBYT ; get DATA
sta (POINTL),y ; store data
jsr CHK
jsr INCPT
dex
bne LOAD2
inx ; X=1 = data record
; X=0 = last record
;
LOAD3 jsr GETBYT ; compare checksum
cmp CHKHI
bne LOADE1
jsr GETBYT
cmp CHKSUM
bne LOADER
;
txa ; X=0 = last record
bne LOAD
;
LOAD7 ldx #$0C ; X-OFF KIM
LOAD8 lda #$27
sta SBD ; disable data in
jsr PRTST
jmp START
;
LOADE1 jsr GETBYT ; dummy
LOADER ldx #$11 ; X-OFF error KIM
bne LOAD8 ; always ->
;
; Dump to TTY from open cell address to LIMHL, LIMHH
DUMP lda #0
sta INL
sta INH ; clear record count
DUMP0 lda #0
sta CHKHI ; clear checksum
sta CHKSUM
;
DUMP1 jsr CRLF
lda #$3B ; ":"
jsr OUTCH
;
; Check if POINTL/H >= EAL/H
lda POINTL
cmp EAL
;
lda POINTH
sbc EAH
bcc DUMP4 ; no ->
;
lda #0 ; print last record
jsr PRTBYT ; 0 bytes
jsr OPEN
jsr PRTPNT ;
lda CHKHI ; print checksum
jsr PRTBYT ; for last record
lda CHKSUM
jsr PRTBYT
jmp CLEAR
;
DUMP4 lda #$18 ; print 24 bytes
tax ; save as index
jsr PRTBYT
jsr CHK
jsr PRTPNT
;
DUMP2 ldy #0
lda (POINTL),y
jsr PRTBYT ; print data
jsr CHK
jsr INCPT
dex ; Printed everything?
bne DUMP2 ; No ->
;
lda CHKHI
jsr PRTBYT ; print checksum
lda CHKSUM
jsr PRTBYT
inc INL ; increment record counter
bne DUMP3
inc INH
DUMP3 jmp DUMP0
;
SPACE jsr OPEN ; open new cell
SHOW jsr CRLF
SHOW1 jsr PRTPNT
jsr OUTSP ; print space
ldy #0
lda (POINTL),y ; print data
jsr PRTBYT
jsr OUTSP ; print space
jmp CLEAR
;
RTRN jsr INCPT ; next address
jmp SHOW
; Start a program at displayed address. RTI is used as a comfortable
; way to define all flags in one move.
GOEXEC ldx SPUSER ; user defined stack
txs
lda POINTH ; program runs from
pha ; displayed address
lda POINTL
pha
lda PREG ; user defined Flag register
pha
ldx XREG
ldy YREG
lda ACC
rti ; start program
;
; Take care if TTY input
SCAN cmp #$20 ; open new cell
beq SPACE
cmp #$7F ; rub out, restart KIM
beq STV
cmp #$0D ; next cell
beq RTRN
cmp #$0A ; prev cell
beq FEED
cmp #$2E ; "." = modify cell
beq MODIFY
cmp #$47 ; "G" = exec program
beq GOEXEC
cmp #$51 ; "Q" = dump from open cell
beq DUMPV ; to HI limit
cmp #$4C ; "L" = load tape
beq LOADV
jmp READ ; ignore illegal CHAR
;
STV jmp START
DUMPV jmp DUMP
LOADV jmp LOAD
;
FEED sec
lda POINTL ; decrement POINTL/H
sbc #1
sta POINTL
bcs FEED1
dec POINTH
FEED1 jmp SHOW
;
MODIFY ldy #0 ; get contents of input buffer
lda INL ; INL and store in location
sta (POINTL),y ; specified by POINT
jmp RTRN
;
; Subroutine to print POINT = address
PRTPNT lda POINTH
jsr PRTBYT
jsr CHK
lda POINTL
jsr PRTBYT
jsr CHK
rts
;
; Print ASCII-string from TOP+X to TOP
CRLF ldx #7 ; output and
PRTST lda TOP,x
jsr OUTCH
dex ; everything?
bpl PRTST ; no ->
PRT1 rts
;
; Print 1 hex byte as 2 ASCII chars
PRTBYT sta TEMP ; save A
lsr ; shift A 4 times
lsr
lsr
lsr
jsr HEXTA ; convert bit 4..7 to HEX and print
lda TEMP
jsr HEXTA ; convert bit 0..7 to HEX and print
lda TEMP ; restore A
rts
;
HEXTA and #$0F ; mask bit 0..4
cmp #$0A ; > 10 ?
clc
bmi HEXTA1 ; no ->
adc #7 ; A..F
HEXTA1 adc #$30 ; convert to ASCII-char...
jmp OUTCH ; ...and print it
;
; Get char from TTY in A
GETCH stx TMPX
ldx #8 ; count 8 bits
lda #1
GET1 bit SAD ; check if TTY-mode
bne GET6 ; no ->
; PA7 is input TTY
bmi GET1 ; wait for startbit
jsr DELAY ; delay 1 bit
;
; By delaying another half bit time, you read the bit in the middle
; of every bit.
GET5 jsr DEHALF ; delay 1/2 bit time
GET2 lda SAD
and #$80 ; mask bit 7
lsr CHAR ; shift last result
ora CHAR ; OR it with new bit
sta CHAR ; and store it again
jsr DELAY
dex
bne GET2 ; next bit
jsr DEHALF ; why ????
;
ldx TMPX
lda CHAR
rol ; shift off stopbit
lsr
GET6 rts
;
; initialization of 6530 [1E88]
INITS ldx #1 ; set display to address mode
stx MODE
;
INIT1 ldx #0
stx PADD ; PA0..PA7 = input
ldx #$3F
stx PBDD ; PB0..PB5 = output
; PB6, PB7 = input
ldx #7 ; enable 74145 output 3 to
stx SBD ; check KB/TTY-mode
cld
sei
rts
;
; Output char in A to TTY [1E9E]
OUTSP lda #" " ; print space
OUTCH sta CHAR
stx TMPX
jsr DELAY
lda SBD
and #$FE ; send startbit
sta SBD ; PB0 = 0 -> TTY := (H)
jsr DELAY
;
ldx #8 ; send character
OUT1 lda SBD
and #$FE ; clear bit 0
lsr CHAR ; shift byte
adc #0 ; add Carry = former bit 0
sta SBD ; output bit
jsr DELAY
dex ; all bits?
bne OUT1 ; no ->
lda SBD
ora #1
sta SBD ; stop bit
jsr DELAY
ldx TMPX
rts
;
; Delay 1 bit time as determined by DETCPS
DELAY lda CNTH30
sta TIMH
lda CNTL30
DE2 sec
DE4 sbc #1
bcs DE3 ; A<>$FF ->
dec TIMH
DE3 ldy TIMH ; TIMH > 0 ?
bpl DE2 ; yes ->
rts
;
; Delay half a bit time
DEHALF lda CNTH30
sta TIMH
lda CNTL30
lsr
lsr TIMH
bcc DE2
ora #$80
bcs DE4 ; always ->
;
; Determine if key is depressed: NO -> A=0, YES -> A>0
AK ldy #3 ; 3 rows
ldx #1 ; select 74145 output 0
ONEKEY lda #$FF ; initial value
;
AKA stx SBD ; enable output = select row
inx
inx ; prepare for next row
and SAD ; A := A && (PA0..PA7)
dey ; all rows?
bne AKA ; no ->
ldy #7
sty SBD ; select 74145 output 3 (not used)
;
ora #$80 ; mask bit 7 of A
eor #$FF ; if A still is $FF -> A := 0
rts
;
; Output to 7-segment-display
SCAND ldy #0 ; POINTL/POINTH = address on display
lda (POINTL),Y ; get data from this address
sta INH ; store in INH =
SCANDS lda #$7F ; PA0..PA6 := output
sta PADD
ldx #9 ; Start with display at output 4
ldy #3 ; 3 bytes to be shown
;
SCAND1 lda INL_A,y ; get byte
lsr ; get MSD by shifting A
lsr
lsr
lsr
jsr CONVD
lda INL_A,y ; get byte again
and #$0F ; get LSD
jsr CONVD
dey ; all ?
bne SCAND1 ; no ->
stx SBD ; all digits off
lda #0
sta PADD ; PA0..PA7 := input
jmp AK
;
; Convert digit into 7-segment-value
CONVD sty TEMP
tay
lda TABLE,Y
ldy #0
sty SAD ; turn off segments
stx SBD ; select 7-s-display
sta SAD ; output code on display
ldy #$7F ; delay ~500 cycles
CONVD1 dey
bne CONVD1
inx ; next display
inx
ldy TEMP
rts
;
; Increment POINT = address on display
INCPT inc POINTL
bne INCPT2
inc POINTH
INCPT2 rts
;
; Get key from keyboard in A
GETKEY ldx #$21 ; row 0 / disable input TTY
GETKE5 ldy #1 ; only one row in the time
jsr ONEKEY ; key?
bne KEYIN ; yes ->
cpx #$27 ; last row?
bne GETKE5 ; no, next one ->
lda #$15 ; 15 = no key
rts
;
KEYIN ldy #$FF ; Y := key number
KEYIN1 asl ; shift A until
bcs KEYIN2 ; bit = 1 ->
;
; Comment: bit 7 is always 0 so Carry is always 0 the first time
; and allowing Y to become 0 (key $FF does not exist)
iny
bpl KEYIN1 ; always ->
KEYIN2 txa
and #$0F ; strip bit4..7
lsr ; A := row+1
tax ; X := actual row+1
tya
bpl KEYIN4 ; always, because Y<7 ->
;
; Add 7 to A for every row above 0 to get actual key number
KEYIN3 clc
adc #7 ; add (X-1) times 7 to A
KEYIN4 dex ; countdown to 0
bne KEYIN3
rts ; A is always < 21 eg. < $15
;
; Compute checksum
CHK clc
adc CHKSUM
sta CHKSUM
lda CHKHI
adc #0
sta CHKHI
rts
;
; Get 2 hex-chars and pack into INL and INH
; Non hex char will be loaded as nearsest hex equivalent
GETBYT jsr GETCH
jsr PACK
jsr GETCH
jsr PACK
lda INL
rts
;
; Shift char in A into INL and INH
PACK cmp #$30 ; is hex?
bmi UPDAT2 ; < = no ->
cmp #$47
bpl UPDAT2 ; > = no ->
HEXNUM cmp #$40 ; A..F ?
bmi UPDATE ; no ->
HEXALP clc
adc #9
UPDATE rol ; shift to bit 4..7
rol
rol
rol
ldy #4 ; shift into INL/INH
UPDAT1 rol
rol INL
rol INH
dey ; 4 times?
bne UPDAT1 ; no ->
lda #0 ; if hex number -> A := 0
UPDAT2 rts
;
OPEN lda INL ; move I/O-buffer to POINT
sta POINTL
lda INH
sta POINTH
rts
;
; Tables
TOP
.by 0, 0, 0, 0, 0, 0, 10, 13
.tx "MIK" ; KIM
.by " ", $13
.tx "RRE " ; ERRor
.by $13
; Hex -> 7-segment 0 1 2 3 4 5 6 7
TABLE .by $BF, $86, $DB, $CF, $E6, $ED, $FD, $87
; 8 9 A B C D E F
.by $FF, $EF, $F7, $FC, $B9, $DE, $F9, $F1
.by $FF, $FF, $FF
;
; Comment: if everything is compiled right, next vectors should
; start at $FFFA
NMIENT .wo NMIT
RSTENT .wo RESET
IRQENT .wo IRQT
.en
You can email me here.