WRTWO
– print characters in X and A, A first via WRT
– fall through in WRT.

CRLF
– print CR and LF via WRTWO
– wait (CRDLY * serial bit time)

The wait can be extended by increasing the default of CRDLY of 1, obviously to give a slow teletype a chance to perform a CRLF.

.WH 7000 7100
;18700085F9A923D055A9168D036EA208BDF7739DF7FFCAD0F786EA0F19
;18701886E786E8CA9A4C5070E3AD026E4A90FA8E046EAD056E10040BF3
;187030E6EAD0F4984D026E2901F0EF8810ECAD046E49FF4A46EA900D9F
;187048020980C8F0F685EB580085F968482910F0270A85FED84A860C84
;187060FA84FB6885F86869FF85F66869FF85F7BA86FC208A72A6FE10D9
;187078A92A20C072A952D016A5F96CF8FFA90085E785E4208A72A90E4A
;1870902E20C67220E972A206DD0671D019A5FD85E986FDA97185ED0E1D
;1870A8BD0D7185ECE003B0032074736CEC00CA10DFA93F20C672900C5A
;1870C0C538A5F0E5EE85E5A5F1E5EFA805E560A5EE85F6A5EF85F71291
;1870D860A90095EE95EF6020B3739010A20081EEC1EEF00568684C0D87
;1170F0BA70207C72209773C6FE60A9F885EEA9000AB4
.

The format is similar to what the KIM-1 reads and writes.

A record is made up of:

‘;’ XX YYYY D..D CCCC

where
XX is number of databytes
YYYY is load address
D..D are XX databytes
CCCC is checksum, sum of XX YYYY and D.D)

The Jolt Simulator end Convert 8 bit hex utility know this format as ‘TIM’ file.

0421   71C2 20 E9 72    WO     JSR RDOC          ; RD 2ND CMD CHAR
0422   71C5 85 FE              STA TMPC
0423   71C7 20 77 73           JSR SPACE
0424   71CA 20 A4 73           JSR RDOA
0425   71CD 20 87 73           JSR T2T2         ; SA TO TMP2
0426   71D0 20 77 73           JSR SPACE         ; SPACE BEFORE NEXT ADDRESS
0427   71D3 20 A4 73           JSR RDOA
0428   71D6 20 87 73           JSR T2T2          ; SA TO TMP0, EA TO TMP2
0429   71D9 20 E9 72           JSR RDOC          ; DELAY FOR FINAL CR
0430   71DC A5 FE              LDA TMPC
0431   71DE             ;
0432   71DE C9 48              CMP #'H'
0433   71E0 D0 59              BNE WB

WO
What is happening here?

