From 595e986c947a8047c21aad705afdd6103d67c4f8 Mon Sep 17 00:00:00 2001 From: Charles Mangin Date: Wed, 14 Jun 2017 09:16:08 -0400 Subject: [PATCH] combined routines now on DSK as GPIO --- GP2IO | Bin 0 -> 204 bytes GP2IO.s | 121 +++++++++++++++++++++++++++++++++++++++++ GP2IO_Output.txt | 126 +++++++++++++++++++++++++++++++++++++++++++ GPIO Routines.dsk | Bin 143360 -> 143360 bytes _FileInformation.txt | 1 + 5 files changed, 248 insertions(+) create mode 100644 GP2IO create mode 100644 GP2IO.s create mode 100644 GP2IO_Output.txt diff --git a/GP2IO b/GP2IO new file mode 100644 index 0000000000000000000000000000000000000000..18c45d8720cce56728dccd9d750ac957d767c3c6 GIT binary patch literal 204 zcmY%J=2+RFP|LBD14yjYP+0LtVF?FkgTmXt$ADrN-YWF{O;E`C+ttdxlA)DtB@0L? zJCIn$wwHlPvmVHL#$?LkYVS{7cnP#}>H7o#qp@Fi literal 0 HcmV?d00001 diff --git a/GP2IO.s b/GP2IO.s new file mode 100644 index 0000000..f547269 --- /dev/null +++ b/GP2IO.s @@ -0,0 +1,121 @@ + ORG $800 + +BUFFERLENGTH EQU $08 +INPUTLENGTH EQU $07 +INPUTPTR EQU $06 + +BYTETOSEND EQU $ED +BYTETRCVD EQU $EF +BUTT1HILO EQU $EE + +ANN0HI EQU $C059 +ANN0LO EQU $C058 +ANN1HI EQU $C05B +ANN1LO EQU $C05A +ANN2HI EQU $C05D +ANN2LO EQU $C05C +BUTT1 EQU $C062 + +WAIT EQU $FCA8 +PRINTCR EQU $FD8E +PRINTBYTE EQU $FDED +KEYBUFFER EQU $0200 + +BUFFERIO JSR QUERYBUFFER ; start by querying the buffer length - is there anything waiting? returns with buffer length in $08 + LDA #$80 ; load control byte $80 "send buffer bytes" + JSR SENDBYTE ; send control byte + LDA BUFFERLENGTH ; load buffer length (or however much buffer you want sent) + JSR SENDBYTE ; send message length byte +BETWEENBYTES LDA #$28 ; wait a moment (betweenbytes) + JSR WAIT ; wait + JSR READBYTE ; CTS - send byte + ORA #$80 ; clear byte 7 (for ASCII) + JSR PRINTBYTE ; display byte on screen + DEC BUFFERLENGTH ; count down bytes (countdownbuffer) + LDA BUFFERLENGTH ; load Accumulator with new buffer length + BNE BETWEENBYTES ; if there's more to come, loop (betweenbytes) + JSR PRINTCR ; last byte. print CF/LF + RTS ; return + +GETLINE JSR $FD6A ; get line of input, input length in X reg + TXA ; get input length into Accumulator + STA INPUTLENGTH ; put input length into $07 +CLEARPTR LDA #$00 ; load zero into Accumulator + STA INPUTPTR ; put zero into $06, keyboard buffer pointer + LDA #$04 ; load Accumulator with control byte "write to buffer" + JSR SENDBYTE ; send control byte + LDA INPUTLENGTH ; load input length from $07 + JSR SENDBYTE ; send message length +LOADBUFFER LDX INPUTPTR ; load X with keyboard buffer pointer (LOADBUFFER) + LDA KEYBUFFER,X ; load Accumulator with bytes from keyboard buffer (start at $200) + AND #$7F ; clear high bit (for ASCII on other end) + JSR SENDBYTE ; send byte + INC INPUTPTR ; increment keyboard buffer pointer + LDA INPUTPTR ; load buffer pointer into Accumulator + CMP INPUTLENGTH ; compare with message length + BNE LOADBUFFER ; if not at end of message, loop to (LOADBUFFER) + RTS ; return + +QUERYBUFFER LDA #$40 ; control byte for query buffer length + JSR SENDBYTE ; send control byte + JSR TWIDDLE ; wait routine - gives GP2IO time to receive bytes from serial +CTS STA ANN2LO ; set ANN2 to LOW (just in case it's floating high) + JSR READBYTE ; CTS - ready for response byte with buffer length + BEQ QUERYBUFFER ; if there's nothing in the buffer, loop until there is + STA BUFFERLENGTH ; put the byte in $08 + RTS ; returns buffer length in $08 (BUFFERLENGTH) + +TWIDDLE LDA #$21 ; ! (inverse) + JSR PRINTCHAR ; + LDA #$2F ; / + JSR PRINTCHAR ; + LDA #$2D ; - + JSR PRINTCHAR ; + LDA #$1C ; \ +PRINTCHAR JSR PRINTBYTE ; prints character to screen, high byte not set, inverse text + LDA #$AA ; speed of animation + JSR WAIT ; waits for a while + LDA #$88 ; (backspace) + JSR PRINTBYTE ; backspaces over current char to overwrite + RTS ; RETURN + +SENDBYTE LDY #$08 ; load 8 for a full byte, loop counter + STA BYTETOSEND ; put byte in zero page for safe keeping +RTS STA ANN0HI ; annunciator 0 high, RTS +SENDBIT ROL BYTETOSEND ; rotate byte left, high/MSB out to carry (sendbit) + BCC SHORTLOOP ; "branch on carry clear" - if carry/bit = 0, goto #311 (short loop) +LONGLOOP LDX #$14 ; if carry/bit = 1, load X with 20 (long loop) + JMP SETANN1 ; jump over SHORTLOOP +SHORTLOOP LDX #$0A ; if carry/bit = 0, load X with 10 (short loop) +SETANN1 STA ANN1HI ; set annunciator 1 HIGH +COUNTDOWN DEX ; decrement, countdown to setting ANN1 low (COUNTDOWN) + BNE COUNTDOWN ; if X > 0, keep counting (goto COUNTDOWN) + STA ANN1LO ; if done, set ANN1 LOW, countdown to getting next bit + LDX #$05 ; reset counter for short "reset" transition. This lets the GP2IO stage the bit before the next interrupt +COUNTDOWN2 DEX ; count down again (COUNTDOWN2) + BNE COUNTDOWN2 ; if X > 0, keep counting (goto COUNTDOWN2) + DEY ; decrement y, countdown bits sent + BNE SENDBIT ; if y > 0, next bit (SENDBIT) +RTSOFF STA ANN0LO ; annunciator 0 low, sending RTS OFF + RTS ; return + +READBYTE LDX #$09 ; reading 8 bits requires 9 transitions. + LDA #$00 ; clear the accumulator + STA BYTETRCVD ; $EF is staging for received byte, set 0 + STA BUTT1HILO ; $EE is staging for each bit, set 0 +CTSON STA ANN2HI ; set ANN2 HIGH, indicate to AVR "Clear to Send" +LOOPSTART LDY #$FF ; start wait loop +LOOPCOUNT INY ; Increment Y - rolls over to 0 on first run (loopcount) + LDA BUTT1 ; check PB1 status hi/low + AND #$80 ; clear 0-6 bits (just need bit 7, all others float) + CMP BUTT1HILO ; compare Accumulator 7 bit with $EE, previous PB2 value + BNE BITCHANGE ; if PB2 has changed state, store in $EE (bitchange) + BEQ LOOPCOUNT ; bit hasn't changed yet, return to (loopcount) +BITCHANGE STA BUTT1HILO ; (bitchange) + CPY #$44 ; if the loop count is more than 68, bit is one. Bit is set in Carry + ROL BYTETRCVD ; rotate the new bit into $EF, our result byte. + DEX ; decrement X, our bit count + BNE LOOPSTART ; if bit count is not yet full, loop back to (loopcount) +CTSOFF STA ANN2LO ; if bit count is full, set ANN2 LOW, CTS off + LDA BYTETRCVD ; puts received byte into Accumulator + RTS ; return with byte in Accumulator diff --git a/GP2IO_Output.txt b/GP2IO_Output.txt new file mode 100644 index 0000000..44454ef --- /dev/null +++ b/GP2IO_Output.txt @@ -0,0 +1,126 @@ +------+-------------------+-------------+----+---------+------+-----------------------+------------------------------------------------------------------- + Line | # File Line | Line Type | MX | Reloc | Size | Address Object Code | Source Code +------+-------------------+-------------+----+---------+------+-----------------------+------------------------------------------------------------------- + 1 | 1 GP2IO.s 1 | Directive | 11 | | 0 | 00/8000 | ORG $800 + 2 | 1 GP2IO.s 2 | Empty | 11 | | 0 | 00/0800 | + 3 | 1 GP2IO.s 3 | Equivalence | 11 | | 0 | 00/0800 | BUFFERLENGTH EQU $08 + 4 | 1 GP2IO.s 4 | Equivalence | 11 | | 0 | 00/0800 | INPUTLENGTH EQU $07 + 5 | 1 GP2IO.s 5 | Equivalence | 11 | | 0 | 00/0800 | INPUTPTR EQU $06 + 6 | 1 GP2IO.s 6 | Empty | 11 | | 0 | 00/0800 | + 7 | 1 GP2IO.s 7 | Equivalence | 11 | | 0 | 00/0800 | BYTETOSEND EQU $ED + 8 | 1 GP2IO.s 8 | Equivalence | 11 | | 0 | 00/0800 | BYTETRCVD EQU $EF + 9 | 1 GP2IO.s 9 | Equivalence | 11 | | 0 | 00/0800 | BUTT1HILO EQU $EE + 10 | 1 GP2IO.s 10 | Empty | 11 | | 0 | 00/0800 | + 11 | 1 GP2IO.s 11 | Equivalence | 11 | | 0 | 00/0800 | ANN0HI EQU $C059 + 12 | 1 GP2IO.s 12 | Equivalence | 11 | | 0 | 00/0800 | ANN0LO EQU $C058 + 13 | 1 GP2IO.s 13 | Equivalence | 11 | | 0 | 00/0800 | ANN1HI EQU $C05B + 14 | 1 GP2IO.s 14 | Equivalence | 11 | | 0 | 00/0800 | ANN1LO EQU $C05A + 15 | 1 GP2IO.s 15 | Equivalence | 11 | | 0 | 00/0800 | ANN2HI EQU $C05D + 16 | 1 GP2IO.s 16 | Equivalence | 11 | | 0 | 00/0800 | ANN2LO EQU $C05C + 17 | 1 GP2IO.s 17 | Equivalence | 11 | | 0 | 00/0800 | BUTT1 EQU $C062 + 18 | 1 GP2IO.s 18 | Empty | 11 | | 0 | 00/0800 | + 19 | 1 GP2IO.s 19 | Equivalence | 11 | | 0 | 00/0800 | WAIT EQU $FCA8 + 20 | 1 GP2IO.s 20 | Equivalence | 11 | | 0 | 00/0800 | PRINTCR EQU $FD8E + 21 | 1 GP2IO.s 21 | Equivalence | 11 | | 0 | 00/0800 | PRINTBYTE EQU $FDED + 22 | 1 GP2IO.s 22 | Equivalence | 11 | | 0 | 00/0800 | KEYBUFFER EQU $0200 + 23 | 1 GP2IO.s 23 | Empty | 11 | | 0 | 00/0800 | + 24 | 1 GP2IO.s 24 | Code | 11 | | 3 | 00/0800 : 20 4B 08 | BUFFERIO JSR QUERYBUFFER ; start by querying the buffer length - is there anything waiting? returns with buffer length in $08 + 25 | 1 GP2IO.s 25 | Code | 11 | | 2 | 00/0803 : A9 80 | LDA #$80 ; load control byte $80 "send buffer bytes" + 26 | 1 GP2IO.s 26 | Code | 11 | | 3 | 00/0805 : 20 7D 08 | JSR SENDBYTE ; send control byte + 27 | 1 GP2IO.s 27 | Code | 11 | | 2 | 00/0808 : A5 08 | LDA {$08} ; load buffer length (or however much buffer you want sent) + 28 | 1 GP2IO.s 28 | Code | 11 | | 3 | 00/080A : 20 7D 08 | JSR SENDBYTE ; send message length byte + 29 | 1 GP2IO.s 29 | Code | 11 | | 2 | 00/080D : A9 28 | BETWEENBYTES LDA #$28 ; wait a moment (betweenbytes) + 30 | 1 GP2IO.s 30 | Code | 11 | | 3 | 00/080F : 20 A8 FC | JSR {$FCA8} ; wait + 31 | 1 GP2IO.s 31 | Code | 11 | | 3 | 00/0812 : 20 A4 08 | JSR READBYTE ; CTS - send byte + 32 | 1 GP2IO.s 32 | Code | 11 | | 2 | 00/0815 : 09 80 | ORA #$80 ; clear byte 7 (for ASCII) + 33 | 1 GP2IO.s 33 | Code | 11 | | 3 | 00/0817 : 20 ED FD | JSR {$FDED} ; display byte on screen + 34 | 1 GP2IO.s 34 | Code | 11 | | 2 | 00/081A : C6 08 | DEC {$08} ; count down bytes (countdownbuffer) + 35 | 1 GP2IO.s 35 | Code | 11 | | 2 | 00/081C : A5 08 | LDA {$08} ; load Accumulator with new buffer length + 36 | 1 GP2IO.s 36 | Code | 11 | | 2 | 00/081E : D0 ED | BNE BETWEENBYTES ; if there's more to come, loop (betweenbytes) + 37 | 1 GP2IO.s 37 | Code | 11 | | 3 | 00/0820 : 20 8E FD | JSR {$FD8E} ; last byte. print CF/LF + 38 | 1 GP2IO.s 38 | Code | 11 | | 1 | 00/0823 : 60 | RTS ; return + 39 | 1 GP2IO.s 39 | Empty | 11 | | 0 | 00/0824 | + 40 | 1 GP2IO.s 40 | Code | 11 | | 3 | 00/0824 : 20 6A FD | GETLINE JSR $FD6A ; get line of input, input length in X reg + 41 | 1 GP2IO.s 41 | Code | 11 | | 1 | 00/0827 : 8A | TXA ; get input length into Accumulator + 42 | 1 GP2IO.s 42 | Code | 11 | | 2 | 00/0828 : 85 07 | STA {$07} ; put input length into $07 + 43 | 1 GP2IO.s 43 | Code | 11 | | 2 | 00/082A : A9 00 | CLEARPTR LDA #$00 ; load zero into Accumulator + 44 | 1 GP2IO.s 44 | Code | 11 | | 2 | 00/082C : 85 06 | STA {$06} ; put zero into $06, keyboard buffer pointer + 45 | 1 GP2IO.s 45 | Code | 11 | | 2 | 00/082E : A9 04 | LDA #$04 ; load Accumulator with control byte "write to buffer" + 46 | 1 GP2IO.s 46 | Code | 11 | | 3 | 00/0830 : 20 7D 08 | JSR SENDBYTE ; send control byte + 47 | 1 GP2IO.s 47 | Code | 11 | | 2 | 00/0833 : A5 07 | LDA {$07} ; load input length from $07 + 48 | 1 GP2IO.s 48 | Code | 11 | | 3 | 00/0835 : 20 7D 08 | JSR SENDBYTE ; send message length + 49 | 1 GP2IO.s 49 | Code | 11 | | 2 | 00/0838 : A6 06 | LOADBUFFER LDX {$06} ; load X with keyboard buffer pointer (LOADBUFFER) + 50 | 1 GP2IO.s 50 | Code | 11 | | 3 | 00/083A : BD 00 02 | LDA {$0200},X ; load Accumulator with bytes from keyboard buffer (start at $200) + 51 | 1 GP2IO.s 51 | Code | 11 | | 2 | 00/083D : 29 7F | AND #$7F ; clear high bit (for ASCII on other end) + 52 | 1 GP2IO.s 52 | Code | 11 | | 3 | 00/083F : 20 7D 08 | JSR SENDBYTE ; send byte + 53 | 1 GP2IO.s 53 | Code | 11 | | 2 | 00/0842 : E6 06 | INC {$06} ; increment keyboard buffer pointer + 54 | 1 GP2IO.s 54 | Code | 11 | | 2 | 00/0844 : A5 06 | LDA {$06} ; load buffer pointer into Accumulator + 55 | 1 GP2IO.s 55 | Code | 11 | | 2 | 00/0846 : C5 07 | CMP {$07} ; compare with message length + 56 | 1 GP2IO.s 56 | Code | 11 | | 2 | 00/0848 : D0 EE | BNE LOADBUFFER ; if not at end of message, loop to (LOADBUFFER) + 57 | 1 GP2IO.s 57 | Code | 11 | | 1 | 00/084A : 60 | RTS ; return + 58 | 1 GP2IO.s 58 | Empty | 11 | | 0 | 00/084B | + 59 | 1 GP2IO.s 59 | Code | 11 | | 2 | 00/084B : A9 40 | QUERYBUFFER LDA #$40 ; control byte for query buffer length + 60 | 1 GP2IO.s 60 | Code | 11 | | 3 | 00/084D : 20 7D 08 | JSR SENDBYTE ; send control byte + 61 | 1 GP2IO.s 61 | Code | 11 | | 3 | 00/0850 : 20 5E 08 | JSR TWIDDLE ; wait routine - gives GP2IO time to receive bytes from serial + 62 | 1 GP2IO.s 62 | Code | 11 | | 3 | 00/0853 : 8D 5C C0 | CTS STA {$C05C} ; set ANN2 to LOW (just in case it's floating high) + 63 | 1 GP2IO.s 63 | Code | 11 | | 3 | 00/0856 : 20 A4 08 | JSR READBYTE ; CTS - ready for response byte with buffer length + 64 | 1 GP2IO.s 64 | Code | 11 | | 2 | 00/0859 : F0 F0 | BEQ QUERYBUFFER ; if there's nothing in the buffer, loop until there is + 65 | 1 GP2IO.s 65 | Code | 11 | | 2 | 00/085B : 85 08 | STA {$08} ; put the byte in $08 + 66 | 1 GP2IO.s 66 | Code | 11 | | 1 | 00/085D : 60 | RTS ; returns buffer length in $08 (BUFFERLENGTH) + 67 | 1 GP2IO.s 67 | Empty | 11 | | 0 | 00/085E | + 68 | 1 GP2IO.s 68 | Code | 11 | | 2 | 00/085E : A9 21 | TWIDDLE LDA #$21 ; ! (inverse) + 69 | 1 GP2IO.s 69 | Code | 11 | | 3 | 00/0860 : 20 6F 08 | JSR PRINTCHAR ; + 70 | 1 GP2IO.s 70 | Code | 11 | | 2 | 00/0863 : A9 2F | LDA #$2F ; / + 71 | 1 GP2IO.s 71 | Code | 11 | | 3 | 00/0865 : 20 6F 08 | JSR PRINTCHAR ; + 72 | 1 GP2IO.s 72 | Code | 11 | | 2 | 00/0868 : A9 2D | LDA #$2D ; - + 73 | 1 GP2IO.s 73 | Code | 11 | | 3 | 00/086A : 20 6F 08 | JSR PRINTCHAR ; + 74 | 1 GP2IO.s 74 | Code | 11 | | 2 | 00/086D : A9 1C | LDA #$1C ; \ + 75 | 1 GP2IO.s 75 | Code | 11 | | 3 | 00/086F : 20 ED FD | PRINTCHAR JSR {$FDED} ; prints character to screen, high byte not set, inverse text + 76 | 1 GP2IO.s 76 | Code | 11 | | 2 | 00/0872 : A9 AA | LDA #$AA ; speed of animation + 77 | 1 GP2IO.s 77 | Code | 11 | | 3 | 00/0874 : 20 A8 FC | JSR {$FCA8} ; waits for a while + 78 | 1 GP2IO.s 78 | Code | 11 | | 2 | 00/0877 : A9 88 | LDA #$88 ; (backspace) + 79 | 1 GP2IO.s 79 | Code | 11 | | 3 | 00/0879 : 20 ED FD | JSR {$FDED} ; backspaces over current char to overwrite + 80 | 1 GP2IO.s 80 | Code | 11 | | 1 | 00/087C : 60 | RTS ; RETURN + 81 | 1 GP2IO.s 81 | Empty | 11 | | 0 | 00/087D | + 82 | 1 GP2IO.s 82 | Code | 11 | | 2 | 00/087D : A0 08 | SENDBYTE LDY #$08 ; load 8 for a full byte, loop counter + 83 | 1 GP2IO.s 83 | Code | 11 | | 2 | 00/087F : 85 ED | STA {$ED} ; put byte in zero page for safe keeping + 84 | 1 GP2IO.s 84 | Code | 11 | | 3 | 00/0881 : 8D 59 C0 | RTS STA {$C059} ; annunciator 0 high, RTS + 85 | 1 GP2IO.s 85 | Code | 11 | | 2 | 00/0884 : 26 ED | SENDBIT ROL {$ED} ; rotate byte left, high/MSB out to carry (sendbit) + 86 | 1 GP2IO.s 86 | Code | 11 | | 2 | 00/0886 : 90 05 | BCC SHORTLOOP ; "branch on carry clear" - if carry/bit = 0, goto #311 (short loop) + 87 | 1 GP2IO.s 87 | Code | 11 | | 2 | 00/0888 : A2 14 | LONGLOOP LDX #$14 ; if carry/bit = 1, load X with 20 (long loop) + 88 | 1 GP2IO.s 88 | Code | 11 | | 3 | 00/088A : 4C 8F 08 | JMP SETANN1 ; jump over SHORTLOOP + 89 | 1 GP2IO.s 89 | Code | 11 | | 2 | 00/088D : A2 0A | SHORTLOOP LDX #$0A ; if carry/bit = 0, load X with 10 (short loop) + 90 | 1 GP2IO.s 90 | Code | 11 | | 3 | 00/088F : 8D 5B C0 | SETANN1 STA {$C05B} ; set annunciator 1 HIGH + 91 | 1 GP2IO.s 91 | Code | 11 | | 1 | 00/0892 : CA | COUNTDOWN DEX ; decrement, countdown to setting ANN1 low (COUNTDOWN) + 92 | 1 GP2IO.s 92 | Code | 11 | | 2 | 00/0893 : D0 FD | BNE COUNTDOWN ; if X > 0, keep counting (goto COUNTDOWN) + 93 | 1 GP2IO.s 93 | Code | 11 | | 3 | 00/0895 : 8D 5A C0 | STA {$C05A} ; if done, set ANN1 LOW, countdown to getting next bit + 94 | 1 GP2IO.s 94 | Code | 11 | | 2 | 00/0898 : A2 05 | LDX #$05 ; reset counter for short "reset" transition. This lets the GP2IO stage the bit before the next interrupt + 95 | 1 GP2IO.s 95 | Code | 11 | | 1 | 00/089A : CA | COUNTDOWN2 DEX ; count down again (COUNTDOWN2) + 96 | 1 GP2IO.s 96 | Code | 11 | | 2 | 00/089B : D0 FD | BNE COUNTDOWN2 ; if X > 0, keep counting (goto COUNTDOWN2) + 97 | 1 GP2IO.s 97 | Code | 11 | | 1 | 00/089D : 88 | DEY ; decrement y, countdown bits sent + 98 | 1 GP2IO.s 98 | Code | 11 | | 2 | 00/089E : D0 E4 | BNE SENDBIT ; if y > 0, next bit (SENDBIT) + 99 | 1 GP2IO.s 99 | Code | 11 | | 3 | 00/08A0 : 8D 58 C0 | RTSOFF STA {$C058} ; annunciator 0 low, sending RTS OFF + 100 | 1 GP2IO.s 100 | Code | 11 | | 1 | 00/08A3 : 60 | RTS ; return + 101 | 1 GP2IO.s 101 | Empty | 11 | | 0 | 00/08A4 | + 102 | 1 GP2IO.s 102 | Code | 11 | | 2 | 00/08A4 : A2 09 | READBYTE LDX #$09 ; reading 8 bits requires 9 transitions. + 103 | 1 GP2IO.s 103 | Code | 11 | | 2 | 00/08A6 : A9 00 | LDA #$00 ; clear the accumulator + 104 | 1 GP2IO.s 104 | Code | 11 | | 2 | 00/08A8 : 85 EF | STA {$EF} ; $EF is staging for received byte, set 0 + 105 | 1 GP2IO.s 105 | Code | 11 | | 2 | 00/08AA : 85 EE | STA {$EE} ; $EE is staging for each bit, set 0 + 106 | 1 GP2IO.s 106 | Code | 11 | | 3 | 00/08AC : 8D 5D C0 | CTSON STA {$C05D} ; set ANN2 HIGH, indicate to AVR "Clear to Send" + 107 | 1 GP2IO.s 107 | Code | 11 | | 2 | 00/08AF : A0 FF | LOOPSTART LDY #$FF ; start wait loop + 108 | 1 GP2IO.s 108 | Code | 11 | | 1 | 00/08B1 : C8 | LOOPCOUNT INY ; Increment Y - rolls over to 0 on first run (loopcount) + 109 | 1 GP2IO.s 109 | Code | 11 | | 3 | 00/08B2 : AD 62 C0 | LDA {$C062} ; check PB1 status hi/low + 110 | 1 GP2IO.s 110 | Code | 11 | | 2 | 00/08B5 : 29 80 | AND #$80 ; clear 0-6 bits (just need bit 7, all others float) + 111 | 1 GP2IO.s 111 | Code | 11 | | 2 | 00/08B7 : C5 EE | CMP {$EE} ; compare Accumulator 7 bit with $EE, previous PB2 value + 112 | 1 GP2IO.s 112 | Code | 11 | | 2 | 00/08B9 : D0 02 | BNE BITCHANGE ; if PB2 has changed state, store in $EE (bitchange) + 113 | 1 GP2IO.s 113 | Code | 11 | | 2 | 00/08BB : F0 F4 | BEQ LOOPCOUNT ; bit hasn't changed yet, return to (loopcount) + 114 | 1 GP2IO.s 114 | Code | 11 | | 2 | 00/08BD : 85 EE | BITCHANGE STA {$EE} ; (bitchange) + 115 | 1 GP2IO.s 115 | Code | 11 | | 2 | 00/08BF : C0 44 | CPY #$44 ; if the loop count is more than 68, bit is one. Bit is set in Carry + 116 | 1 GP2IO.s 116 | Code | 11 | | 2 | 00/08C1 : 26 EF | ROL {$EF} ; rotate the new bit into $EF, our result byte. + 117 | 1 GP2IO.s 117 | Code | 11 | | 1 | 00/08C3 : CA | DEX ; decrement X, our bit count + 118 | 1 GP2IO.s 118 | Code | 11 | | 2 | 00/08C4 : D0 E9 | BNE LOOPSTART ; if bit count is not yet full, loop back to (loopcount) + 119 | 1 GP2IO.s 119 | Code | 11 | | 3 | 00/08C6 : 8D 5C C0 | CTSOFF STA {$C05C} ; if bit count is full, set ANN2 LOW, CTS off + 120 | 1 GP2IO.s 120 | Code | 11 | | 2 | 00/08C9 : A5 EF | LDA {$EF} ; puts received byte into Accumulator + 121 | 1 GP2IO.s 121 | Code | 11 | | 1 | 00/08CB : 60 | RTS ; return with byte in Accumulator + 122 | 1 GP2IO.s 122 | Empty | 11 | | 0 | 00/08CC | +------+-------------------+-------------+----+---------+------+-----------------------+------------------------------------------------------------------- diff --git a/GPIO Routines.dsk b/GPIO Routines.dsk index d266044f756b59d0537315e3ec0a4963973fabd6..389f1ff83d8d8f511004669966e00b99172ae128 100755 GIT binary patch delta 247 zcmZp8z|ru4V*@ucqx@zb=G`o6qV54kp8gDQz!t^8$Z&>%;hYj5Cj-M_2!m;|BBRJ= zMh+E_HZ|^B>+2P~IaW3()N(B401_)T6juCESi-^Cpz!wZF`(Fmw+elK6BM%kcD1sv zWN2ku$pTW!4kVVb?PXxntOv55u`Ojg%6{Qp!b%4qPa%$@H|7A)j1M1LITBVXD&%vl z)CUo|AVLOc?#fj_OICIOSqTd`R9oNnMjlXmJArkPh)+MqBCg)(1E((h?TtFHh!se8 VTzJwOaUfw+XAEQ0-er3kivgp8TJ!(_ delta 42 ycmZp8z|ru4V*@ucqy1(c=G`oll^CryGjgafGsFq)81u!8H)iVFAhfl diff --git a/_FileInformation.txt b/_FileInformation.txt index 4ac39a2..9dd9ff9 100644 --- a/_FileInformation.txt +++ b/_FileInformation.txt @@ -2,3 +2,4 @@ sendbyte=Type(00),AuxType(0000),VersionCreate(70),MinVersion(BE),Access(E3),Fold readbyte=Type(00),AuxType(0000),VersionCreate(70),MinVersion(BE),Access(E3),FolderInfo1(000000000000000000000000000000000000),FolderInfo2(000000000000000000000000000000000000) bufferedio=Type(00),AuxType(0000),VersionCreate(70),MinVersion(BE),Access(E3),FolderInfo1(000000000000000000000000000000000000),FolderInfo2(000000000000000000000000000000000000) twiddle=Type(00),AuxType(0000),VersionCreate(70),MinVersion(BE),Access(E3),FolderInfo1(000000000000000000000000000000000000),FolderInfo2(000000000000000000000000000000000000) +GP2IO=Type(00),AuxType(0000),VersionCreate(70),MinVersion(BE),Access(E3),FolderInfo1(000000000000000000000000000000000000),FolderInfo2(000000000000000000000000000000000000)