Apple-2-SW
/
Applecorn
mirror of https://github.com/bobbimanners/Applecorn.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merged in latest JGH enhancements.

This commit is contained in:
Bobbi Webber-Manners 2021-08-12 16:58:13 -04:00
parent d781709ed5
commit a9bde4db93
3 changed files with 311 additions and 176 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
applecorn.po
View File

Binary file not shown.

392
auxmem.chario.s
View File

@ -7,177 +7,309 @@
* Character read and write
*
* TEMP:
FXESCCHAR EQU $240
FXESCON EQU $241
FLASHER EQU $242
OLDCHAR EQU $243
CURSOR EQU $244
* OSWRCH handler
****************
* Send a character to current output
* All registers preserved
*
WRCHHND PHA
PHX
PHY
* TODO Check any output redirections
* TODO Check any spool output
* TO DO Check any output redirections
* TO DO Check any spool output
JSR OUTCHAR
* TODO Check any printer output
* TO DO Check any printer output
PLY
PLX
PLA
RTS
* OSRDCH handler
* OSRDCH/INKEY handler
**********************
* Read a character from current input
* All registers preserved except A, Carry
* Read a character from the keyboard
RDCHHND PHX
* Flashes a fake cursor while waiting for input
*
RDCHHND LDA #$80 ; flag=wait forever
PHY
JSR GETCHRC
STA OLDCHAR
:L1 LDA CURS+1 ; Skip unless CURS=$8000
CMP #$80
BNE :S1
LDA CURS
BNE :S1
STZ CURS
STZ CURS+1
LDA CSTATE
ROR
BCS :S2
TAY
* TEST
LDA CURSOR
BNE INKEYGO
LDA #'_'
BRA :S3
:S2 LDA OLDCHAR
:S3 JSR PRCHRC
INC CSTATE
:S1 INC CURS
BNE :S4
INC CURS+1
:S4 LDA $C000 ; Keyboard data/strobe
BPL :L1
LDA OLDCHAR ; Erase cursor
JSR PRCHRC
LDA $C000
AND #$7F
STA $C010 ; Clear strobe
STA CURSOR
* TEST
BRA INKEYGO ; Wait forever for input
; XY<$8000 - wait for a keypress
INKEY PHY ; Dummy PHY to balance RDCH
INKEYGO PHX ; Save registers
PHY
;
JSR GETCHRC ; Get character under cursor
STA OLDCHAR
BRA INKEYLP
;
INKEYLP1 PHX
INKEYLP2 PHY
INKEYLP INC FLASHER ; Increment cursor counter
INC FLASHER
LDA FLASHER
AND #63 ; Flash every 64/100sec = 32/50sec
BNE INKEY3 ; Not time to toggle yet
LDA OLDCHAR ; Prepare to remove cursor
BIT FLASHER
BVS INKEY2 ; Remove cursor
LDA CURSOR ; Add cursor
* TO DO: Cursor could be any char, eg $A0 for block cursor
INKEY2 JSR PRCHRC ; Toggle cursor
INKEY3
;
LDA ESCFLAG
SEC
BMI INKEYOK ; Escape pending, return it
JSR KEYREAD ; Test for input, all can be trashed
BCC INKEYOK ; Char returned, return it
JSR DELAY ; Wait 1/100sec
PLY
BMI INKEYLP2 ; Loop forever
PLX
CMP #$1B ; Escape pressed?
BNE :S5
SEC ; Return CS
ROR ESCFLAG
SEC
RTS
:S5 CLC
RTS
CURS DW $0000 ; Counter
CSTATE DB $00 ; Cursor on or off
OLDCHAR DB $00 ; Char under cursor
BYTE81 JSR GETKEY ; $81 = Read key with time lim
RTS
* Performs OSBYTE $81 INKEY$ function
* X,Y has time limit
* On exit, CC, Y=$00, X=key - key pressed
* CS, Y=$FF - timeout
* CS, Y=$1B - escape
GETKEY TYA
BMI NEGKEY ; Negative INKEY
:L1 CPX #$00
BEQ :S1
LDA $C000 ; Keyb data/strobe
AND #$80
BNE :GOTKEY
JSR DELAY ; 1/100 sec
DEX
BRA :L1
:S1 CPY #$00
BEQ :S2
TXA
BNE INKEYDEC ; Decrement XY
DEY
LDX #$FF
BRA :L1
:S2 LDA $C000 ; Keyb data/strobe
AND #$80
BNE :GOTKEY
LDY #$FF ; No key, time expired
SEC
INKEYDEC DEX
BNE INKEYLP1 ; Not 0, loop back
TYA
BNE INKEYLP1 ; Not 0, loop back
DEY ; Y=$FF
TYA ; A=$FF
PLX ; Drop dummy PHY
RTS ; CS from above
; Timeout: CS, AY=$FFFF, becomes XY=$FFFF
INKEYOK PHA
LDA OLDCHAR
JSR PRCHRC ; Remove cursor
PLA
PLY ; <$80=INKEY or $80=RDCH
PLX ; Restore X
PLY ; <$80=INKEY or restore=RDCH
PHA ; Save char for a mo
LDA ESCFLAG
ASL A ; Cy=Escape flag
PLA ; Get char back
RTS
:GOTKEY LDA $C000 ; Fetch char
AND #$7F
STA $C010 ; Clear strobe
CMP #27 ; Escape
BEQ :ESC
TAX
; Character read: CC, A=char, X=???, Y<$80
; Escape: CS, A=?? , X=???, Y<$80
* OLD CODE
**********
*
*RDCHHND PHX
* PHY
* JSR GETCHRC
* STA OLDCHAR
*:L1 LDA CURS+1 ; Skip unless CURS=$8000
* CMP #$80
* BNE :S1
* LDA CURS
* BNE :S1
*
* STZ CURS
* STZ CURS+1
* LDA CSTATE
* ROR
* BCS :S2
* LDA #'_'
* BRA :S3
*:S2 LDA OLDCHAR
*:S3 JSR PRCHRC
* INC CSTATE
*:S1 INC CURS
* BNE :S4
* INC CURS+1
*:S4 LDA $C000 ; Keyboard data/strobe
* BPL :L1
* LDA OLDCHAR ; Erase cursor
* JSR PRCHRC
* LDA $C000
* AND #$7F
* STA $C010 ; Clear strobe
* PLY
* PLX
* CMP #$1B ; Escape pressed?
* BNE :S5
* SEC ; Return CS
* ROR ESCFLAG
* SEC
* RTS
*:S5 CLC
* RTS
*CURS DW $0000 ; Counter
*CSTATE DB $00 ; Cursor on or off
*OLDCHAR DB $00 ; Char under cursor
*
*
** Performs OSBYTE $81 INKEY$ function
** X,Y has time limit
** On exit, CC, Y=$00, X=key - key pressed
** CS, Y=$FF - timeout
** CS, Y=$1B - escape
*GETKEY TYA
* BMI NEGKEY ; Negative INKEY
*:L1 CPX #$00
* BEQ :S1
* LDA $C000 ; Keyb data/strobe
* AND #$80
* BNE :GOTKEY
* JSR DELAY ; 1/100 sec
* DEX
* BRA :L1
*:S1 CPY #$00
* BEQ :S2
* DEY
* LDX #$FF
* BRA :L1
*:S2 LDA $C000 ; Keyb data/strobe
* AND #$80
* BNE :GOTKEY
* LDY #$FF ; No key, time expired
* SEC
* RTS
*:GOTKEY LDA $C000 ; Fetch char
* AND #$7F
* STA $C010 ; Clear strobe
* CMP #27 ; Escape
* BEQ :ESC
* TAX
* LDY #$00
* CLC
* RTS
*:ESC ROR ESCFLAG
* LDY #27 ; Escape
* SEC
* RTS
*NEGKEY LDX #$00 ; Unimplemented
* LDY #$00
* RTS
BYTE81 TYA
BMI NEGINKEY ; XY<0, scan for keypress
JSR INKEY ; XY>=0, wait for keypress
* Y=$FF, A=FF, X=??, CS - timeout
* Y<$80, A=esc, X=??, CS - escape
* Y<$80, A=char, X=??, CC - character read
TAX ; X=character returned
TYA
BMI BYTE81DONE ; Y=$FF, timeout
LDY #$00
BCC BYTE81DONE ; CC, not Escape
LDY #$1B ; Y=27
BYTE81DONE RTS
* Returns: Y=$FF, X=$FF, CS - timeout
* Y=$1B, X=???, CS - escape
* Y=$00, X=char, CC - keypress
NEGINKEY LDX #$00 ; Unimplemented
LDY #$00
CLC
RTS
:ESC ROR ESCFLAG
LDY #27 ; Escape
SEC
RTS
NEGKEY LDX #$00 ; Unimplemented
LDY #$00
RTS
* KERNEL/KEYBOARD.S
*******************
KBDREAD
KEYPRESS LDA $C000
TAY
* KEYREAD
*************************
* Test for and read from input,
* expanding keyboard special keys
*
* On exit, CS=no keypress
* CC=keypress
* A =keycode, X=corrupted
KEYREAD
* TO DO: check *EXEC source
* TO DO: expand current soft key
JSR KBDREAD ; Fetch character from KBD "buffer"
BCS KEYREAD0 ; Nothing pending
* TO DO: process cursor keys
* TO DO: process new soft keys
KEYREAD0 RTS
* KBDREAD
*************************
* Test for and fetch key from keyboard
*
* On exit, CS=no keypress
* CC=keypress
* A =keycode, X=corrupted
* Apple+Letter -> Ctrl+Letter
* Apple+Digits -> 80+x, 90+x, A0+x
* TAB -> $C9
* Cursors -> $CC-$CF
*
KBDREAD CLV ; VC=return keypress
KBDTEST LDA $C000 ; VS here to test for keypress
EOR #$80 ; Toggle bit 7
CMP #$80
BCC KEYNONE ; No key pressed
AND #$7F
BCS KBDDONE ; No key pressed
BVS KBDDONE ; VS=test for keypress
STA $C010 ; Ack. keypress
BIT $C061
BMI KEYLALT ; Left Apple pressed
BMI KBDLALT ; Left Apple pressed
BIT $C062
BMI KEYRALT ; Right Apple pressed
BMI KBDRALT ; Right Apple pressed
CMP #$09
BEQ KEYTAB
BEQ KBDTAB ;
CMP #$08
BCC KEYOK ; <$08 not cursor key
BCC KBDDONE ; <$08 not cursor key
CMP #$0C
BCC KEYCURSR
BCC KBDCURSR
CMP #$15
BEQ KEYCUR15
KEYOK SEC ; SEC=Ok
KEYNONE RTS
BEQ KBDCUR15
CMP #27 ; TEMP
* CMP FXESCCHAR ; Current ESCAPE char?
BNE KBDNOESC ; No
LDX FXESCON ; Is ESCAPE enabled?
BNE KBDNOESC ; No
ROR ESCFLAG ; Set Escape flag
KBDNOESC CLC ; CLC=Ok
KBDDONE RTS
KEYTAB LDA #$C9
; If cursors active, COPY
; else TAB
SEC
RTS
KEYRALT ; Right Apple key pressed
KEYLALT CMP #$40 ; Left Apple key pressed
BCS KEYCTRL
KBDRALT ; Right Apple key pressed
KBDLALT CMP #$40 ; Left Apple key pressed
BCS KBDCTRL
CMP #$30
BCC KEYOK ; <'0'
BCC KBDFUNOK ; <'0'
CMP #$3A
BCS KEYOK ; >'9'
KEYFUNC AND #$0F ; Convert Apple-Num to function key
BCS KBDOK ; >'9'
KBDFUNC AND #$0F ; Convert Apple-Num to function key
ORA #$80
BIT $C062
BPL KEYFUNOK ; Left+Digit -> $8x
BPL KBDFUNOK ; Left+Digit -> $8x
ORA #$90 ; Right+Digit -> $9x
BIT $C061
BPL KEYFUNOK
BPL KBDFUNOK
EOR #$30 ; Left+Right+Digit -> $Ax
KEYFUNOK SEC
RTS
KEYCTRL AND #$1F ; Apple-Letter -> Ctrl-Letter
KBDFUNOK RTS
KBDCTRL AND #$1F ; Apple-Letter -> Ctrl-Letter
KBDOK CLC
RTS
KEYCUR15
* BIT $C062
* BPL KEYCUR16 ; Right Apple not pressed
* LDA #$C9 ; Solid+Right -> COPY?
* SEC
* RTS
KEYCUR16 LDA #$09 ; Convert RGT to $09
KEYCURSR AND #$03
ORA #$CC ; Cursor keys $CC-$CF
SEC ; SEC=Ok
RTS
KBDTAB LDA #$11 ; Convert TAB to $C9, expanded later
KBDCUR15 SBC #$0C ; Convert RGT to $09
KBDCURSR CLC
ADC #$C4 ; Cursor keys $CC-$CF
RTS ; CLC=Ok set earlier