• character after the W is read INTO tmpc(421-422
• a space is printed (423)
• Start address is read into TMP0 (424-425)
• End address address is read into TMP2 (428-429)
• Any character is read to end the commandline (429)
• if second character in TMPC is B then goto WB (write BNPF format) (432-433)
• else continue with WH0

Helper subroutines with arguments in TMP0 locations

0707   7387 A2 02       T2T2   LDX #2
0708   7389 B5 ED       T2T21  LDA TMP0-1,X
0709   738B 48                 PHA
0710   738C B5 EF              LDA TMP2-1,X
0711   738E 95 ED              STA TMP0-1,X
0712   7390 68                 PLA
0713   7391 95 EF              STA TMP2-1,X
0714   7393 CA                 DEX
0715   7394 D0 F3              BNE T2T21
0716   7396 60                 RTS
0717   7397             ;
0718   7397             ;INCREMENT (TMP0,TMP0+1) BY 1
0719   7397 E6 EE       INCTMP INC TMP0          ;LOW BYTE
0720   7399 F0 01              BEQ INCT1
0721   739B 60                 RTS
0722   739C             ;
0723   739C E6 EF       INCT1  INC TMP0+1        ;HIGH BYTE
0724   739E F0 01              BEQ SETWRP
0725   73A0 60                 RTS
0726   73A1             ;
0727   73A1 E6 E4       SETWRP INC WRAP          ;POINTER HAS WRAPPED AROUND - SET FLAG
0728   73A3 60                 RTS
0729   73A4             ;

0262   70C1 38          DCMP   SEC               ; TMP2-TMP0 DOUBLE SUBTRACT
0263   70C2 A5 F0              LDA TMP2
0264   70C4 E5 EE              SBC TMP0
0265   70C6 85 E5              STA DIFF
0266   70C8 A5 F1              LDA TMP2+1
0267   70CA E5 EF              SBC TMP0+1
0268   70CC A8                 TAY               ; RETURN HIGH ORDER PART IN Y
0269   70CD 05 E5              ORA DIFF          ; OR LO FOR EQU TEST
0270   70CF 60                 RTS

0278   70D9 A9 00       ZTMP   LDA #0            ; CLEAR REGS
0279   70DB 95 EE              STA TMP0,X
0280   70DD 95 EF              STA TMP0+1,X
0281   70DF 60                 RTS

0518   727C 48          CADD   PHA               ; SAVE A
0519   727D 18                 CLC
0520   727E 65 F2              ADC TMP4
0521   7280 85 F2              STA TMP4
0522   7282 A5 F3              LDA TMP4+1
0523   7284 69 00              ADC #0
0524   7286 85 F3              STA TMP4+1
0525   7288 68                 PLA               ; RESTORE A
0526   7289 60                 RTS

T2T2
– exchange TMP0 and TMP2 addresses

INCTMP

Increment address in TMP0 (low) and TMP0+1 (high) with 1
– increment low part of address TMP0
– if wrapped over then increment high part of address TMP0+1
– if high part wrapped over to 0000 the set WRAP flag to true

ZTMP
-zero TMP0+X an TMP0+1 locations

CADD
– add byte in A to 16 bit checksum in TMP4 and TMP4+1, A saved

DCMP
– subtract TMP2-TMP0 and leave result in DIFF and Y

WH

0434   71E2             ;
0435   71E2 A6 E4       WH0    LDX WRAP          ;IF ADDR HAS WRAPPED AROUND
0436   71E4 D0 52              BNE BCCST         ;THEN TERMINATE WRITE OPERATION
0437   71E6             ;
0438   71E6 20 8A 72           JSR CRLF
0439   71E9 A2 18              LDX #24
0440   71EB 86 FE              STX RCNT          ; RCNT=24
0441   71ED A2 04              LDX #4            ; CLEAR CKSUM
0442   71EF 20 D9 70           JSR ZTMP
0443   71F2             ;
0444   71F2 A9 3B              LDA #59		 ; ';'
0445   71F4 20 C6 72           JSR WROC          ; WR RCD MARK
0446   71F7             ;
0447   71F7 20 C1 70           JSR DCMP          ; EA-SA (TMP0+2-TMP0) DIFF IN LOC DIFF,+1
0448   71FA 98                 TYA               ; MS BYTE OF DIFF
0449   71FB D0 0A              BNE WH1
0450   71FD A5 E5              LDA DIFF
0451   71FF C9 17              CMP #23
0452   7201 B0 04              BCS WH1           ; DIFF GT 24
0453   7203 85 FE              STA RCNT          ; INCR LAST RCNT
0454   7205 E6 FE              INC RCNT
0455   7207 A5 FE       WH1    LDA RCNT
0456   7209 20 7C 72           JSR CADD          ; ADD TO CKSUM
0457   720C 20 B1 72           JSR WROB          ; RCC CNT IN A
0458   720F A5 EF              LDA TMP0+1        ; SA HO
0459   7211 20 7C 72           JSR CADD
0460   7214 20 B1 72           JSR WROB
0461   7217 A5 EE              LDA TMP0          ; SA LO
0462   7219 20 7C 72           JSR CADD
0463   721C 20 B1 72           JSR WROB
0464   721F             ;
0465   721F A0 00       WH2    LDY #0
0466   7221 B1 EE              LDA (TMP0),Y
0467   7223             ;
0468   7223 20 7C 72           JSR CADD          ; INC CKSUM, PRESERVES A
0469   7226 20 B1 72           JSR WROB
0470   7229 20 97 73           JSR INCTMP        ; INC SA
0471   722C C6 FE              DEC RCNT
0472   722E D0 EF              BNE WH2           ; LOOP FOR OP TO 24 BYTE
0473   7230             ;
0474   7230 20 9E 72           JSR WROA4         ; WRITE CKSUM
0475   7233             ;
0476   7233 20 C1 70           JSR DCMP
0477   7236 B0 AA              BCS WH0           ; LOOP WHILE EA GT OR = SA
0478   7238 4C 86 70    BCCST  JMP START

What is happening here?
called from WO so
– start address in TMP0
– end address in TMP0+2

loop records
stop if address wraps around 0 (from (435-436)
write CRLF
record count = 24, hex $18 (439-440)
zero checksum low and high in TMP0+3,4 = TMP4 (442)
increment TMP and check wrap (470)
loop bytes

until all bytes between start address and end address are dumped

What is happening here?
The registers are loaded from the zeropage save locations, where they were stored by the interrupt (BRK/IRQ).
In the right order for RTI to jump to the Program counter on the stack.

The serial interface uses two pins of Port B. PB0 is serial output, PB1 serial input. THe srial signals are handled via bitbanging and the baudrate is determined at startup.
The hardware part of the Jolt has two options, selectable with jumpers:

1. 20 mA current loop.
   Build with transistors and the resistors 220/270 to create the current loop.
2. RS232C serial interface
   Classical solution with the line drivers 1488/1489.

Note that when using a TTL USB requires to invert the signals. You can tap the output from pin U11D, for the input you need an inverter (a spare 7404 will do) to connect to PB1

Routines RDT and WRT are for receiving and sending characters via the serial interface PB0 and PB1, bit-banged.
RDT echoes every character received as it comes in, bit for bit.

Determine baud rate at startup

0157   701C CA                 DEX             ; X=FF
0158   701D 9A                 TXS             ; SP=FF
0160   701E             ;                      ; COMPUTE BIT-TIME CONSTANT, X=FF
0161   701E             ;
0162   701E A0 01              LDY #1          ; SET TO MEASURE 2 BITS
0163   7020 84 E3              STY CRDLY       ;INIT OR DELAY TIME PARAMETER
0164   7022 AD 02 6E    R0     LDA MPB         ; WAIT FOR START
0165   7025 4A                 LSR A
0166   7026 90 FA              BCC R0
0167   7028             ;
0168   7028 8E 04 6E    R2     STX MCLKIT      ; START CLOCK INITIALLY WITH FF
0169   702B AD 05 6E    R3     LDA MCLKIF
0170   702E 10 04              BPL R4
0171   7030 E6 EA              INC MAJORT      ; COUNT MAJOR T
0172   7032 D0 F4              BNE R2          ; GO RESTART CLOCK WITH X = FF
0173   7034             ;
0174   7034 98          R4     TYA
0175   7035 4D 02 6E           EOR MPB
0176   7038 29 01              AND #1
0177   703A F0 EF              BEQ R3          ; WAIT FOR Y BIT 0 AND SERIAL-IN NOT EQU
0178   703C 88                 DEY
0179   703D 10 EC              BPL R3          ; LOOP UNTIL START OF BIT 2
0180   703F             ;
0181   703F AD 04 6E           LDA MCLKRD
0182   7042 49 FF              EOR #$FF        ; COMPLEMENT RESIDUE
0183   7044 4A          R5     LSR A           ; HALF IT
0184   7045 46 EA              LSR MAJORT      ; HALF MAJOR
0185   7047 90 02              BCC R6
0186   7049 09 80              ORA #$80        ; PROPAGETE HC TO LC
0187   704B C8          R6     INY
0188   704C F0 F6              BEQ R5
0189   704E 85 EB              STA MINORT

What is happening here?
After RESET the baudrate is determined by measuring the length of the start bit of an incoming serial character. This means any character is usable where the first data bit is the opposite of the start bit (0). The TIM manual suggests using Carriage Return, which has the odd value 13, the lsb is 1 . SPACE ($20 0010 0000) for example does not work, any character with an odd value is OK.

The goal of this piece of code is to establish two variables: MAJORT and MINORT.

• The routine is entered with X = FF due to the stack pointer initialization
• The delay is measured by using the CLKIT Timer of the RRIOT filled with FF (174-179)
• MINORT is the value to let the timer run
• MAJORT is the number to repeat the timer
• the exact timer value is corrected (181-189)

Delay half and whole bit time serial as determined at startup

0634   731D             ;
0635   731D 20 20 73    DLY2   JSR DLY1
0636   7320 48          DLY1   PHA               ; SAVE FLAGS AND A
0637   7321 08                 PHP
0638   7322 8A                 TXA               ; SAVE X
0639   7323 48                 PHA
0640   7324 A6 EA              LDX MAJORT
0641   7326 A5 EB              LDA MINORT
0642   7328             ;
0643   7328 8D 04 6E    DL2    STA MCLKIT
0644   732B             ;
0645   732B AD 05 6E    DL3    LDA MCLKIF
0646   732E 10 FB              BPL DL3
0647   7330 CA                 DEX
0648   7331 08                 PHP
0649   7332 AD 04 6E           LDA MCLKRD        ; RESET TIMER INT FLAG
0650   7335 28                 PLP
0651   7336 10 F3              BPL DL3
0652   7338             ;
0653   7338 68                 PLA               ; RESTORE REGS
0654   7339 AA                 TAX
0655   733A 28                 PLP
0656   733B 68                 PLA
0657   733C 60          DLX    RTS

What is happening here?

• DLY2 waits one bit time (635).
• DLY1 is used to wait one half bit time, as determined at startup.
• Registers are saved (636-639)
• The timer is run with value MINORT for MAJORT times (640-651)

WRT WROC Write character to serial interface

0572   72C6             ;
0573   72C6             ;  WRITE SERIAL OUTPUT
0574   72C6             ;  A = CHAR TO BE OUTPUT
0575   72C6             ;
0576   72C6 20 1D 73    WRT    JSR DLY2
0577   72C9 A2 09              LDX #9
0578   72CB             WROC   =WRT
0579   72CB 49 FF              EOR #$FF          ; COMPLEMENT A
0580   72CD 38                 SEC
0581   72CE             ;
0582   72CE 20 DA 72    WRT1   JSR OUT
0583   72D1 20 1D 73           JSR DLY2
0584   72D4 4A                 LSR A
0585   72D5 CA                 DEX
0586   72D6 D0 F6              BNE WRT1
0587   72D8 F0 3F              BEQ RDT5
0588   72DA                                      ; *USE BNE?
0589   72DA             ;
0590   72DA 48          OUT    PHA               ; SAVE A
0591   72DB AD 02 6E           LDA MPB           ; OUTPUT BIT FROM CY
0592   72DE 29 FD              AND #%11111101
0593   72E0 90 02              BCC OUT1
0594   72E2 09 02              ORA #%00000010
0595   72E4 8D 02 6E    OUT1   STA MPB
0596   72E7 68                 PLA               ; RESTORE A
0597   72E8 60                 RTS
0598   72E9             ;

What is happening here?

• to be sure the serial line is quiet a bit time is waited (576)
• send start bit via OUT(580)
• send out 8 data bits and a stop bit (577)
• complement character to write (579)
• loop 9 bits
• shift 8 databits into carry and send OUT with delay of one databit (582-586)
• wait last bit as stop bit via carry, get out via RDT5 and OUT (585)

OUT

isolate PB1 (592)
if carry set bit else clear bit(592-594)
set databit in PB1 (595)

RDT RDOC Read character from serial interface

0599   72E9             ;  OUTPUT  RETURNS CHAR IN A
0600   72E9             ;
0601   72E9 A5 E7       RDT    LDA HSPTR         ; TEST HS PTR OPTION
0602   72EB 4A                 LSR A
0603   72EC B0 4F              BCS RDHSR
0604   72EE             RDOC   =RDT
0605   72EE A2 08              LDX #8
0606   72F0             ;
0607   72F0 AD 02 6E    RDT1   LDA MPB
0608   72F3 4A                 LSR A             ; WAIT FOR START BIT
0609   72F4 90 FA              BCC RDT1
0610   72F6             ;
0611   72F6 20 20 73           JSR DLY1
0612   72F9 20 DA 72           JSR OUT           ; ECHO START BIT
0613   72FC             ;
0614   72FC 20 1D 73    RDT2   JSR DLY2
0615   72FF AD 02 6E           LDA MPB           ; CY = NEXT BIT
0616   7302 4A                 LSR A
0617   7303 20 DA 72           JSR OUT           ; ECHO
0618   7306             ;
0619   7306 08                 PHP               ; SAVE BIT
0620   7307 98                 TYA               ; Y CONTAINS CHAR BEING FORMED
0621   7308 4A                 LSR A
0622   7309 28                 PLP               ; RECALL BIT
0623   730A 90 02              BCC RDT4
0624   730C 09 80              ORA #$80          ; ADD IN NEXT BIT
0625   730E A8          RDT4   TAY
0626   730F CA                 DEX
0627   7310 D0 EA              BNE RDT2          ; LOOP FOR 8 BITS
0628   7312 49 FF              EOR #$FF          ; COMPLEMENT DATA
0629   7314 29 7F              AND #$7F          ; CLEAR PARITY
0630   7316             ;
0631   7316 20 1D 73           JSR DLY2
0632   7319 18          RDT5   CLC
0633   731A 20 DA 72           JSR OUT           ;AND DELAY 2 HALF-BIT-TIMES

What is happening here?
The read character routine echoes the incoming serial signal as it comes in!
Input is 8N1, reduced t0 7 databits

• check if High Speed reader is wanted, branch to RDHSR (60-603)
• 8 databits to receive (605)
• Wait for startbit
• delay half databit time
• echo start bit to serial out
• for 8 databits loop (605)
• wait databit time 614)
• read in databit into carry (615-616)
• send out databit (617)
• shift databit into received character (620-625)
• complement received character (628)
• mask off 8 bit parity (629)
• wait databit time
• send stop bit (632 – 633)
• fall into DLY2 and return there (634-657

.LH
;160100208A72A9208500A500C97EF00820C672E6004C07010007F7
;00
.R  CE05 35 55 DB 00 DB
.:  0100
.R  0100 35 55 DB 00 DB
.M  0100 20 8A 72 A9 20 85 00 A5
.G
.R  0100 B0 10 0D 05 FF
.G
 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmno
pqrstuvwxyz{|}
 *  0116 33 7E 0D 05 FF
.

0140   7000 85 F9       NMINT  STA ACC
0141   7002 A9 23              LDA #'#'           ; SET A=# TO INDICATE NMINT ENTRY
0142   7004 D0 55              BNE B3            ; JMP B3
0143   7006             ;

0190   7050             ;
0191   7050 58                 CLI               ; ENABLE INTS
0192   7051 00                 BRK               ; ENTER TIM BY BRK
0193   7052   

          ;
0194   7052 85 F9       INTRQ  STA ACC           ; SAVE ACC
0195   7054 68                 PLA               ; FLAGS TO A
0196   7055 48                 PHA               ; RESTORE STACK STATUS
0197   7056 29 10              AND #$10          ; TEST BRK FLAG
0198   7058 F0 27              BEQ BX            ; USER INTERRUPT
0199   705A             ;
0200   705A 0A                 ASL A             ; SET A=SPACE (10 X 2 = 2C)
0201   705B 85 FE       B3     STA TMPC          ; SAVE INT TYPE FLAG
0202   705D D8                 CLD               ; CLEAR DECIMAL MODE
0203   705E 4A                 LSR A             ; # IS ODD, SPACE IS EVEN
0204   705F                                      ; SET CY FOR PC BRK CORRECTION
0205   705F             ;
0206   705F 86 FA              STX XR            ; SAVE X
0207   7061 84 FB              STY YR            ; Y
0208   7063 68                 PLA
0209   7064 85 F8              STA FLGS          ; FLAGS
0210   7066 68                 PLA
0211   7067 69 FF              ADC #$FF          ; CY SET TO PC-1 FOR BRK
0212   7069 85 F6              STA PCL
0213   706B 68                 PLA
0214   706C 69 FF              ADC #$FF
0215   706E 85 F7              STA PCH
0216   7070 BA                 TSX
0217   7071 86 FC              STX SP            ; SAVE ORIG SP
0218   7073             ;
0219   7073 20 8A 72    B5     JSR CRLF
0220   7076 A6 FE              LDX TMPC
0221   7078             ;
0222   7078 A9 2A              LDA #'*'
0223   707A 20 C0 72           JSR WRTWO
0224   707D A9 52              LDA #'R'           ; SET FOR R DISPLAY TO PERMIT
0225   707F D0 16              BNE S0            ;   IMMEDIATE ALTER FOLLOWING BREAKPOINT.
0226   7081             ;
0227   7081 A5 F9       BX     LDA ACC
0228   7083 6C F8 FF           JMP (UINT)        ; CONTROL TO USER INTRO SERVICE ROUTINE

0729   73A4             ;
0730   73A4             ; READ HEX ADR; RETURN HO IN TMP0; LO IN TMP0+1 AND CY=1
0731   73A4             ;    IF SP CY=0
0732   73A4             ;
0733   73A4 20 B3 73    RDOA   JSR RDOB          ; READ 2 CHAR BYTE
0734   73A7 90 02              BCC RDOA2         ; SPACE
0735   73A9             ;
0736   73A9 85 EF              STA TMP0+1
0737   73AB 20 B3 73    RDOA2  JSR RDOB
0738   73AE 90 02              BCC RDEXIT        ; SP
0739   73B0 85 EE              STA TMP0
0740   73B2 60          RDEXIT RTS
0741   73B3             ;
0742   73B3             ;  READ HEX BYTE AND RETURN IN A, AND CY=1
0743   73B3             ;    IF SP CY=0
0744   73B3             ;    Y REG IS PRESERVED
0745   73B3             ;
0746   73B3 98          RDOB   TYA               ; SAVE Y
0747   73B4 48                 PHA
0748   73B5 A9 00              LDA #0            ; SET DATA = 0
0749   73B7 85 EC              STA ACMD
0750   73B9 20 E9 72           JSR RDOC
0751   73BC C9 0D              CMP #$0D          ; CR?
0752   73BE D0 06              BNE RDOB1
0753   73C0 68                 PLA               ;YES - GO TO START
0754   73C1 68                 PLA               ;CLEANING STACK UP FIRST
0755   73C2 68                 PLA
0756   73C3 4C 86 70           JMP START
0757   73C6             ;
0758   73C6 C9 20       RDOB1  CMP #' '           ; SPACE
0759   73C8 D0 0A              BNE RDOB2
0760   73CA 20 E9 72           JSR RDOC          ; READ NEXT CHAR
0761   73CD C9 20              CMP #' '
0762   73CF D0 0F              BNE RDOB3
0763   73D1 18                 CLC               ; CY=0
0764   73D2 90 12              BCC RDOB4
0765   73D4             ;
0766   73D4 20 EB 73    RDOB2  JSR HEXIT         ; TO HEX
0767   73D7 0A                 ASL A
0768   73D8 0A                 ASL A
0769   73D9 0A                 ASL A
0770   73DA 0A                 ASL A
0771   73DB 85 EC              STA ACMD
0772   73DD 20 E9 72           JSR RDOC          ; 2ND CHAR ASSUMED HEX
0773   73E0 20 EB 73    RDOB3  JSR HEXIT
0774   73E3 05 EC              ORA ACMD
0775   73E5 38                 SEC               ; CY=1
0776   73E6 AA          RDOB4  TAX
0777   73E7 68                 PLA               ; RESTORE Y
0778   73E8 A8                 TAY
0779   73E9 8A                 TXA               ;SET Z & N FLAGS FOR RETURN
0780   73EA 60                 RTS
0781   73EB             ;
0782   73EB C9 3A       HEXIT  CMP #$3A
0783   73ED 08                 PHP               ; SAVE FLAGS
0784   73EE 29 0F              AND #$0F
0785   73F0 28                 PLP
0786   73F1 90 02              BCC HEX09         ; 0-9
0787   73F3 69 08              ADC #8            ; ALPHA ADD 8+CY=9
0788   73F5 60          HEX09  RTS

RDOA read address as hex coded ASCII characters
Returns with address in TMP0

• Read high part of address 2 hex byte and store in TMP0
• Read high part of address 2 hex byte and store in TMP0
• return with Carry set if if valid address

RDOB
Read hex byte from serial input.
Either two hex characters or CR.
Return with Carry clear if space found in second character.
Note if invalid characters are entered only pressing Enter will get you out of this mesh!
Entering non-hex characters is accepted, and some address is returned.

• Save Y on stack (746-747)
• ACMD is used for building up hex value (748-749)
• read character (750)
• if CR (ENTER) then clean up stack from RTS return address and saved Y and jump to start (751-756)
• if space handle as zero and clear carry (758-764)
• HEXIT and shift to upper nibble (766-771)
• get second character (772)
• HEXIT and or in lower nibble (773-775)
• return in A and restore Y (776-780)

HEXIT
Convert from ASCII character to byte
Examples:
31 mask off upper nibble 01, delivers 1
42 mask of upper nibble 0010, add 9 delivers B
Note no check is made if this is actually hex ASCII 0-..9 or A..F. So any other character delivers nonsense.

What is happening here?

is it above 3A? must be A..F, set carry 1
mask off upper nibble
if A..F add 8+ carry
return A with byte

 DISPLAY COMMANDS
  ----------------

  .R          DISPLAY REGISTERS (PC,F,A,X,Y,SP)
  .M  ADDR    DISPLAY MEMORY ( 8 BYTES BEGINNING AT ADDR )


  ALTER COMMAND (:)
  -----------------
  .:  DATA      ALTERS PREVIOUSLY DISPLAYED ITEM OR NEXT ITEM


  PAPER TAPE I/O COMMANDS
  ------------------------

  .LH                   LOAD HEX TAPE
  .WB ADDR1 ADDR2       WRITE BNPF TAPE (FROM LOW ADDR1 TO HIGH ADDR2)
  .WH ADDR1 ADDR2       WRITE HEX TAPE (FROM LOW ADDR1 TO HIGH ADDR2)

  CONTROL COMMANDS
  ----------------

  .G                    GO, CONTINUE EXECUTION FROM CIRRENT PC ADDRESS

  .H                    TOGGLES HIGH-SPEED-READER OPTION
                          (IF ITS ON, TURNS IT OFF; IF OFF, TURNS ON

START

0096   0000             NCMDS  =7

0309   7106 3A          CMDS   .BYTE ':'
0310   7107 52                 .BYTE 'R'
0311   7108 4D                 .BYTE 'M'
0312   7109 47                 .BYTE 'G'
0313   710A 48                 .BYTE 'H'
0314   710B 4C                 .BYTE 'L'
0315   710C 57                 .BYTE 'W'         ; W MUST BE LAST CMD IN CHAIN
0316   710D 3A          ADRS   .BYTE ALTER-MP1
0317   710E 14                 .BYTE DSPLYR-MP1
0318   710F 1C                 .BYTE DSPLYM-MP1
0319   7110 5C                 .BYTE GO-MP1
0320   7111 6F                 .BYTE HSP-MP1
0321   7112 74                 .BYTE LH-MP1
0322   7113 C2                 .BYTE WO-MP1

0692   7374 20 77 73    SPAC2  JSR SPACE
0693   7377 48          SPACE  PHA               ; SAVE A,X,Y
0694   7378 8A                 TXA
0695   7379 48                 PHA
0696   737A 98                 TYA
0697   737B 48                 PHA
0698   737C A9 20              LDA #' '
0699   737E 20 C6 72           JSR WRT           ; TYPE SP
0700   7381 68                 PLA               ; RESTORE A,X,Y
0701   7382 A8                 TAY
0702   7383 68                 PLA
0703   7384 AA                 TAX
0704   7385 68                 PLA
0705   7386 60                 RTS

0229   7086             ;
0230   7086 A9 00       START  LDA #0            ;NEXT COMMAND FROM USER
0231   7088 85 E7              STA HSPTR         ;CLEAR H. S. PAPER TAPE FLAG
0232   708A 85 E4              STA WRAP          ;CLEAR ADDRESS WRAP-AROUND FLAG
0233   708C 20 8A 72           JSR CRLF
0234   708F A9 2E              LDA #'.'           ; TYPE PROMPTING '.'
0235   7091 20 C6 72           JSR WROC
0236   7094 20 E9 72           JSR RDOC          ; READ CMD, CHAR RETURNED In A
0237   7097             ;
0238   7097 A2 06       S0     LDX #NCMDS-1      ; LOCK-UP CMD
0239   7099 DD 06 71    S1     CMP CMDS,X
0240   709C D0 19              BNE S2
0241   709E             ;
0242   709E A5 FD              LDA SAVX          ; SAVE PRIVIOUS CMD
0243   70A0 85 E9              STA PREVC
0244   70A2 86 FD              STX SAVX          ; SAVE CURRENT CMD INDEX
0245   70A4 A9 71              LDA #MP1/256      ; JMP INDIRECT TO CMD CODE
0246   70A6 85 ED              STA ACMD+1        ;   ALL CMD CODE BEGINS ON MP1
0247   70A8 BD 0D 71           LDA ADRS,X
0248   70AB 85 EC              STA ACMD
0249   70AD E0 03              CPX #3            ; IF :, R OR M (0, 1, OR 2) SPACE 2
0250   70AF B0 03              BCS IJMP
0251   70B1 20 74 73           JSR SPAC2
0252   70B4             ;
0253   70B4 6C EC 00    IJMP   JMP (ACMD)
0254   70B7             ;
0255   70B7 CA          S2     DEX
0256   70B8 10 DF              BPL S1            ; LOOP FOR ALL CMDS
0257   70BA             ;
0258   70BA A9 3F       ERROPR LDA #'?'           ; OPERATOR ERR, TYPE '?', RESTART
0259   70BC 20 C6 72           JSR WROC
0260   70BF 90 C5              BCC START        

What is happening here?

START

• clear High speed reader flag (230-231)
• clear address wrap around flag (232)
• show prompt ‘.’ (233-235)
• read command character (236)
• command index = 7 (238)
• lookup command[index] in table CMDS (239)
• if not found decrement index
• if index > 0 continue else display ‘?’ error and jump back to to START (255-260)
• save previous command (243)
• lookup address of command address ADRS[index] (245-248)
• Add high part of address MP1 7100(245-246)
• if index = 3 then show 2 spaces : R M (249-251)
• jump indirect to address of command code (253)

SPAC2 SPAC

• print (2) space with A X Y saved and restored

CMDS
Table with the 7 command characters

ADRS
Table with address of code of the 7 commands, ordered the same as CMDS table

On the next pages the command code is presented:

• : modify memory ALTER-MP1
• R show registers DSPLYR-MP1 7114
• M show memory DSPLYM-MP1 711C
• G execute code GO-MP1 715C
• H Toggle High speed reader input HSP-MP1
• LH Load papertape LH-MP1
• WH WB write papertape WO-MP1 WH MO papertape WB BNPF format