95
auxmem.misc.s
View File

@ -10,16 +10,12 @@
BYTE80 LDY #$00 ; Prepare return=&00xx
TXA ; X<0 - info about buffers
BMI ADVALBUF ; X>=0 - read input devices
*
* TEST CODE
CPX #$7F
BNE ADVALNONE
ADVALWAIT JSR KBDREAD
BCC ADVALWAIT
BCS ADVALWAIT
TAX
RTS
* TEST CODE
*
ADVALNONE LDX #$00 ; Input, just return 0
RTS
ADVALBUF INX
@ -39,55 +35,64 @@ ADVALBUF INX
******************
* Beep
*
* Sound measurement shows the tone formula is:
* 1.230 MHz
* ------------- = cycles
* 8 * frequency
*
* cycles = BEEPX*5+10
*
* So:
* BEEPX = (cycles-10)/5
* So:
* BEEPX = ( 1.230 MHz )
* (------------- - 10 ) / 5
* (8 * frequency )
* BEEPX EQU 57 ; note=C5
BEEPX EQU 116 ; note=C4
BEEP PHA
PHX
*
* A nicer beep
* 1.023MHz clock
*
PHY
LDY #$00 ; 2cy duration
*
* $C1 975cy = 524.6Hz = C5 slightly sharp
* (actually sounds like E5 on my Casio)
* $6B 546cy = 936.8Hz = A5# sharp - close to Apple BEEP
* $60 491cy = 1041.7Hz = C6 slightly sharp
*
:L1 LDX #$60 ; 2cy pitch 2cy
LDY #$00 ; duration
:L1 LDX #BEEPX ; 2cy pitch 2cy
*------------------------------------------------
:L2 DEX ; 2cy 193 * 2cy
BNE :L2 ; 3cy/2cy 192 * 3cy + 1 * 2cy
:L2 DEX ; 2cy BEEPX * 2cy
BNE :L2 ; 3cy/2cy (BEEPX-1) * 3cy + 1 * 2cy
*------------------------------------------------
* 964cy
LDA $C030 ; 4cy 4cy
DEY ; 2cy 2cy
BNE :L1 ; 2cy/3cy 3cy
PLY ; 975cy = 524.6Hz = C5
*
* LDX #$20
*:L1 LDA $C030
* JSR DELAY
* INX
* BNE :L1
*
* BEEPX*5-1cy
LDA $C030 ; 4cy BEEPX*5+5
DEY ; 2cy BEEPX*5+7
BNE :L1 ; 3cy/2cy BEEPX*5+10
PLY ;
PLX
PLA
RTS
* Delay approx 1/100 sec
DELAY PHX
PHY
LDX #$00
:L1 INX ; 2
LDY #$00 ; 2
:L2 INY ; 2
CPY #$00 ; 2
BNE :L2 ; 3 (taken)
CPX #$02 ; 2
BNE :L1 ; 3 (taken)
PLY
PLX
RTS
************************
* Enter at DELAY with CS to test keyboard
* Enter at CENTI to ignore keyboard
*
CENTI CLC ; Don't test keyboard
DELAY PHX ; 3cy
PHY ; 3cy
LDY #10 ; 2cy 10 * 1/1000s
*------------------------------------------------
:L1 LDX #$48 ; 2cy $48 gives about 1/1000s
:L2 BCC :L3 ; 2cy/3cy Don't test kbd
LDA $C000 ; 4cy
BMI :L5 ; 2cy keypress, exit early
:L3 DEX ; 2cy
BNE :L2 ; 3cy/2cy -> 72*(2+2+4+2+2+3)-1
* ; = 1079 -> 0.00105s
*------------------------------------------------
:L4 DEY ; 2cy
BNE :L1 ; 3cy/2cy
:L5 PLY ; 4cy
PLX ; 4cy
RTS ; 6cy
* Print string pointed to by X,Y to the screen
OUTSTR TXA
@ -306,5 +311,3 @@ MOSVEND
* Buffer for one 512 byte disk block in aux mem
AUXBLK DS $200