Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 1 MON.ASM: Assembly Coordination $PAGINATE $PG PAGEWIDTH=131 $NOLN $TITLE(MON51-TUC52 950530-1.02) $SUBTITLE(MON.ASM: Assembly Coordination) ; ; ; MON51 -- A firmware system to provide monitor functions ; for the 8051 family of parts ; ; ; Author: Paul Newland ; ; Features that must be added before next release, in priority order: ; ; 1. ; 2. ; 3. ; 4. ; 5. ; 6. ; 7. ; 8. ; 9. ; 10. ; ; ; Revision History: ; 901210-0.02 New stuff ; ; 931121-0.04 Mods for TUC52 system ; ; 950128-1.01 Add verify command and provide paging on help ; ; 950530-1.02 Fix address problem with ACALL and AJMP ; =0000 FALSE EQU 0 =0001 TRUE EQU 1 =0000 DEV EQU FALSE ; this determines ROM and RAM locations ;RAM256 EQU FALSE ; true if RAM is 256 =0001 UARTINT EQU TRUE ; flag for UART internal (false for external) =0001 CPU52 EQU TRUE ; Flag for 8052 (serport baud rate timer) $SETLN(NOTES.ASM); %INCLUDE NOTES.ASM ; include programmers notes $SUBTITLE(PNOTES.ASM: Programmers Notes) Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 2 PNOTES.ASM: Programmers Notes ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; programmer's notes go here ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; ; Copyright (c) 1991-- 1994 Paul Newland, P.E. All rights reserved. ; ; ; This code was written for two purposes: ; ; 1) to learn about 8051 code ; 2) to obtain a tool for debugging software ; ; When I wrote this code I was a novice at 8051 code, and this ; work shows it. However, the functions the monitor provides ; are useful, notwithstanding that the functions may be capable ; of being provided in half the ROM space. Given that ROM is ; cheap I haven't bothered to go back and clean up the code to ; make it tighter. ; ; Please let me know if you find bugs or incorporate improvements. ; I would like to see that these get reflected back into the code ; to aid any other users who make use of it. ; ; ; ; Paul Newland, January 1995 ; ; ; ; ; Inquires regarding the code should be directed to: ; ; Paul Newland, P.E. ; Post Office 205 ; Holmdel, NJ 07733-0205 ; ; ;******************************************** ; Revision History ;******************************************** ; ; 931122-0.04 ; Add Power On Vector and some BBRAM test routines ; ; 950128-1.01 ; Add verify on hex load ; Provide paging for HELP command ; ;******************************************** ; Features that to be added for next release ;******************************************** ; Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 3 PNOTES.ASM: Programmers Notes ; 1. test verify on hex load ; 2. have - dec the PC by one and then print all regs ; 3. ; 4. ; 5. ; 6. ; 7. ; 8. ; 9. ; 10. ; ; ; $RESETLN $SETLN(EQU.ASM); %INCLUDE EQU.ASM ; include defines and equates $SUBTITLE(EQU.ASM: Equates) Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 4 EQU.ASM: Equates ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; Global Constants ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; additional system defines =0000 RB0 EQU 000H ; value for MOV PSW,RXn to set to RB0 =0008 RB1 EQU 008H ; value for MOV PSW,RXn to set to RB1 =0010 RB2 EQU 010H ; value for MOV PSW,RXn to set to RB2 =0018 RB3 EQU 018H ; value for MOV PSW,RXn to set to RB3 ; for 8052 =00CB RCAP2H EQU 0CBH ; Capture high, T2 =00CA RCAP2L EQU 0CAH ; Capture low, T2 ; configuration dependent stuff =00E0 STKHI EQU 00E0H ; start of stack for 256 byte IDM =0060 STKLOW EQU 0060H ; start of stack for 128 byte IDM ; %IF DEV ; if development ;PGMBAS EQU 0C000H ; start of program memory ;XRAMBAS EQU 0EE00H ; start of external ram space ;VECBAS EQU 0EECAH ; start of ram vectors ;DEFRB EQU RB1 ; default register bank ; %ELSE ; must be finished ROMed code =0000 PGMBAS EQU 00000H ; start of program memory =EF00 XRAMBAS EQU 0EF00H ; start of external ram space =EFCA VECBAS EQU 0EFCAH ; start of ram vectors =0000 DEFRB EQU RB0 ; default register bank ; %ENDIF ;************************************************* ;************************************************* ;** RB0 RAM uses addresses 00-07 ** ;** RB1 RAM uses addresses 08-0F ** ;** ** ;************************************************* ;************************************************* ; ; ; ;********************************************************* ;********************************************************* ;** NOTE!!!! The following locations are only to be ** ;** used by the TEST routines. If other ** ;** monitor functions use them that will ** ;** wipe out user data -- TEST functions ** ;** are not intended to preserve user data ** ;** ** ;********************************************************* ;********************************************************* Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 5 EQU.ASM: Equates ; ; line input processing =0010 TMP0 EQU 010H ; (10) temp buffer =0011 TMP1 EQU 011H ; (11) temp buffer =0012 TMP2 EQU 012H ; (12) temp buffer =0013 TMP3 EQU 013H ; (13) temp buffer =0014 TMP4 EQU 014H ; (14) temp buffer =0015 TMP5 EQU 015H ; (15) temp buffer =0016 TMP6 EQU 016H ; (16) temp buffer =0017 TMP7 EQU 017H ; (17) temp buffer ; ;************************************************* ;************************************************* ;** Bit Addressable RAM ** ;************************************************* ;************************************************* ; =0020 SF0 EQU 020H ; System Flags "0" =0000 TMPF0 EQU SF0.0 ; temp flag bit ; ; ; ; character constants =000A ALF EQU 00AH ; ASCII LF char =000D ACR EQU 00DH ; ASCII CR char =0020 ASP EQU ' ' ; ASCII SPACE char =0008 ABSP EQU 008H ; ASCII BACK-SPACE char =001B AESC EQU 01BH ; ASCII ESCAPE char =007F ADEL EQU 07FH ; ASCII DELETE char =0000 ANULL EQU 000H ; ASCII NULL char =005F AERR EQU '_' ; ASCII ERROR char =0027 AAPOS EQU 027H ; ASCII APOSTROPHY =0007 ABELL EQU 007H ; ASCII BELL =0011 CTLQ EQU 'Q' AND 01FH ; Control Q =0013 CTLS EQU 'S' AND 01FH ; Control S ; external ports for development system =F100 ACEBAS EQU 0F100H ; external ACE UART (8250) =FE00 X8155A EQU 0FE00H ; Ath 8155 $RESETLN $SETLN(LOWMEM.ASM); %INCLUDE LOWMEM.ASM ; ram, strings and tables $SUBTITLE(LOWMEM.ASM: Lower memory space stuff) Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 6 LOWMEM.ASM: Lower memory space stuff DEFSEG ALPHA, ABSOLUTE ; just make it all absolute code SEG ALPHA ; run everything in ALPHA =0000 ORG PGMBAS ; start of program 0000 02 00C3 NULL LJMP START ; skip all the vector stuff 0003 02 EFFD LJMP VEC03 ; vector from location 03 to RAM 0006 12 0912 BK LCALL RBKPNT ; break point address, for test 0009 00 00 DB 0,0 ; consume space for next vector 000B 02 EFFA LJMP VEC0B ; vector from location 0B to RAM 000E 00 00 00 00 DB 0,0,0,0,0 ; consume space for next vector 0012 00 0013 02 EFF7 LJMP VEC13 ; vector from location 13 to RAM 0016 00 00 00 00 DB 0,0,0,0,0 ; consume space for next vector 001A 00 001B 02 EFF4 LJMP VEC1B ; vector from location 1B to RAM 001E 00 00 00 00 DB 0,0,0,0,0 ; consume space for next vector 0022 00 0023 02 EFF1 LJMP VEC23 ; vector from location 23 to RAM 0026 00 00 00 00 DB 0,0,0,0,0 ; consume space for next vector 002A 00 002B 02 EFEE LJMP VEC2B ; vector from location 2B to RAM 002E 00 00 00 00 DB 0,0,0,0,0 ; consume space for next vector 0032 00 0033 02 EFEB LJMP VEC33 ; vector from location 33 to RAM 0036 00 00 00 00 DB 0,0,0,0,0 ; consume space for next vector 003A 00 003B 02 EFE8 LJMP VEC3B ; vector from location 3B to RAM 003E 00 00 00 00 DB 0,0,0,0,0 ; consume space for next vector 0042 00 0043 02 EFE5 LJMP VEC43 ; vector from location 43 to RAM 0046 00 00 00 00 DB 0,0,0,0,0 ; consume space for next vector 004A 00 004B 02 EFE2 LJMP VEC4B ; vector from location 4B to RAM 004E 00 00 00 00 DB 0,0,0,0,0 ; consume space for next vector 0052 00 0053 02 EFDF LJMP VEC53 ; vector from location 53 to RAM 0056 00 00 00 00 DB 0,0,0,0,0 ; consume space for next vector 005A 00 005B 02 EFDC LJMP VEC5B ; vector from location 5B to RAM 005E 00 00 00 00 DB 0,0,0,0,0 ; consume space for next vector 0062 00 0063 02 EFD9 LJMP VEC63 ; vector from location 63 to RAM 0066 00 00 00 00 DB 0,0,0,0,0 ; consume space for next vector 006A 00 006B 02 EFD6 LJMP VEC6B ; vector from location 6B to RAM 006E 00 00 00 00 DB 0,0,0,0,0 ; consume space for next vector 0072 00 0073 02 EFD3 LJMP VEC73 ; vector from location 73 to RAM 0076 00 00 00 00 DB 0,0,0,0,0 ; consume space for next vector 007A 00 Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 7 LOWMEM.ASM: Lower memory space stuff 007B 02 EFD0 LJMP VEC7B ; vector from location 7B to RAM 007E 20 20 43 4F CPYRITE DB ' COPYRIGHT (C) 1991-1998 PAUL NEWLAND, P.E. ' 0082 50 59 52 49 0086 47 48 54 20 008A 28 43 29 20 008E 31 39 39 31 0092 2D 31 39 39 0096 38 20 50 41 009A 55 4C 20 4E 009E 45 57 4C 41 00A2 4E 44 2C 20 00A6 50 2E 45 2E 00AA 20 20 00AC 20 20 41 4C DB ' ALL RIGHTS RESERVED ' 00B0 4C 20 52 49 00B4 47 48 54 53 00B8 20 52 45 53 00BC 45 52 56 45 00C0 44 20 20 00C3 C2 AF START CLR EA ; ensure no interrupts at this point 00C5 75 D0 00 MOV PSW,#DEFRB ; select default register bank ; load the stack pointer depending on IDM size 00C8 78 E0 MOV R0,#STKHI ; try for high stack 00CA E6 MOV A,@R0 ; get a byte 00CB FB MOV R3,A ; save data in R3 00CC F4 CPL A ; complement it 00CD F6 MOV @R0,A ; put back to IDM 00CE 00 NOP ; kill some time 00CF 00 NOP ; to ensure that the bus 00D0 00 NOP ; has fully settled 00D1 E6 MOV A,@R0 ; get data from RAM, if any 00D2 F4 CPL A ; restore to original 00D3 6B XRL A,R3 ; see if same 00D4 70 06 JNZ START10 ; jump if not the same 00D6 75 81 E0 MOV SP,#STKHI ; go with a high stack value 00D9 02 00DF JMP START20 ; skip the alternate load 00DC 75 81 60 START10 MOV SP,#STKLOW ; default to low stack value START20 00DF 12 13C8 CALL INITSP ; init the serial port 00E2 12 102A CALL CBKPT ; clear any outstanding breakpoints 00E5 12 1426 CALL SIGNON ; print the signon message console MAIN ; this is the main loop 00E8 12 1437 CALL CRLF ; print newline 00EB D2 D7 SETB CY ; set CY for prompt MAIN05 00ED 50 03 JNC MAIN07 ; jump not prompt wanted 00EF 12 1430 CALL PROMPT ; output prompt 00F2 12 1452 MAIN07 CALL GETUCHE ; get an input char with echo 00F5 12 1458 CALL MAPC ; convert chars as required 00F8 FF MOV R7,A ; save A in R7 Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 8 LOWMEM.ASM: Lower memory space stuff 00F9 24 A5 ADD A,#255-'Z' ; see if more than 'Z' 00FB 40 EB JC MAIN ; no err msg, just get next command 00FD EF MOV A,R7 ; restore data 00FE 24 BF ADD A,#256-'A' ; see if 'A' or more 0100 50 E6 JNC MAIN ; no err msg, just get next command 0102 23 RL A ; multiply by 2 0103 C2 E0 CLR ACC.0 ; ensure lsb is clear 0105 FF MOV R7,A ; save A in R7 0106 74 ED MOV A,#LOW MAIN05 ; get low byte of return address 0108 C0 E0 PUSH ACC ; save on stack 010A 74 00 MOV A,#HIGH MAIN05 ; get high byte of return address 010C C0 E0 PUSH ACC ; save on stack ; now any RET w/o CALL goes to MAIN05 010E EF MOV A,R7 ; restore A 010F 90 011D MOV DPTR,#MAIN20 ; pt to jump table 0112 93 MOVC A,@A+DPTR ; get high byte of address 0113 FE MOV R6,A ; save in R6 0114 EF MOV A,R7 ; restore A 0115 04 INC A ; to to 2nd byte 0116 93 MOVC A,@A+DPTR ; get low byte of address 0117 C0 E0 PUSH ACC ; save on stack 0119 EE MOV A,R6 ; recover high byte 011A C0 E0 PUSH ACC ; save on stack 011C 22 RET ; go to that routine ; next RET w/o call will take MAIN05 ; value previously placed on stack 011D 00E8 MAIN20 DW MAIN ; a - no command yet 011F 0578 DW BLAST ; b - repetitive memory read or write 0121 0660 DW CHECK ; c - checksum on code or data space 0123 06F3 DW DISPX ; d - display 0125 00E8 DW MAIN ; e - no command yet 0127 0975 DW FIND ; f - find data in data space 0129 08B7 DW GO ; g - go to user program 012B 085C DW HELP ; h - no command yet 012D 00E8 DW MAIN ; i - no command yet 012F 0A17 DW JAM ; j - jam (data space) start end data 0131 00E8 DW MAIN ; k - no command yet 0133 0A3F DW LSTACK ; l - list stack 0135 0A76 DW MOVE ; m - move start end to 0137 0544 DW NEXT ; n - next instruction w/breakpoint 0139 00E8 DW MAIN ; o - no command yet 013B 0AB6 DW POV ; p - power on vector 013D 00E8 DW MAIN ; q - no command yet 013F 0BF8 DW RX ; r - receive INTEL hex code 0141 0AFD DW SUB ; s - substitute memory and regs 0143 0000? DW TESTSYS ; t - test system command -----> LOWMEM.ASM:123 ERROR 14: Undefined symbol: TESTSYS -----> LOWMEM.ASM:123 ERROR 42: Undefined Value 0145 00E8 DW MAIN ; u - no command yet 0147 0C32 DW VERIFY ; v - verify using R like command 0149 00E8 DW MAIN ; w - no command yet 014B 0C6C DW EXAMINE ; x - examine special locations 014D 00E8 DW MAIN ; y - no command yet 014F 0567 DW ZNEXT ; z - no command yet Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 9 LOWMEM.ASM: Lower memory space stuff $RESETLN $SETLN(SNGLSTEP.ASM); %INCLUDE SNGLSTEP.ASM ; single step routines $SUBTITLE(SNGLSTEP.ASM: Single Step Code) Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 10 SNGLSTEP.ASM: Single Step Code ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; Single Step ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; this code assumes that the code and data spaces are double mapped. ; therefore, references to code space may be done with either the ; MOVX or MOVC instruction. Restricting use to only MOVC doesn't make ; sense because for the breakpoints to work the code must be in RAM or ; the monitor can't insert the software trap (actually a LCALL) into ; the memory. MVPCDP ; mov the user's PC to the data pointer 0151 90 EF1F MOV DPTR,#UPCH ; pt to user PC high 0154 12 1626 CALL DPATDP ; pt to address 0157 22 RET ; that's all SETGO ; set PC and go to user program 0158 12 15B9 CALL ZARG ; clear ARGs w/o fouling DPTR 015B AB 83 MOV R3,DPH ; save high value in R3 015D AC 82 MOV R4,DPL ; save low value in R4 015F 90 EF01 MOV DPTR,#ARGV0 ; pt to ARGV0 0162 EB MOV A,R3 ; recover high 0163 F0 MOVX @DPTR,A ; store at high ARGV0 0164 A3 INC DPTR ; pt to low ARGV0 0165 EC MOV A,R4 ; recover low 0166 F0 MOVX @DPTR,A ; store at low ARGV0 0167 02 08CC JMP GO20 ; set break, load regs and goto user pgm TSJMP03 ; come here for 3 byte jump instructions what will jump 016A 3151 CALL MVPCDP ; get user's PC to DPTR 016C A3 INC DPTR ; pt to 2nd byte 016D A3 INC DPTR ; pt to rel address 016E 02 0174 JMP TSJMP05 ; do the jump TSJMP ; short jump 0171 3151 CALL MVPCDP ; get user's PC to DPTR 0173 A3 INC DPTR ; pt to rel address TSJMP05 ; entry point for JB, JNB and JBC 0174 E0 MOVX A,@DPTR ; get it 0175 A3 INC DPTR ; pt to next instruction 0176 20 E7 0C JB ACC.7,TSJMP10 ; jump if negative 0179 25 82 ADD A,DPL ; add in the offset 017B F5 82 MOV DPL,A ; move new value low to A 017D E4 CLR A ; clear A 017E 35 83 ADDC A,DPH ; add carry to high part 0180 F5 83 MOV DPH,A ; move new value high to A 0182 02 018F JMP TSJMP20 ; skip negative stuff 0185 25 82 TSJMP10 ADD A,DPL ; add in the offset 0187 F5 82 MOV DPL,A ; move new value low to A 0189 74 FF MOV A,#0FFH ; really is twos compliment 018B 35 83 ADDC A,DPH ; add borrow to high part 018D F5 83 MOV DPH,A ; move new value high to A Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 11 SNGLSTEP.ASM: Single Step Code 018F 80 C7 TSJMP20 JMP SETGO ; set to go TAJMP ; absolute jump TACALL ; absolute call 0191 3151 CALL MVPCDP ; get user's PC to DPTR 0193 E0 MOVX A,@DPTR ; get actual opcode 0194 C4 SWAP A ; move to lower nibble 0195 03 RR A ; rotate right one position 0196 54 07 ANL A,#007H ; ensure only address bits are retained 0198 FD MOV R5,A ; save in R5 0199 A3 INC DPTR ; pt to low address 019A E0 MOVX A,@DPTR ; get it 019B F5 82 MOV DPL,A ; move new load address to DPL 019D E5 83 MOV A,DPH ; get high address of PC 019F 54 F8 ANL A,#0F8H ; save only page portion 01A1 4D ORL A,R5 ; or in A8-A10 01A2 F5 83 MOV DPH,A ; move to DPH 01A4 80 B2 JMP SETGO ; set to go TLJMP ; long jump TLCALL ; long call 01A6 3151 CALL MVPCDP ; get user's PC to DPTR 01A8 A3 INC DPTR ; pt to high address 01A9 12 1626 CALL DPATDP ; get value that's there 01AC 80 AA JMP SETGO ; set to go TN1 ; advance the PC by Tx 01AE 3151 CALL MVPCDP ; get user's PC to DPTR 01B0 90 EF1F MOV DPTR,#UPCH ; pt to user PC high 01B3 12 1626 CALL DPATDP ; pt to address 01B6 A3 INC DPTR ; pt to next location 01B7 80 9F JMP SETGO ; do it 01B9 3151 TN2 CALL MVPCDP ; get user's PC to DPTR 01BB A3 INC DPTR ; pt to next location 01BC A3 INC DPTR ; pt to next location 01BD 80 99 JMP SETGO ; do it 01BF 3151 TN3 CALL MVPCDP ; get user's PC to DPTR 01C1 A3 INC DPTR ; pt to next location 01C2 A3 INC DPTR ; pt to next location 01C3 A3 INC DPTR ; pt to next location 01C4 80 92 JMP SETGO ; do it TJZ ; jump if ACC zero 01C6 90 EF11 MOV DPTR,#UACC ; pt to user accumulator 01C9 E0 MOVX A,@DPTR ; get user accumulator 01CA 60 A5 JZ TSJMP ; if zero, then it's a short jump 01CC 80 EB JMP TN2 ; else, just want to fall through TJNZ ; jump if ACC NOT zero 01CE 90 EF11 MOV DPTR,#UACC ; pt to user accumulator 01D1 E0 MOVX A,@DPTR ; get user accumulator 01D2 70 9D JNZ TSJMP ; if not zero, then it's a short jump 01D4 80 E3 JMP TN2 ; else, just want to fall through Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 12 SNGLSTEP.ASM: Single Step Code TJC ; jump if CY set 01D6 90 EF12 MOV DPTR,#UPSW ; pt to user PSW 01D9 E0 MOVX A,@DPTR ; get user PSW 01DA 33 RLC A ; rotate msb (cy) into CY 01DB 40 94 JC TSJMP ; if set, then it's a short jump 01DD 80 DA JMP TN2 ; else, just want to fall through TJNC ; jump if CY NOT set 01DF 90 EF12 MOV DPTR,#UPSW ; pt to user PSW 01E2 E0 MOVX A,@DPTR ; get user PSW 01E3 33 RLC A ; rotate msb (cy) into CY 01E4 50 8B JNC TSJMP ; if set, then it's a short jump 01E6 80 D1 JMP TN2 ; else, just want to fall through TJB ; jump if bit set TJBC ; jump if bit and clear bit 01E8 3151 CALL MVPCDP ; get user's PC to DPTR 01EA A3 INC DPTR ; pt to bit address 01EB E0 MOVX A,@DPTR ; get the bit address 01EC 12 01FE CALL BTST ; put the bit into CY 01EF 50 CE JNC TN3 ; if no bit, just bump PC by three 01F1 216A JMP TSJMP03 ; if set, then it's a short jump (3 byte) TJNB ; jump if bit NOT set 01F3 3151 CALL MVPCDP ; get user's PC to DPTR 01F5 A3 INC DPTR ; pt to bit address 01F6 E0 MOVX A,@DPTR ; get the bit address 01F7 12 01FE CALL BTST ; put the bit into CY 01FA 40 C3 JC TN3 ; if bit, just bump PC by three 01FC 216A JMP TSJMP03 ; if set, then it's a short jump (3 byte) BTST ; bit test, set CY to reflect the bit value in A 01FE FF MOV R7,A ; save address in R7 01FF 54 07 ANL A,#007H ; look only at bit address 0201 04 INC A ; add one to it 0202 FB MOV R3,A ; save in R3 0203 EF MOV A,R7 ; restore address 0204 54 F8 ANL A,#0F8H ; look only at high bits 0206 20 E7 08 JB ACC.7,BTST50 ; jump if in upper half, A is address 0209 7A 03 MOV R2,#3 ; want to shift 3 bits (divide by 8) 020B C3 BTST10 CLR C ; ensure CY is clear 020C 13 RRC A ; rotate right 020D DA FC DJNZ R2,BTST10 ; do until byte address is right justified 020F 24 20 ADD A,#20H ; add starting address 0211 F8 BTST50 MOV R0,A ; put address index into R0 0212 B8 D0 07 CJNE R0,#0D0H,BTST52 ; see if PSW is wanted 0215 90 EF12 MOV DPTR,#UPSW ; pt to user PSW 0218 E0 MOVX A,@DPTR ; get user PSW 0219 02 0233 JMP BTST70 ; continue 021C B8 E0 07 BTST52 CJNE R0,#0E0H,BTST54 ; see if ACC is wanted 021F 90 EF11 MOV DPTR,#UACC ; pt to user ACC 0222 E0 MOVX A,@DPTR ; get user ACC Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 13 SNGLSTEP.ASM: Single Step Code 0223 02 0233 JMP BTST70 ; continue 0226 B8 F0 07 BTST54 CJNE R0,#0F0H,BTST60 ; see if B is wanted 0229 90 EF1D MOV DPTR,#UB ; pt to user B 022C E0 MOVX A,@DPTR ; get user B 022D 02 0233 JMP BTST70 ; continue 0230 12 13B0 BTST60 CALL GSFR ; get SFR data (or 0-7F ram) 0233 13 BTST70 RRC A ; rotate lsb into CY 0234 DB FD DJNZ R3,BTST70 ; do until correct bit is in CY 0236 22 RET TDDJNZ ; data DJNZ 0237 3151 CALL MVPCDP ; get user's PC to DPTR 0239 A3 INC DPTR ; pt to direct address 023A E0 MOVX A,@DPTR ; get it 023B F8 MOV R0,A ; have R0 pt to it 023C E6 MOV A,@R0 ; get the contents 023D 64 01 XRL A,#001H ; see if it's a one (soon to be zero) 023F 60 02 JZ TDDJN10 ; if it's one then will fall through 0241 216A JMP TSJMP03 ; if not then do short jump (3 byte) 0243 21BF TDDJN10 JMP TN3 TRDJNZ ; register DJNZ 0245 3151 CALL MVPCDP ; get user's PC to DPTR 0247 E0 MOVX A,@DPTR ; get the opcode 0248 54 07 ANL A,#007H ; look only at register address 024A 04 INC A ; add one 024B FA MOV R2,A ; save value in R2 024C A3 INC DPTR ; pt to rel address 024D E0 MOVX A,@DPTR ; get it 024E FB MOV R3,A ; save relative address in R3 024F 90 EF12 MOV DPTR,#UPSW ; pt to UPSW 0252 E0 MOVX A,@DPTR ; get data 0253 54 18 ANL A,#018H ; look only at RS bits 0255 64 00 XRL A,#DEFRB ; see if same 0257 70 0A JNZ TRDJN20 ; skip over if not 0259 90 EF12 MOV DPTR,#UR0-1 ; pt to one less than UR0 025C A3 TRDJN10 INC DPTR ; pt to next register 025D DA FD DJNZ R2,TRDJN10 ; loop till pointing to correct register 025F E0 MOVX A,@DPTR ; get register contents 0260 02 026B JMP TRDJN40 ; continue with checking 0263 64 00 TRDJN20 XRL A,#DEFRB ; restore register address 0265 14 DEC A ; subtract one from address 0266 F8 MOV R0,A ; pt address to R0 0267 08 TRDJN30 INC R0 ; increment address 0268 DA FD DJNZ R2,TRDJN30 ; loop till pointing to correct register 026A E6 MOV A,@R0 ; get register contents 026B 64 01 TRDJN40 XRL A,#001H ; see if it's a one (soon to be zero) 026D 70 02 JNZ TRDJN50 ; jump if not same 026F 21B9 JMP TN2 ; if it's one then will fall through 0271 2171 TRDJN50 JMP TSJMP ; else, do short jump TJADP ; jump @A+DPTR 0273 90 EF11 MOV DPTR,#UACC ; pt to user ACC Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 14 SNGLSTEP.ASM: Single Step Code 0276 E0 MOVX A,@DPTR ; get it 0277 FF MOV R7,A ; save in R7 0278 90 EF1B MOV DPTR,#UDPH ; pt to user DPTR 027B 12 1626 CALL DPATDP ; get contents 027E E5 82 MOV A,DPL ; get data low 0280 2F ADD A,R7 ; add in user accumulator 0281 F5 82 MOV DPL,A ; save in DPL 0283 E4 CLR A ; clear A 0284 35 83 ADDC A,DPH ; add in high byte 0286 F5 83 MOV DPH,A ; save in high 0288 2158 JMP SETGO ; jump will be to location in DPTR TCJNE ; compare and jump if not equal 028A 3151 CALL MVPCDP ; get user's PC to DPTR 028C E0 MOVX A,@DPTR ; get opcode 028D B4 B4 03 CJNE A,#0B4H,TCJNE10 ; jump if not immediate data 0290 02 02A9 JMP TCJIM ; do imediate compare 0293 B4 B5 03 TCJNE10 CJNE A,#0B5H,TCJNE20 ; jump if not direct data 0296 02 02B9 JMP TCJDR ; do direct compare 0299 B4 B6 03 TCJNE20 CJNE A,#0B6H,TCJNE30 ; jump if not direct data 029C 02 02CB JMP TCJAR0 ; do compare with @R0 029F B4 B7 03 TCJNE30 CJNE A,#0B7H,TCJNE40 ; jump if not direct data 02A2 02 02EB JMP TCJAR1 ; do compare with @R1 02A5 02 030C TCJNE40 JMP TCJARN ; do compare with Rn 02A8 22 RET TCJIM ; do imediate compare 02A9 90 EF11 MOV DPTR,#UACC ; pt to user ACC 02AC E0 MOVX A,@DPTR ; get it 02AD FB MOV R3,A ; save in R3 02AE 3151 CALL MVPCDP ; mov the user's PC to the data pointer 02B0 A3 INC DPTR ; pt to immediate data 02B1 E0 MOVX A,@DPTR ; get it 02B2 6B XRL A,R3 ; see if same 02B3 60 02 JZ TCJIM10 ; jump if same 02B5 216A JMP TSJMP03 ; if not do short jump (3 byte) 02B7 21BF TCJIM10 JMP TN3 ; if same then will fall through TCJDR ; do direct compare 02B9 90 EF11 MOV DPTR,#UACC ; pt to user ACC 02BC E0 MOVX A,@DPTR ; get user ACC 02BD FB MOV R3,A ; save in R3 02BE 3151 CALL MVPCDP ; mov the user's PC to the data pointer 02C0 A3 INC DPTR ; pt to direct address 02C1 E0 MOVX A,@DPTR ; get it 02C2 F8 MOV R0,A ; move to R0 02C3 E6 MOV A,@R0 ; get the direct data 02C4 6B XRL A,R3 ; see if same 02C5 60 02 JZ TCJDR10 ; jump if same 02C7 216A JMP TSJMP03 ; if not do short jump (3 byte) 02C9 21BF TCJDR10 JMP TN3 ; if same then will fall through TCJAR0 ; do compare with @R0 Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 15 SNGLSTEP.ASM: Single Step Code 02CB 3151 CALL MVPCDP ; mov the user's PC to the data pointer 02CD A3 INC DPTR ; pt to immediate data 02CE E0 MOVX A,@DPTR ; get it 02CF FB MOV R3,A ; save in R3 02D0 90 EF12 MOV DPTR,#UPSW ; pt to UPSW 02D3 E0 MOVX A,@DPTR ; get data 02D4 54 18 ANL A,#018H ; look only at RS bits 02D6 B4 00 07 CJNE A,#DEFRB,TCJR01 ; see if same 02D9 90 EF13 MOV DPTR,#UR0 ; pt to user R0 02DC E0 MOVX A,@DPTR ; get index to A 02DD 02 02E2 JMP TCJR02 ; skip over first indirection 02E0 F8 TCJR01 MOV R0,A ; address of user's R0 to R0 02E1 E6 MOV A,@R0 ; get user's R0 to A 02E2 F8 TCJR02 MOV R0,A ; move it to R0 02E3 E6 MOV A,@R0 ; get indirect value 02E4 6B XRL A,R3 ; see if same as in R3 02E5 60 02 JZ TCJR03 ; jump if same 02E7 216A JMP TSJMP03 ; if not do short jump (3 byte) 02E9 21BF TCJR03 JMP TN3 ; if same then will fall through TCJAR1 ; do compare with @R1 02EB 3151 CALL MVPCDP ; mov the user's PC to the data pointer 02ED A3 INC DPTR ; pt to immediate data 02EE E0 MOVX A,@DPTR ; get it 02EF FB MOV R3,A ; save in R3 02F0 90 EF12 MOV DPTR,#UPSW ; pt to UPSW 02F3 E0 MOVX A,@DPTR ; get data 02F4 54 18 ANL A,#018H ; look only at RS bits 02F6 B4 00 07 CJNE A,#DEFRB,TCJR10 ; see if same 02F9 90 EF14 MOV DPTR,#UR1 ; pt to user R0 02FC E0 MOVX A,@DPTR ; get index to A 02FD 02 0303 JMP TCJR11 ; skip adj, needed only for real regs 0300 04 TCJR10 INC A ; pt to R1 not R0 0301 F8 MOV R0,A ; address of user's R1 to R0 0302 E6 MOV A,@R0 ; get user's R1 to A 0303 F8 TCJR11 MOV R0,A ; move it to R0 0304 E6 MOV A,@R0 ; get indirect value 0305 6B XRL A,R3 ; see if same as in R3 0306 60 02 JZ TCJR12 ; jump if same 0308 216A JMP TSJMP03 ; if not do short jump (3 byte) 030A 21BF TCJR12 JMP TN3 ; if same then will fall through TCJARN ; do compare with Rn 030C 3151 CALL MVPCDP ; mov the user's PC to the data pointer 030E E0 MOVX A,@DPTR ; get the opcode 030F 54 07 ANL A,#007H ; look only at register address 0311 04 INC A ; add one 0312 FA MOV R2,A ; save in R2 0313 A3 INC DPTR ; pt to immediate data 0314 E0 MOVX A,@DPTR ; get the data 0315 FB MOV R3,A ; save in R3 0316 90 EF12 MOV DPTR,#UPSW ; pt to UPSW 0319 E0 MOVX A,@DPTR ; get data Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 16 SNGLSTEP.ASM: Single Step Code 031A 54 18 ANL A,#018H ; look only at RS bits 031C B4 00 0A CJNE A,#DEFRB,TCJRN5 ; see if same 031F 90 EF12 MOV DPTR,#UR0-1 ; pt to one less then user's register 0322 A3 TCJRN1 INC DPTR ; pt to next register 0323 DA FD DJNZ R2,TCJRN1 ; loop till data correct 0325 E0 MOVX A,@DPTR ; get data 0326 02 032F JMP TCJRN7 ; continue 0329 F8 TCJRN5 MOV R0,A ; get the index 032A 18 DEC R0 ; subtract one 032B 08 TCJRN6 INC R0 ; pt to next value 032C DA FD DJNZ R2,TCJRN6 ; loop till data correct 032E E6 MOV A,@R0 ; get data 032F 6B TCJRN7 XRL A,R3 ; see if same as in R3 0330 70 02 JNZ TCJRN8 ; jump if different 0332 21BF JMP TN3 ; if same then will fall through 0334 216A TCJRN8 JMP TSJMP03 ; else, do short jump (3 byte) TRET ; do RETURN TRETI ; do RETURN from INTERRUPT 0336 90 EF1E MOV DPTR,#USP ; pt to user's SP 0339 E0 MOVX A,@DPTR ; get it 033A F8 MOV R0,A ; put to A 033B E6 MOV A,@R0 ; get high byte 033C F5 83 MOV DPH,A ; put to DPTR high 033E 18 DEC R0 ; pt to low byte 033F E6 MOV A,@R0 ; get low byte 0340 F5 82 MOV DPL,A ; put to DPTR low 0342 2158 JMP SETGO ; will jump to address in DPTR ; table of opcode handlers 0344 01AE 0191 OCTBAS DW TN1,TAJMP,TLJMP,TN1,TN1,TN2,TN1,TN1 ; 00 0348 01A6 01AE 034C 01AE 01B9 0350 01AE 01AE 0354 01AE 01AE DW TN1,TN1,TN1,TN1,TN1,TN1,TN1,TN1 0358 01AE 01AE 035C 01AE 01AE 0360 01AE 01AE 0364 01E8 0191 DW TJBC,TACALL,TLCALL,TN1,TN1,TN2,TN1,TN1 ; 10 0368 01A6 01AE 036C 01AE 01B9 0370 01AE 01AE 0374 01AE 01AE DW TN1,TN1,TN1,TN1,TN1,TN1,TN1,TN1 0378 01AE 01AE 037C 01AE 01AE 0380 01AE 01AE 0384 01E8 0191 DW TJB,TAJMP,TRET,TN1,TN2,TN2,TN1,TN1 ; 20 0388 0336 01AE 038C 01B9 01B9 0390 01AE 01AE 0394 01AE 01AE DW TN1,TN1,TN1,TN1,TN1,TN1,TN1,TN1 0398 01AE 01AE 039C 01AE 01AE Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 17 SNGLSTEP.ASM: Single Step Code 03A0 01AE 01AE 03A4 01F3 0191 DW TJNB,TACALL,TRETI,TN1,TN2,TN2,TN1,TN1 ; 30 03A8 0336 01AE 03AC 01B9 01B9 03B0 01AE 01AE 03B4 01AE 01AE DW TN1,TN1,TN1,TN1,TN1,TN1,TN1,TN1 03B8 01AE 01AE 03BC 01AE 01AE 03C0 01AE 01AE 03C4 01D6 0191 DW TJC,TAJMP,TN2,TN3,TN2,TN2,TN1,TN1 ; 40 03C8 01B9 01BF 03CC 01B9 01B9 03D0 01AE 01AE 03D4 01AE 01AE DW TN1,TN1,TN1,TN1,TN1,TN1,TN1,TN1 03D8 01AE 01AE 03DC 01AE 01AE 03E0 01AE 01AE 03E4 01DF 0191 DW TJNC,TACALL,TN2,TN3,TN2,TN2,TN1,TN1 ; 50 03E8 01B9 01BF 03EC 01B9 01B9 03F0 01AE 01AE 03F4 01AE 01AE DW TN1,TN1,TN1,TN1,TN1,TN1,TN1,TN1 03F8 01AE 01AE 03FC 01AE 01AE 0400 01AE 01AE 0404 01C6 0191 DW TJZ,TAJMP,TN2,TN3,TN2,TN2,TN1,TN1 ; 60 0408 01B9 01BF 040C 01B9 01B9 0410 01AE 01AE 0414 01AE 01AE DW TN1,TN1,TN1,TN1,TN1,TN1,TN1,TN1 0418 01AE 01AE 041C 01AE 01AE 0420 01AE 01AE 0424 01CE 0191 DW TJNZ,TACALL,TN2,TJADP,TN2,TN3,TN2,TN2 ; 70 0428 01B9 0273 042C 01B9 01BF 0430 01B9 01B9 0434 01B9 01B9 DW TN2,TN2,TN2,TN2,TN2,TN2,TN2,TN2 0438 01B9 01B9 043C 01B9 01B9 0440 01B9 01B9 0444 0171 0191 OCTBA10 DW TSJMP,TAJMP,TN2,TN1,TN1,TN3,TN2,TN2 ; 80 0448 01B9 01AE 044C 01AE 01BF 0450 01B9 01B9 0454 01B9 01B9 DW TN2,TN2,TN2,TN2,TN2,TN2,TN2,TN2 0458 01B9 01B9 045C 01B9 01B9 0460 01B9 01B9 0464 01BF 0191 DW TN3,TACALL,TN2,TN1,TN2,TN2,TN1,TN1 ; 90 0468 01B9 01AE 046C 01B9 01B9 0470 01AE 01AE Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 18 SNGLSTEP.ASM: Single Step Code 0474 01AE 01AE DW TN1,TN1,TN1,TN1,TN1,TN1,TN1,TN1 0478 01AE 01AE 047C 01AE 01AE 0480 01AE 01AE 0484 01B9 0191 DW TN2,TAJMP,TN2,TN1,TN1,TN1,TN2,TN2 ; A0 0488 01B9 01AE 048C 01AE 01AE 0490 01B9 01B9 0494 01B9 01B9 DW TN2,TN2,TN2,TN2,TN2,TN2,TN2,TN2 0498 01B9 01B9 049C 01B9 01B9 04A0 01B9 01B9 04A4 01B9 0191 DW TN2,TACALL,TN2,TN1,TCJNE,TCJNE,TCJNE,TCJNE ; B0 04A8 01B9 01AE 04AC 028A 028A 04B0 028A 028A 04B4 028A 028A DW TCJNE,TCJNE,TCJNE,TCJNE,TCJNE,TCJNE,TCJNE,TCJNE 04B8 028A 028A 04BC 028A 028A 04C0 028A 028A 04C4 01B9 0191 DW TN2,TAJMP,TN2,TN1,TN1,TN2,TN1,TN1 ; C0 04C8 01B9 01AE 04CC 01AE 01B9 04D0 01AE 01AE 04D4 01AE 01AE DW TN1,TN1,TN1,TN1,TN1,TN1,TN1,TN1 04D8 01AE 01AE 04DC 01AE 01AE 04E0 01AE 01AE 04E4 01B9 0191 DW TN2,TACALL,TN2,TN1,TN1,TDDJNZ,TN1,TN1 ; D0 04E8 01B9 01AE 04EC 01AE 0237 04F0 01AE 01AE 04F4 0245 0245 DW TRDJNZ,TRDJNZ,TRDJNZ,TRDJNZ,TRDJNZ,TRDJNZ,TRDJNZ,TRDJNZ 04F8 0245 0245 04FC 0245 0245 0500 0245 0245 0504 01AE 0191 DW TN1,TAJMP,TN1,TN1,TN1,TN2,TN1,TN1 ; E0 0508 01AE 01AE 050C 01AE 01B9 0510 01AE 01AE 0514 01AE 01AE DW TN1,TN1,TN1,TN1,TN1,TN1,TN1,TN1 0518 01AE 01AE 051C 01AE 01AE 0520 01AE 01AE 0524 01AE 0191 DW TN1,TACALL,TN1,TN1,TN1,TN2,TN1,TN1 ; F0 0528 01AE 01AE 052C 01AE 01B9 0530 01AE 01AE 0534 01AE 01AE DW TN1,TN1,TN1,TN1,TN1,TN1,TN1,TN1 0538 01AE 01AE 053C 01AE 01AE 0540 01AE 01AE Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 19 SNGLSTEP.ASM: Single Step Code NEXT ; do next instruction and display registers ; usage: n 0544 3151 CALL MVPCDP ; get user's PC to DPTR 0546 E0 MOVX A,@DPTR ; get the opcode 0547 20 E7 07 JB ACC.7,NEXT10 ; jump if more than 127 054A 23 RL A ; multiply by two 054B 90 0344 MOV DPTR,#OCTBAS ; pt to start of table 054E 02 0557 JMP NEXT20 ; do common part 0551 C2 E7 NEXT10 CLR ACC.7 ; mask off msb 0553 23 RL A ; multiply by two 0554 90 0444 MOV DPTR,#OCTBA10 ; pt to last half of table 0557 C0 E0 NEXT20 PUSH ACC ; save index on stack 0559 93 MOVC A,@A+DPTR ; get high value 055A A3 INC DPTR ; pt 055B F5 F0 MOV B,A ; save at B 055D D0 E0 POP ACC ; recover index 055F 93 MOVC A,@A+DPTR ; get low value 0560 C0 E0 PUSH ACC ; save low on stack 0562 C0 F0 PUSH B ; save high on stack 0564 C2 D7 CLR CY ; no prompt 0566 22 RET ; go do that routine ZNEXT ; do next instruction and display registers, but don't ; break within a CALL ; usage: z 0567 3151 CALL MVPCDP ; get user's PC to DPTR 0569 E0 MOVX A,@DPTR ; get the opcode 056A B4 12 02 CJNE A,#12H,ZNEXT10 ; jump if not long call 056D 21BF JMP TN3 ; it's LCALL but don't break within it 056F 54 1F ZNEXT10 ANL A,#01FH ; look at bits 0-4 0571 B4 11 02 CJNE A,#011H,ZNEXT20 ; jump if not a ACALL instruction 0574 21B9 JMP TN2 ; it's ACALL but don't break within it 0576 80 CC ZNEXT20 JMP NEXT ; not a call, just to the instruction $RESETLN $SETLN(FUNC1.ASM); %INCLUDE FUNC1.ASM ; functions part 1 $SUBTITLE(FUNC1.ASM: Main Function Code, part 1) Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 20 FUNC1.ASM: Main Function Code, part 1 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; Functions for monitor ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; BLAST ; blast input (from) or output (to) 0578 12 1452 CALL GETUCHE ; get an input char with echo 057B B4 46 09 CJNE A,#'F',BLAST10 ; jump if not blast FROM 057E 12 0596 CALL BLAF ; blast from 0581 12 1437 CALL CRLF ; end with newline 0584 D2 D7 SETB CY ; want prompt 0586 22 RET ; that's all 0587 B4 54 09 BLAST10 CJNE A,#'T',BLAST20 ; jump if not blast TO 058A 12 05F4 CALL BLAT ; blast to 058D 12 1437 CALL CRLF ; end with newline 0590 D2 D7 SETB CY ; want prompt 0592 22 RET ; that's all 0593 02 1400 BLAST20 JMP SYSERR ; no such command BLAF ; blastfrom addr 0596 12 161C CALL SPACE1 ; space over one position 0599 12 1525 CALL CARG ; collect arguments 059C 12 1437 CALL CRLF ; new line 059F 90 EF00 MOV DPTR,#ARGC ; pt to ARGC 05A2 E0 MOVX A,@DPTR ; get ARGC to A 05A3 64 01 XRL A,#1 ; see if ARGC == 1 05A5 60 03 JZ BLAF10 ; jump if so 05A7 02 1400 JMP SYSERR ; jump to err if both args not present 05AA 90 EF01 BLAF10 MOV DPTR,#ARGV0 ; pt to ARGV0 high 05AD 12 1626 CALL DPATDP ; get value to DPTR 05B0 E5 83 MOV A,DPH ; get high value to A 05B2 70 23 JNZ BLAF20 ; jump to external access if >= 0100H 05B4 74 69 MOV A,#'i' ; get ascii I 05B6 12 13F2 CALL PUTCHAR ; move to terminal 05B9 E5 82 MOV A,DPL ; get low byte 05BB 12 15D7 CALL PHXBYTE ; print as byte 05BE 74 3A MOV A,#':' ; get ascii ":" 05C0 12 13F2 CALL PUTCHAR ; move to terminal 05C3 12 161C CALL SPACE1 ; print a space char 05C6 A8 82 MOV R0,DPL ; get DPL value 05C8 12 13B0 CALL GSFR ; get data (SFR if addressed 080H to 0FFH) 05CB 12 15D7 CALL PHXBYTE ; print it 05CE 12 1444 CALL CR ; overwrite 05D1 12 147E CALL KBESC ; ESC from KB? 05D4 50 D4 JNC BLAF10 ; loop if not found 05D6 22 RET 05D7 74 78 BLAF20 MOV A,#'x' ; mark as external data memory 05D9 12 13F2 CALL PUTCHAR ; output it 05DC 12 15CC CALL PDPTR ; print the DPTR 05DF 74 3A MOV A,#':' ; get colon 05E1 12 13F2 CALL PUTCHAR ; output it 05E4 12 161C CALL SPACE1 ; print space char 05E7 E0 MOVX A,@DPTR ; get value to A Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 21 FUNC1.ASM: Main Function Code, part 1 05E8 12 15D7 CALL PHXBYTE ; print the byte 05EB 12 1444 CALL CR ; overwrite 05EE 12 147E CALL KBESC ; ESC from KB? 05F1 50 E4 JNC BLAF20 ; loop if not found 05F3 22 RET BLAT ; blast-to addr data 05F4 12 161C CALL SPACE1 ; space over one position 05F7 12 1525 CALL CARG ; collect arguments 05FA 12 1437 CALL CRLF ; new line 05FD 90 EF00 MOV DPTR,#ARGC ; pt to ARGC 0600 E0 MOVX A,@DPTR ; get ARGC to A 0601 64 02 XRL A,#2 ; see if ARGC == 2 0603 60 03 JZ BLAT10 ; jump if so 0605 02 1400 JMP SYSERR ; jump to err if both args not present 0608 90 EF01 BLAT10 MOV DPTR,#ARGV0 ; pt to ARGV0 high 060B 12 1626 CALL DPATDP ; get value to DPTR 060E E5 83 MOV A,DPH ; get high value to A 0610 70 27 JNZ BLAT20 ; jump to external access if >= 0100H 0612 74 69 MOV A,#'i' ; get ascii I 0614 12 13F2 CALL PUTCHAR ; move to terminal 0617 E5 82 MOV A,DPL ; get low byte 0619 12 15D7 CALL PHXBYTE ; print as byte 061C 74 3A MOV A,#':' ; get ascii ":" 061E 12 13F2 CALL PUTCHAR ; move to terminal 0621 12 161C CALL SPACE1 ; print a space char 0624 A8 82 MOV R0,DPL ; get DPL value 0626 90 EF04 MOV DPTR,#ARGV1+1 ; pt to ARGV1 low 0629 E0 MOVX A,@DPTR ; get data 062A 12 139C CALL PSFR ; put data (SFR if addressed 080H to 0FFH) 062D 12 15D7 CALL PHXBYTE ; print it 0630 12 1444 CALL CR ; overwrite 0633 12 147E CALL KBESC ; ESC from KB? 0636 50 D0 JNC BLAT10 ; loop if not found 0638 22 RET 0639 74 78 BLAT20 MOV A,#'x' ; mark as external data memory 063B 12 13F2 CALL PUTCHAR ; output it 063E 12 15CC CALL PDPTR ; print the DPTR 0641 74 3A MOV A,#':' ; get colon 0643 12 13F2 CALL PUTCHAR ; output it 0646 12 161C CALL SPACE1 ; print space char 0649 90 EF04 MOV DPTR,#ARGV1+1 ; pt to ARGV1 low 064C E0 MOVX A,@DPTR ; get value to A 064D 90 EF01 MOV DPTR,#ARGV0 ; pt to ARGV0 0650 12 1626 CALL DPATDP ; get value pointed to 0653 F0 MOVX @DPTR,A ; move to memory 0654 12 15D7 CALL PHXBYTE ; print the byte 0657 12 1444 CALL CR ; overwrite 065A 12 147E CALL KBESC ; ESC from KB? 065D 50 DA JNC BLAT20 ; loop if not found 065F 22 RET CHECK ; display several options Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 22 FUNC1.ASM: Main Function Code, part 1 0660 12 1452 CALL GETUCHE ; get an input char with echo 0663 B4 58 09 CJNE A,#'X',CHECK10 ; jump if not external display 0666 12 067E CALL CHKEXT ; display external ram 0669 12 1437 CALL CRLF ; end with newline 066C D2 D7 SETB CY ; want prompt 066E 22 RET ; that's all 066F B4 50 09 CHECK10 CJNE A,#'P',CHECK20 ; jump if not program display 0672 12 06B8 CALL CHKPGM ; display program memory 0675 12 1437 CALL CRLF ; end with newline 0678 D2 D7 SETB CY ; want prompt 067A 22 RET ; that's all 067B 02 1400 CHECK20 JMP SYSERR ; no such command CHKEXT ; calculate check sum over ext data space, usage: cx start stop 067E 12 161C CALL SPACE1 ; space over one position 0681 12 1525 CALL CARG ; collect arguments 0684 12 1437 CALL CRLF ; new line 0687 90 EF00 MOV DPTR,#ARGC ; pt to ARGC 068A E0 MOVX A,@DPTR ; get ARGC to A 068B 64 02 XRL A,#2 ; see if ARGC == 2 068D 60 03 JZ CHKEX10 ; jump if so 068F 02 1400 JMP SYSERR ; jump to err if both args not present 0692 A3 CHKEX10 INC DPTR ; pt to ARGV0 0693 12 1626 CALL DPATDP ; make DPTR = @DPTR 0696 7C 00 MOV R4,#0 ; cksum low 0698 7D 00 MOV R5,#0 ; cksum high 069A E0 CHKEX20 MOVX A,@DPTR ; get a byte from data space 069B 2C ADD A,R4 ; add to check sum 069C FC MOV R4,A ; save in R4 069D 50 01 JNC CHKEX30 ; jump if no carry 069F 0D INC R5 ; if carry then inc ms byte 06A0 A3 CHKEX30 INC DPTR ; increment the DPTR 06A1 12 0F92 CALL DPGV1 ; set CY if DPTR > ARGV1 06A4 50 F4 JNC CHKEX20 ; loop if no CY 06A6 90 16E3 MOV DPTR,#CKSMSG ; else, done so get pt to checksum msg 06A9 12 1491 CALL CPUTS ; put it 06AC ED MOV A,R5 ; get checksum high 06AD 12 15D7 CALL PHXBYTE ; print as hex value 06B0 EC MOV A,R4 ; get checksum low 06B1 12 15D7 CALL PHXBYTE ; print as hex value 06B4 12 1437 CALL CRLF ; end the line 06B7 22 RET CHKPGM ; calculate check sum over program memory, usage: cp start stop 06B8 12 161C CALL SPACE1 ; space over one position 06BB 12 1525 CALL CARG ; collect arguments 06BE 12 1437 CALL CRLF ; new line 06C1 90 EF00 MOV DPTR,#ARGC ; pt to ARGC 06C4 E0 MOVX A,@DPTR ; get ARGC to A 06C5 64 02 XRL A,#2 ; see if ARGC == 2 06C7 60 03 JZ CHKPG10 ; jump if so 06C9 02 1400 JMP SYSERR ; jump to err if both args not present 06CC A3 CHKPG10 INC DPTR ; pt to ARGV0 Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 23 FUNC1.ASM: Main Function Code, part 1 06CD 12 1626 CALL DPATDP ; make DPTR = @DPTR 06D0 7C 00 MOV R4,#0 ; cksum low 06D2 7D 00 MOV R5,#0 ; cksum high 06D4 E4 CHKPG20 CLR A ; clear A 06D5 93 MOVC A,@A+DPTR ; get a byte from program memory 06D6 2C ADD A,R4 ; add to check sum 06D7 FC MOV R4,A ; save in R4 06D8 50 01 JNC CHKPG30 ; jump if no carry 06DA 0D INC R5 ; if carry then inc ms byte 06DB A3 CHKPG30 INC DPTR ; increment the DPTR 06DC 12 0F92 CALL DPGV1 ; set CY if DPTR > ARGV1 06DF 50 F3 JNC CHKPG20 ; loop if no CY 06E1 90 16E3 MOV DPTR,#CKSMSG ; else, done so get pt to checksum msg 06E4 12 1491 CALL CPUTS ; put it 06E7 ED MOV A,R5 ; get checksum high 06E8 12 15D7 CALL PHXBYTE ; print as hex value 06EB EC MOV A,R4 ; get checksum low 06EC 12 15D7 CALL PHXBYTE ; print as hex value 06EF 12 1437 CALL CRLF ; end the line 06F2 22 RET DISPX ; display several options 06F3 12 1452 CALL GETUCHE ; get an input char with echo 06F6 B4 49 09 CJNE A,#'I',DISPX10 ; jump if not internal display 06F9 12 0729 CALL DISINT ; display internal registers 06FC 12 1437 CALL CRLF ; end with newline 06FF D2 D7 SETB CY ; want prompt 0701 22 RET ; that's all 0702 B4 58 09 DISPX10 CJNE A,#'X',DISPX20 ; jump if not external display 0705 12 077D CALL DISEXT ; display external ram 0708 12 1437 CALL CRLF ; end with newline 070B D2 D7 SETB CY ; want prompt 070D 22 RET ; that's all 070E B4 50 09 DISPX20 CJNE A,#'P',DISPX30 ; jump if not program display 0711 12 07C1 CALL DISPGM ; display program memory 0714 12 1437 CALL CRLF ; end with newline 0717 D2 D7 SETB CY ; want prompt 0719 22 RET ; that's all 071A B4 46 09 DISPX30 CJNE A,#'F',DISPX40 ; jump if not SFR display 071D 12 0805 CALL DISSFR ; display special func register space 0720 12 1437 CALL CRLF ; end with newline 0723 22 RET ; that's all 0724 D2 D7 SETB CY ; want prompt 0726 02 1400 DISPX40 JMP SYSERR ; no such command DISINT ; display internal ram, usage: di start stop 0729 12 161C CALL SPACE1 ; space over one position 072C 12 1525 CALL CARG ; collect arguments 072F 12 1437 CALL CRLF ; new line 0732 90 EF00 MOV DPTR,#ARGC ; pt to ARGC 0735 E0 MOVX A,@DPTR ; get ARGC to A 0736 64 02 XRL A,#2 ; see if ARGC == 2 0738 60 08 JZ DISIN03 ; jump if so Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 24 FUNC1.ASM: Main Function Code, part 1 073A E0 MOVX A,@DPTR ; get ARGC to A 073B 64 01 XRL A,#1 ; see if ARGC == 1 073D 60 03 JZ DISIN03 ; jump if so 073F 02 1400 JMP SYSERR ; jump to err if needed args not present 0742 E4 DISIN03 CLR A ; clear A 0743 90 EF01 MOV DPTR,#ARGV0 ; pt to ARGV0 high 0746 F0 MOVX @DPTR,A ; zero high byte of ARGV0 0747 A3 INC DPTR ; pt to ARGV0 low 0748 A3 INC DPTR ; pt to ARGV1 high 0749 E0 MOVX A,@DPTR ; get high byte of end point 074A 60 06 JZ DISIN05 ; jump if zero 074C E4 CLR A ; clear A 074D F0 MOVX @DPTR,A ; zero high byte 074E A3 INC DPTR ; pt to low byte 074F 74 FF MOV A,#0FFH ; get max value 0751 F0 MOVX @DPTR,A ; save at low 0752 90 EF00 DISIN05 MOV DPTR,#ARGC ; pt to ARGC 0755 E0 MOVX A,@DPTR ; get ARGC to A 0756 FF MOV R7,A ; save A in R7 0757 A3 INC DPTR ; pt to ARGV0 0758 12 1626 CALL DPATDP ; make DPTR = @DPTR 075B E5 82 MOV A,DPL ; get DPTR low 075D 54 F0 ANL A,#0F0H ; ensure 16 byte boundary 075F F5 82 MOV DPL,A ; restore modified DPTR low 0761 EF MOV A,R7 ; restore A, ARGC 0762 B4 01 04 CJNE A,#1,DISIN10 ; jump if not one argument 0765 12 0E77 CALL PILINE ; print one line of internal data mem 0768 22 RET ; that's all 0769 B4 02 0E DISIN10 CJNE A,#2,DISIN40 ; jump if not two arguments 076C 12 0E77 DISIN20 CALL PILINE ; print one line of internal data mem 076F 12 147E CALL KBESC ; ESC from KB? 0772 40 05 JC DISIN30 ; jump if found 0774 12 0F92 CALL DPGV1 ; set CY if DP greater than ARGV1 0777 50 F3 JNC DISIN20 ; loop until done 0779 22 DISIN30 RET ; that's all 077A 02 1400 DISIN40 JMP SYSERR ; no such command DISEXT ; display external ram, usage: dx start stop 077D 12 161C CALL SPACE1 ; space over one position 0780 12 1525 CALL CARG ; collect arguments 0783 12 1437 CALL CRLF ; new line 0786 90 EF00 MOV DPTR,#ARGC ; pt to ARGC 0789 E0 MOVX A,@DPTR ; get ARGC to A 078A 64 02 XRL A,#2 ; see if ARGC == 2 078C 60 08 JZ DISEX03 ; jump if so 078E E0 MOVX A,@DPTR ; get ARGC to A 078F 64 01 XRL A,#1 ; see if ARGC == 1 0791 60 03 JZ DISEX03 ; jump if so 0793 02 1400 JMP SYSERR ; jump to err if needed args not present 0796 90 EF00 DISEX03 MOV DPTR,#ARGC ; pt to ARGC 0799 E0 MOVX A,@DPTR ; get ARGC to A 079A FF MOV R7,A ; save A in R7 079B A3 INC DPTR ; pt to ARGV0 Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 25 FUNC1.ASM: Main Function Code, part 1 079C 12 1626 CALL DPATDP ; make DPTR = @DPTR 079F E5 82 MOV A,DPL ; get DPTR low 07A1 54 F0 ANL A,#0F0H ; ensure 16 byte boundary 07A3 F5 82 MOV DPL,A ; restore modified DPTR low 07A5 EF MOV A,R7 ; restore A from R7 07A6 B4 01 04 CJNE A,#1,DISEX10 ; jump if not one argument 07A9 12 0EBB CALL PXLINE ; print one line of external data mem 07AC 22 RET ; that's all 07AD B4 02 0E DISEX10 CJNE A,#2,DISEX40 ; jump if not two arguments 07B0 12 0EBB DISEX20 CALL PXLINE ; print one line of external data mem 07B3 12 147E CALL KBESC ; ESC from KB? 07B6 40 05 JC DISEX30 ; jump if found 07B8 12 0F92 CALL DPGV1 ; set CY if DP greater than ARGV1 07BB 50 F3 JNC DISEX20 ; loop until done 07BD 22 DISEX30 RET ; that's all 07BE 02 1400 DISEX40 JMP SYSERR ; no such command DISPGM ; display program memory, usage: dp start stop 07C1 12 161C CALL SPACE1 ; space over one position 07C4 12 1525 CALL CARG ; collect arguments 07C7 12 1437 CALL CRLF ; new line 07CA 90 EF00 MOV DPTR,#ARGC ; pt to ARGC 07CD E0 MOVX A,@DPTR ; get ARGC to A 07CE 64 02 XRL A,#2 ; see if ARGC == 2 07D0 60 0B JZ DISPG03 ; jump if so 07D2 E0 MOVX A,@DPTR ; get ARGC to A 07D3 64 01 XRL A,#1 ; see if ARGC == 1 07D5 60 06 JZ DISPG03 ; jump if so 07D7 02 1400 JMP SYSERR ; jump to err if needed args not present 07DA 90 EF00 MOV DPTR,#ARGC ; pt to ARGC 07DD E0 DISPG03 MOVX A,@DPTR ; get ARGC to A 07DE FF MOV R7,A ; save A in R7 07DF A3 INC DPTR ; pt to ARGV0 07E0 12 1626 CALL DPATDP ; make DPTR = @DPTR 07E3 E5 82 MOV A,DPL ; get DPTR low 07E5 54 F0 ANL A,#0F0H ; ensure 16 byte boundary 07E7 F5 82 MOV DPL,A ; restore modified DPTR low 07E9 EF MOV A,R7 ; restore A 07EA B4 01 04 CJNE A,#1,DISPG10 ; jump if not one argument 07ED 12 0EFF CALL PPLINE ; print one line of program memory 07F0 22 RET ; that's all 07F1 B4 02 0E DISPG10 CJNE A,#2,DISPG40 ; jump if not two arguments 07F4 12 0EFF DISPG20 CALL PPLINE ; print one line of program memory 07F7 12 147E CALL KBESC ; ESC from KB? 07FA 40 05 JC DISPG30 ; jump if found 07FC 12 0F92 CALL DPGV1 ; set CY if DP greater than ARGV1 07FF 50 F3 JNC DISPG20 ; loop until done 0801 22 DISPG30 RET ; that's all 0802 02 1400 DISPG40 JMP SYSERR ; no such command DISSFR ; display SFR locations, usage: ds start stop 0805 12 161C CALL SPACE1 ; space over one position 0808 12 1525 CALL CARG ; collect arguments Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 26 FUNC1.ASM: Main Function Code, part 1 080B 12 1437 CALL CRLF ; new line 080E 90 EF00 MOV DPTR,#ARGC ; pt to ARGC 0811 E0 MOVX A,@DPTR ; get ARGC to A 0812 64 02 XRL A,#2 ; see if ARGC == 2 0814 60 0B JZ DISSF03 ; jump if so 0816 E0 MOVX A,@DPTR ; get ARGC to A 0817 64 01 XRL A,#1 ; see if ARGC == 1 0819 60 06 JZ DISSF03 ; jump if so 081B 02 1400 JMP SYSERR ; jump to err if needed args not present 081E 90 EF00 MOV DPTR,#ARGC ; pt to ARGC 0821 E4 DISSF03 CLR A ; clear A 0822 90 EF01 MOV DPTR,#ARGV0 ; pt to ARGV0 high 0825 F0 MOVX @DPTR,A ; zero high byte of ARGV0 0826 A3 INC DPTR ; pt to ARGV0 low 0827 A3 INC DPTR ; pt to ARGV1 high 0828 E0 MOVX A,@DPTR ; get high byte of end point 0829 60 06 JZ DISSF05 ; jump if zero 082B E4 CLR A ; clear A 082C F0 MOVX @DPTR,A ; zero high byte 082D A3 INC DPTR ; pt to low byte 082E 74 FF MOV A,#0FFH ; get max value 0830 F0 MOVX @DPTR,A ; save at low 0831 90 EF00 DISSF05 MOV DPTR,#ARGC ; pt to ARGC 0834 E0 MOVX A,@DPTR ; get ARGC to A 0835 FF MOV R7,A ; save A in R7 0836 A3 INC DPTR ; pt to ARGV0 0837 12 1626 CALL DPATDP ; make DPTR = @DPTR 083A E5 82 MOV A,DPL ; get DPTR low 083C 54 F0 ANL A,#0F0H ; ensure 16 byte boundary 083E F5 82 MOV DPL,A ; restore modified DPTR low 0840 EF MOV A,R7 ; restore A, ARGC 0841 B4 01 04 CJNE A,#1,DISSF10 ; jump if not one argument 0844 12 0F45 CALL PSLINE ; print one line of SFR data 0847 22 RET ; that's all 0848 B4 02 0E DISSF10 CJNE A,#2,DISSF40 ; jump if not two arguments 084B 12 0F45 DISSF20 CALL PSLINE ; print one line of SFR data 084E 12 147E CALL KBESC ; ESC from KB? 0851 40 05 JC DISSF30 ; jump if found 0853 12 0F92 CALL DPGV1 ; set CY if DP greater than ARGV1 0856 50 F3 JNC DISSF20 ; loop until done 0858 22 DISSF30 RET ; that's all 0859 02 1400 DISSF40 JMP SYSERR ; no such command HELP ; print the help file to the console ; stop every 20 lines and prompt for more 085C 90 1833 MOV DPTR,#HLPMSG ; get the text index 085F 12 0865 CALL CPUTSP ; print mesg to console with prompting 0862 D2 D7 SETB CY ; want prompt 0864 22 RET ; that's all CPUTSP ; output string from code space pointed to by DPTR ; with prompting 0865 7F 00 MOV R7,#0 ; clear R7, line counter Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 27 FUNC1.ASM: Main Function Code, part 1 0867 E4 CPUTP05 CLR A ; clear A 0868 93 MOVC A,@A+DPTR ; get a char 0869 70 01 JNZ CPUTP10 ; jump if not null 086B 22 RET ; else, that's all 086C 12 13F2 CPUTP10 CALL PUTCHAR ; output the char 086F A3 INC DPTR ; increment the data pointer 0870 64 0A XRL A,#ALF ; see if line feed char 0872 70 F3 JNZ CPUTP05 ; loop till done 0874 0F INC R7 ; did a line 0875 EF MOV A,R7 ; get line counter to A 0876 64 14 XRL A,#20 ; see if 20th line 0878 70 ED JNZ CPUTP05 ; loop till done 087A C0 82 PUSH DPL ; save DPL on stack 087C C0 83 PUSH DPH ; save DPH on stack 087E 90 0893 MOV DPTR,#CPUTP50 ; pt to message 0881 12 1491 CALL CPUTS ; put the string 0884 D0 83 POP DPH ; restore DPH 0886 D0 82 POP DPL ; restore DPL 0888 12 13E8 CPUTP20 CALL GETCHAR ; wait for char and then dump it 088B 12 1437 CALL CRLF ; do CRLF 088E 12 1437 CALL CRLF ; do CRLF 0891 80 D4 JMP CPUTP05 ; loop till done 0893 0D 0A CPUTP50 DB ACR,ALF 0895 2D 2D 20 50 DB '-- Press Any Key For Next Page --' 0899 72 65 73 73 089D 20 41 6E 79 08A1 20 4B 65 79 08A5 20 46 6F 72 08A9 20 4E 65 78 08AD 74 20 50 61 08B1 67 65 20 2D 08B5 2D 08B6 00 DB 0 $RESETLN $SETLN(FUNC2.ASM); %INCLUDE FUNC2.ASM ; functions part 2 $SUBTITLE(FUNC2.ASM: Main Function Code, part 2) Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 28 FUNC2.ASM: Main Function Code, part 2 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; Functions for monitor ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; GO ; load user registers and go to user program 08B7 12 15B9 CALL ZARG ; zero the arguments 08BA 12 158B CALL GARGNSP ; get one argument, no spaces allowed 08BD 60 08 JZ GO10 ; jump if no data 08BF 90 EF1F MOV DPTR,#UPCH ; pt to user PC high location 08C2 EB MOV A,R3 ; get high byte 08C3 F0 MOVX @DPTR,A ; save it 08C4 A3 INC DPTR ; pt to user PC low location 08C5 EC MOV A,R4 ; get low byte 08C6 F0 MOVX @DPTR,A ; save it 08C7 40 06 GO10 JC GO30 ; jump if CR was entered (CY=1) 08C9 12 1525 CALL CARG ; collect arguments GO20 ; entry point for single step 08CC 12 0FC3 CALL SBKPT ; set the breakpoints ; now reload default Reg Bank 08CF 90 EF13 GO30 MOV DPTR,#UR0 ; pt to UR0 08D2 E0 MOVX A,@DPTR ; get UR0 data 08D3 A3 INC DPTR ; pt to UR1 08D4 F5 F0 MOV B,A ; save UR0 data in B 08D6 78 01 MOV R0,#DEFRB+1 ; pt to R1 of default bank 08D8 7F 06 MOV R7,#6 ; want to do 6 registers 08DA E0 GO40 MOVX A,@DPTR ; get data (URn) 08DB A3 INC DPTR ; increment the pointer 08DC F6 MOV @R0,A ; save the register 08DD 08 INC R0 ; pt to next register 08DE DF FA DJNZ R7,GO40 ; do R1 throgh R6 08E0 E0 MOVX A,@DPTR ; get data from UR7 08E1 F6 MOV @R0,A ; save at R7 08E2 E5 F0 MOV A,B ; restore data for R0 08E4 F8 MOV R0,A ; save at R7 ; now R0 through R7 have been loaded ; now restore B 08E5 90 EF1D MOV DPTR,#UB ; pt to UB 08E8 E0 MOVX A,@DPTR ; get B 08E9 F5 F0 MOV B,A ; B now restored ; now restore SP 08EB 90 EF1E MOV DPTR,#USP ; pt to USP 08EE E0 MOVX A,@DPTR ; get SP 08EF F5 81 MOV SP,A ; now using user SP ; now push PC onto stack 08F1 90 EF20 MOV DPTR,#UPCL ; pt to user PC low 08F4 E0 MOVX A,@DPTR ; get user PC low 08F5 C0 E0 PUSH ACC ; save on user stack 08F7 90 EF1F MOV DPTR,#UPCH ; pt to user PC high 08FA E0 MOVX A,@DPTR ; get user PC high 08FB C0 E0 PUSH ACC ; save on user stack ; now push ACC onto stack 08FD 90 EF11 MOV DPTR,#UACC ; pt to user ACC Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 29 FUNC2.ASM: Main Function Code, part 2 0900 E0 MOVX A,@DPTR ; get user ACC 0901 C0 E0 PUSH ACC ; save on user stack ; now push PSW onto stack 0903 A3 INC DPTR ; pt to user PSW 0904 E0 MOVX A,@DPTR ; get user PSW 0905 C0 E0 PUSH ACC ; save on user stack ; now restore DPTR 0907 90 EF1B MOV DPTR,#UDPH ; pt to user DPTR 090A 12 1626 CALL DPATDP ; move data to DPTR 090D D0 D0 POP PSW ; restore PSW 090F D0 E0 POP ACC ; restore ACC 0911 22 RET ; restore PC and that's a jump to user! RBKPNT ; return from breakpoint via call, next PC already on stack ; save DPTR on stack, will get in a bit 0912 C0 82 PUSH DPL ; save DPL 0914 C0 83 PUSH DPH ; save DPH ; now save ACC 0916 90 EF11 MOV DPTR,#UACC ; pt to UACC 0919 F0 MOVX @DPTR,A ; save ACC ; now save PSW 091A A3 INC DPTR ; pt to UPSW 091B E5 D0 MOV A,PSW ; get PSW to A 091D F0 MOVX @DPTR,A ; save PSW 091E 75 D0 00 MOV PSW,#DEFRB ; set RB to default ; now save B 0921 90 EF1D MOV DPTR,#UB ; pt to UB 0924 E5 F0 MOV A,B ; move B to A 0926 F0 MOVX @DPTR,A ; save B ; now save DPTR 0927 90 EF1B MOV DPTR,#UDPH ; pt to UDPTR high 092A D0 E0 POP ACC ; recover DPH 092C F0 MOVX @DPTR,A ; save at UDPH 092D A3 INC DPTR ; pt to UDPL 092E D0 E0 POP ACC ; recover DPL 0930 F0 MOVX @DPTR,A ; save at UDPL ; now save PC 0931 90 EF1F MOV DPTR,#UPCH ; pt to UDPTR high 0934 D0 E0 POP ACC ; recover PC high 0936 F0 MOVX @DPTR,A ; save at UPCH 0937 A3 INC DPTR ; pt to UPCL 0938 D0 E0 POP ACC ; recover PC low 093A F0 MOVX @DPTR,A ; save at UPCL ; stack is now same as when breakpoint was found ; now save SP 093B 90 EF1E MOV DPTR,#USP ; pt to SP 093E E5 81 MOV A,SP ; move SP to A 0940 F0 MOVX @DPTR,A ; save at UPCH ; now restore DEFRB to URn 0941 90 EF13 MOV DPTR,#UR0 ; pt to UR0 0944 E8 MOV A,R0 ; move R0 to A 0945 F0 MOVX @DPTR,A ; save at UR0 0946 A3 INC DPTR ; pt to UR1 Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 30 FUNC2.ASM: Main Function Code, part 2 0947 E9 MOV A,R1 ; move R1 to A 0948 F0 MOVX @DPTR,A ; save at UR1 0949 A3 INC DPTR ; pt to UR2 094A 78 02 MOV R0,#DEFRB+2 ; pt to R2 094C 79 06 MOV R1,#6 ; 6 more regs to do 094E E6 RBKPN10 MOV A,@R0 ; get Rn 094F F0 MOVX @DPTR,A ; save at URn 0950 A3 INC DPTR ; pt to URn+1 0951 08 INC R0 ; tp to Rn+1 0952 D9 FA DJNZ R1,RBKPN10 ; do R2 throgh R7 ; all OK except that PC is 3 too far (call used for breakpoint) 0954 90 EF1F MOV DPTR,#UPCH ; pt to UDPTR high 0957 12 1626 CALL DPATDP ; move user's PC to DPTR 095A 7A 03 MOV R2,#3 ; want 3 loops 095C 12 165C RBKPN20 CALL DECDPTR ; decrement data pointer 095F DA FB DJNZ R2,RBKPN20 ; loop till done 0961 E5 83 MOV A,DPH ; move high to A 0963 AC 82 MOV R4,DPL ; move low to R4 0965 90 EF1F MOV DPTR,#UPCH ; pt to UDPTR high 0968 F0 MOVX @DPTR,A ; save high at UPCH 0969 A3 INC DPTR ; pt to UPCL 096A EC MOV A,R4 ; recover low from UPCL 096B F0 MOVX @DPTR,A ; save low at UPCL ; now all registers have been restore 096C 12 102A CALL CBKPT ; clear the break points, if any 096F 12 0D9F CALL DSPREG ; display the registers 0972 02 00ED JMP MAIN05 ; get next command FIND ; find the arg list wherever it appears in memory ; usage: f arg0 ... (16 max) 0975 12 161C CALL SPACE1 ; print a space 0978 79 00 MOV R1,#0 ; R2 is arg count for now 097A 90 EF2E MOV DPTR,#FBUF ; pt to buffer 097D 12 154F FIND10 CALL GARG ; get an arg to R3/R4 0980 60 09 JZ FIND20 ; finished if no input 0982 EC MOV A,R4 ; move low byte to A 0983 F0 MOVX @DPTR,A ; save in memory 0984 A3 INC DPTR ; point to next location 0985 09 INC R1 ; inc arg counter 0986 40 03 JC FIND20 ; jump if CR entered 0988 B9 10 F2 CJNE R1,#16,FIND10 ; loop if not terminal count 098B 12 1437 FIND20 CALL CRLF ; move to a new line 098E B9 00 03 CJNE R1,#0,FIND25 ; jump if data was entered 0991 D2 D7 SETB CY ; want prompt 0993 22 RET ; else, return 0994 7B 00 FIND25 MOV R3,#0 ; zero address HIGH ptr and start compare 0996 7C 01 MOV R4,#1 ; address LOW ptr (skip location 0000H) 0998 90 EF2E FIND30 MOV DPTR,#FBUF ; pt to memory location 099B EB MOV A,R3 ; get addr high ptr to A 099C 4C ORL A,R4 ; or in low value 099D B4 00 03 CJNE A,#0,FIND35 ; jump if not zero 09A0 D2 D7 SETB CY ; want prompt 09A2 22 RET ; that's all Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 31 FUNC2.ASM: Main Function Code, part 2 09A3 12 147E FIND35 CALL KBESC ; ESC from KB? 09A6 50 03 JNC FIND37 ; jump if not found 09A8 D2 D7 SETB CY ; want prompt 09AA 22 RET ; stop if so 09AB E0 FIND37 MOVX A,@DPTR ; get a char from buffer 09AC F8 MOV R0,A ; save data in R0 09AD A3 INC DPTR ; pt to next buffer char 09AE AD 83 MOV R5,DPH ; save DPTR to buffer ptr storage 09B0 AE 82 MOV R6,DPL 09B2 8B 83 MOV DPH,R3 ; restore adr pointer 09B4 8C 82 MOV DPL,R4 09B6 E0 MOVX A,@DPTR ; get data from address space 09B7 A3 INC DPTR ; inc addr memory pointer 09B8 AB 83 MOV R3,DPH ; save adr pointer 09BA AC 82 MOV R4,DPL 09BC 68 XRL A,R0 ; see data same 09BD 70 D9 JNZ FIND30 ; jump if not the same 09BF C0 82 FIND40 PUSH DPL ; save next addr ptr in case no match 09C1 C0 83 PUSH DPH 09C3 E9 MOV A,R1 ; get arg count 09C4 14 DEC A ; matched once so reduce value by one 09C5 FF MOV R7,A ; and save in R7 09C6 8D 83 FIND50 MOV DPH,R5 ; get ptr to buffer 09C8 8E 82 MOV DPL,R6 09CA E0 MOVX A,@DPTR ; get the char 09CB A3 INC DPTR ; pt to next char in buffer 09CC FA MOV R2,A ; save in R2 09CD AD 83 MOV R5,DPH ; save new buffer ptr 09CF AE 82 MOV R6,DPL 09D1 8B 83 MOV DPH,R3 ; get new adr pointer 09D3 8C 82 MOV DPL,R4 09D5 E0 MOVX A,@DPTR ; get the char from xdata space 09D6 A3 INC DPTR ; pt to next address 09D7 AB 83 MOV R3,DPH ; save ptr 09D9 AC 82 MOV R4,DPL 09DB 6A XRL A,R2 ; see chars match 09DC 70 2F JNZ FIND60 ; jump if not match 09DE DF E6 DJNZ R7,FIND50 ; loop till all chars are matched 09E0 EB MOV A,R3 ; get adr high 09E1 6D XRL A,R5 ; see if same as buffer 09E2 70 07 JNZ FIND55 ; jump if not same as buffer high 09E4 EC MOV A,R4 ; get adr low 09E5 6E XRL A,R6 ; see if same as buffer 09E6 70 03 JNZ FIND55 ; jump if not same as buffer low 09E8 02 0A0D JMP FIND60 ; match was with arg list itself! 09EB D0 83 FIND55 POP DPH ; restore next address to test 09ED D0 82 POP DPL 09EF 12 165C CALL DECDPTR ; decrement DPTR 09F2 74 78 MOV A,#'x' ; get x for EDM 09F4 12 13F2 CALL PUTCHAR ; put the char 09F7 E5 83 MOV A,DPH ; get high byte 09F9 12 15D7 CALL PHXBYTE ; print it 09FC E5 82 MOV A,DPL ; get low byte Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 32 FUNC2.ASM: Main Function Code, part 2 09FE 12 15D7 CALL PHXBYTE ; print it 0A01 A3 INC DPTR ; pt to same spot 0A02 74 3A MOV A,#':' ; get colon 0A04 12 13F2 CALL PUTCHAR ; put the char 0A07 12 1437 CALL CRLF ; newline 0A0A 02 0A11 JMP FIND70 ; ptr already taken from stack 0A0D D0 83 FIND60 POP DPH ; recover value from stack 0A0F D0 82 POP DPL 0A11 AB 83 FIND70 MOV R3,DPH ; update adr storage 0A13 AC 82 MOV R4,DPL 0A15 80 81 JMP FIND30 ; continue till end of memory $RESETLN $SETLN(FUNC3.ASM); %INCLUDE FUNC3.ASM ; functions part 3 $SUBTITLE(FUNC3.ASM: Main Function Code, part 3) Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 33 FUNC3.ASM: Main Function Code, part 3 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; Functions for monitor ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; JAM ; jam start end data 0A17 12 161C CALL SPACE1 ; space over one position 0A1A 12 1525 CALL CARG ; collect arguments 0A1D 12 1437 CALL CRLF ; new line 0A20 90 EF00 MOV DPTR,#ARGC ; pt to ARGC 0A23 E0 MOVX A,@DPTR ; get ARGC to A 0A24 64 03 XRL A,#3 ; see if ARGC == 3 0A26 60 03 JZ JAM05 ; jump if so 0A28 02 1400 JMP SYSERR ; jump to err if needed args not present 0A2B 90 EF06 JAM05 MOV DPTR,#ARGV2+1 ; pt to data 0A2E E0 MOVX A,@DPTR ; get the data to A 0A2F 90 EF01 MOV DPTR,#ARGV0 ; get starting address 0A32 12 1626 CALL DPATDP ; get value pointed to by DPTR to DPTR 0A35 F0 JAM10 MOVX @DPTR,A ; save the data 0A36 A3 INC DPTR ; pt to next location 0A37 12 0F92 CALL DPGV1 ; set CY if DPTR is greater than ARGV1 0A3A 50 F9 JNC JAM10 ; loop till done 0A3C D2 D7 SETB CY ; want prompt 0A3E 22 RET LSTACK ; list stack address and data 0A3F 12 1437 CALL CRLF ; get to a newline 0A42 90 1724 MOV DPTR,#LSTMSG0 ; pt to stack message 0 0A45 12 1491 CALL CPUTS ; put string to console 0A48 90 EF1E MOV DPTR,#USP ; pt to user's stack location 0A4B E0 MOVX A,@DPTR ; get stack address 0A4C 24 F8 ADD A,#-8 ; subract 8 from stack pointer 0A4E FB MOV R3,A ; save in R3 0A4F F8 MOV R0,A ; R0 is address pointer 0A50 7A 11 MOV R2,#17 ; number of bytes to print 0A52 E8 LSTA10 MOV A,R0 ; get address 0A53 12 15D7 CALL PHXBYTE ; print the byte 0A56 12 161C CALL SPACE1 ; print a space 0A59 08 INC R0 ; pt to next 0A5A DA F6 DJNZ R2,LSTA10 ; loop till done 0A5C 90 172A MOV DPTR,#LSTMSG1 ; pt to stack message 1 0A5F 12 1491 CALL CPUTS ; put string to console 0A62 EB MOV A,R3 ; get starting address 0A63 F8 MOV R0,A ; R0 is address pointer 0A64 7A 11 MOV R2,#17 ; number of bytes to print 0A66 E6 LSTA20 MOV A,@R0 ; get a byte 0A67 12 15D7 CALL PHXBYTE ; print the byte 0A6A 12 161C CALL SPACE1 ; print a space 0A6D 08 INC R0 ; pt to next 0A6E DA F6 DJNZ R2,LSTA20 ; loop till done 0A70 12 1437 CALL CRLF ; print a newline 0A73 D2 D7 SETB CY ; want prompt 0A75 22 RET Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 34 FUNC3.ASM: Main Function Code, part 3 MOVE ; move block of data (M start end to) 0A76 12 161C CALL SPACE1 ; space over one position 0A79 12 1525 CALL CARG ; collect arguments 0A7C 12 1437 CALL CRLF ; new line 0A7F 90 EF00 MOV DPTR,#ARGC ; pt to ARGC 0A82 E0 MOVX A,@DPTR ; get ARGC to A 0A83 64 03 XRL A,#3 ; see if ARGC == 3 0A85 60 03 JZ MOVE05 ; jump if so 0A87 02 1400 JMP SYSERR ; jump to err if needed args not present 0A8A 90 EF05 MOVE05 MOV DPTR,#ARGV2 ; pt to place to go 0A8D 12 1626 CALL DPATDP ; get value pointed to by DPTR to DPTR 0A90 AC 83 MOV R4,DPH ; get high of TO into R4 0A92 AD 82 MOV R5,DPL ; get low of TO into R5 0A94 90 EF01 MOV DPTR,#ARGV0 ; pt to place to start 0A97 12 1626 CALL DPATDP ; get value pointed to by DPTR to DPTR 0A9A E0 MOVE10 MOVX A,@DPTR ; get the FROM data into A 0A9B A3 INC DPTR ; pt to next from address 0A9C AA 83 MOV R2,DPH ; get high of FROM into R2 0A9E AB 82 MOV R3,DPL ; get low of FROM into R3 0AA0 8C 83 MOV DPH,R4 ; get high of TO from R4 0AA2 8D 82 MOV DPL,R5 ; get low of TO from R5 0AA4 F0 MOVX @DPTR,A ; save data 0AA5 A3 INC DPTR ; pt to next to address 0AA6 AC 83 MOV R4,DPH ; get high of TO into R4 0AA8 AD 82 MOV R5,DPL ; get low of TO into R5 0AAA 8A 83 MOV DPH,R2 ; get high of FROM from R2 0AAC 8B 82 MOV DPL,R3 ; get low of FROM from R3 0AAE 12 0F92 CALL DPGV1 ; set CY if DPTR is greater than ARGV1 0AB1 50 E7 JNC MOVE10 ; loop till done 0AB3 D2 D7 SETB CY ; want prompt 0AB5 22 RET POV ; power on vector, variable loader ; usage is P xxxx, where xxxx is address to go to ; address of 0000 disables power on vector feature 0AB6 12 161C CALL SPACE1 ; space over one position 0AB9 12 1525 CALL CARG ; collect arguments 0ABC 12 1437 CALL CRLF ; new line 0ABF 90 EF00 MOV DPTR,#ARGC ; pt to ARGC 0AC2 E0 MOVX A,@DPTR ; get ARGC to A 0AC3 64 01 XRL A,#1 ; see if ARGC == 1 0AC5 60 03 JZ POV10 ; jump if so 0AC7 02 1400 JMP SYSERR ; jump to err if needed args not present 0ACA 90 EF01 POV10 MOV DPTR,#ARGV0 ; get the argument 0ACD 12 1626 CALL DPATDP ; get the value 0AD0 AF 83 MOV R7,DPH ; save high to R7 0AD2 E5 83 MOV A,DPH ; move high to A 0AD4 64 A8 XRL A,#0A8H ; calc modified high vector 0AD6 FD MOV R5,A ; save in R5 0AD7 AE 82 MOV R6,DPL ; save low to R6 0AD9 E5 82 MOV A,DPL ; move low to A 0ADB 64 58 XRL A,#058H ; calc modified low vector Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 35 FUNC3.ASM: Main Function Code, part 3 0ADD FC MOV R4,A ; save in R4 0ADE 2D ADD A,R5 ; calc checksum 0ADF 2E ADD A,R6 ; calc checksum 0AE0 2F ADD A,R7 ; calc checksum 0AE1 FB MOV R3,A ; save checksum to R3 0AE2 64 0F XRL A,#00FH ; calc modified checksum 0AE4 FA MOV R2,A ; save in R2 0AE5 90 EFCA MOV DPTR,#POVMEM ; pt to vector memory 0AE8 EF MOV A,R7 ; get high adr to A 0AE9 F0 MOVX @DPTR,A ; save at memory 0AEA A3 INC DPTR ; pt to next 0AEB EE MOV A,R6 ; get low adr to A 0AEC F0 MOVX @DPTR,A ; save at memory 0AED A3 INC DPTR ; pt to next 0AEE ED MOV A,R5 ; get mod high adr to A 0AEF F0 MOVX @DPTR,A ; save at memory 0AF0 A3 INC DPTR ; pt to next 0AF1 EC MOV A,R4 ; get mod low adr to A 0AF2 F0 MOVX @DPTR,A ; save at memory 0AF3 A3 INC DPTR ; pt to next 0AF4 EB MOV A,R3 ; get checksum to A 0AF5 F0 MOVX @DPTR,A ; save at memory 0AF6 A3 INC DPTR ; pt to next 0AF7 EA MOV A,R2 ; get mod checksum to A 0AF8 F0 MOVX @DPTR,A ; save at memory 0AF9 A3 INC DPTR ; pt to next 0AFA D2 D7 SETB CY ; want prompt 0AFC 22 RET ; that's all ;POV ; set power on vector ; CALL SPACE1 ; space over one position ; CALL CARG ; collect arguments ; CALL CRLF ; new line ; MOV DPTR,#ARGC ; pt to ARGC ; MOVX A,@DPTR ; get ARGC to A ; XRL A,#1 ; see if ARGC == 1 ; JZ POV10 ; jump if so ; JMP SYSERR ; jump to err if needed args not present ;POV10 MOV DPTR,#ARGV0 ; get the argument ; CALL DPATDP ; get the value ; MOV R4,DPH ; save high to R4 ; MOV A,R4 ; move high to A ; CPL A ; complement it ; MOV R6,A ; save complement of high to R6 ; MOV R5,DPL ; save low to R5 ; MOV A,R5 ; move low to A ; CPL A ; complement it ; MOV R7,A ; save complement of low to R7 ; MOV DPTR,#POVM ; point to POV memory ; MOV A,R4 ; get high byte ; MOVX @DPTR,A ; save high byte ; INC DPTR ; pt to POVM+1 Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 36 FUNC3.ASM: Main Function Code, part 3 ; MOV A,R5 ; get low byte ; MOVX @DPTR,A ; save low byte ; INC DPTR ; pt to POVM+2 ; MOV A,R7 ; get !low byte ; MOVX @DPTR,A ; save !low byte ; INC DPTR ; pt to POVM+3 ; MOV A,R6 ; get !high byte ; MOVX @DPTR,A ; save !high byte ; INC DPTR ; pt to POVM+4 ; MOVX @DPTR,A ; save !high byte ; INC DPTR ; pt to POVM+5 ; MOV A,R7 ; get !low byte ; MOVX @DPTR,A ; save !low byte ; INC DPTR ; pt to POVM+6 ; MOV A,R5 ; get low byte ; MOVX @DPTR,A ; save low byte ; INC DPTR ; pt to POVM+7 ; MOV A,R4 ; get high byte ; MOVX @DPTR,A ; save low byte ; RET ; that's all SUB ; substitute memory and registers 0AFD 12 1452 CALL GETUCHE ; get an input char with echo 0B00 B4 49 09 CJNE A,#'I',SUB10 ; jump if not internal 0B03 12 0B67 CALL SUBINT ; substitute internal ram 0B06 12 1437 CALL CRLF ; end with newline 0B09 D2 D7 SETB CY ; want prompt 0B0B 22 RET ; that's all 0B0C B4 58 09 SUB10 CJNE A,#'X',SUB20 ; jump if not external 0B0F 12 0B27 CALL SUBEXT ; substitute external ram 0B12 12 1437 CALL CRLF ; end with newline 0B15 D2 D7 SETB CY ; want prompt 0B17 22 RET ; that's all 0B18 B4 46 09 SUB20 CJNE A,#'F',SUB30 ; jump if not SFR 0B1B 12 0BAB CALL SUBSFR ; substitute SFR 0B1E 12 1437 CALL CRLF ; end with newline 0B21 D2 D7 SETB CY ; want prompt 0B23 22 RET ; that's all 0B24 02 1400 SUB30 JMP SYSERR ; no such command SUBEXT ; substitute external ram memory; ; usage: sx address; use space for next, CR to end 0B27 12 161C CALL SPACE1 ; space over one position 0B2A 12 1525 CALL CARG ; collect arguments 0B2D 90 EF00 MOV DPTR,#ARGC ; pt to ARGC 0B30 E0 MOVX A,@DPTR ; get ARGC to A 0B31 A3 INC DPTR ; pt to ARGV0 high 0B32 64 01 XRL A,#1 ; see if one 0B34 60 03 JZ SUBEX05 ; jump if so 0B36 02 1400 JMP SYSERR ; else, bad argument 0B39 12 1626 SUBEX05 CALL DPATDP ; make DPTR = @DPTR 0B3C 12 1437 SUBEX10 CALL CRLF ; start on new line 0B3F 74 78 MOV A,#'x' ; get x to mark external data memory Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 37 FUNC3.ASM: Main Function Code, part 3 0B41 12 13F2 CALL PUTCHAR ; print the char 0B44 12 15CC CALL PDPTR ; print address 0B47 74 3A MOV A,#':' ; get colon 0B49 12 13F2 CALL PUTCHAR ; print the char 0B4C 12 1619 CALL SPACE2 ; space 0B4F E0 MOVX A,@DPTR ; get data 0B50 12 15D7 CALL PHXBYTE ; print data 0B53 12 161C CALL SPACE1 ; space 0B56 12 158B CALL GARGNSP ; user input, no leading spaces 0B59 60 02 JZ SUBEX20 ; jump if none 0B5B EC MOV A,R4 ; put data in A 0B5C F0 MOVX @DPTR,A ; save in memory 0B5D 20 D7 03 SUBEX20 JB CY,SUBEX30 ; end if CR pressed 0B60 A3 INC DPTR ; inc address pointer 0B61 80 D9 JMP SUBEX10 ; loop again 0B63 12 1437 SUBEX30 CALL CRLF ; print new line 0B66 22 RET ; that's all SUBINT ; substitute internal ram memory; ; usage: si address; use space for next, CR to end 0B67 12 161C CALL SPACE1 ; space over one position 0B6A 12 1525 CALL CARG ; collect arguments 0B6D 90 EF00 MOV DPTR,#ARGC ; pt to ARGC 0B70 E0 MOVX A,@DPTR ; get ARGC to A 0B71 A3 INC DPTR ; pt to ARGV0 high 0B72 A3 INC DPTR ; pt to ARGV0 low 0B73 64 01 XRL A,#1 ; see if one 0B75 60 03 JZ SUBIN05 ; jump if so 0B77 02 1400 JMP SYSERR ; else, bad argument 0B7A E0 SUBIN05 MOVX A,@DPTR ; get low value of starting address 0B7B F8 MOV R0,A ; move that to R0 which is now index 0B7C 12 1437 SUBIN10 CALL CRLF ; start on new line 0B7F 12 1619 CALL SPACE2 ; space 2 times 0B82 74 69 MOV A,#'i' ; get i to mark internal data memory 0B84 12 13F2 CALL PUTCHAR ; print the char 0B87 E8 MOV A,R0 ; move index to A 0B88 12 15D7 CALL PHXBYTE ; print address 0B8B 74 3A MOV A,#':' ; get colon 0B8D 12 13F2 CALL PUTCHAR ; print the char 0B90 12 1619 CALL SPACE2 ; space 2 times 0B93 E6 MOV A,@R0 ; get data 0B94 12 15D7 CALL PHXBYTE ; print data 0B97 12 161C CALL SPACE1 ; space 0B9A 12 158B CALL GARGNSP ; user input, no leading spaces 0B9D 60 02 JZ SUBIN20 ; jump if none 0B9F EC MOV A,R4 ; put data in A 0BA0 F6 MOV @R0,A ; save in memory 0BA1 20 D7 03 SUBIN20 JB CY,SUBIN30 ; end if CR pressed 0BA4 08 INC R0 ; inc address pointer 0BA5 80 D5 JMP SUBIN10 ; loop again 0BA7 12 1437 SUBIN30 CALL CRLF ; print new line 0BAA 22 RET ; that's all Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 38 FUNC3.ASM: Main Function Code, part 3 SUBSFR ; substitute SFR locations ; usage: sf address; use space for next, CR to end 0BAB 12 161C CALL SPACE1 ; space over one position 0BAE 12 1525 CALL CARG ; collect arguments 0BB1 90 EF00 MOV DPTR,#ARGC ; pt to ARGC 0BB4 E0 MOVX A,@DPTR ; get ARGC to A 0BB5 A3 INC DPTR ; pt to ARGV0 high 0BB6 A3 INC DPTR ; pt to ARGV0 low 0BB7 64 01 XRL A,#1 ; see if one 0BB9 60 03 JZ SUBSF05 ; jump if so 0BBB 02 1400 JMP SYSERR ; else, bad argument 0BBE E0 SUBSF05 MOVX A,@DPTR ; get low value of starting address 0BBF F8 MOV R0,A ; move that to R0 which is now index 0BC0 12 1437 SUBSF10 CALL CRLF ; start on new line 0BC3 12 161C CALL SPACE1 ; space 1 time 0BC6 74 66 MOV A,#'f' ; get f to mark function 0BC8 12 13F2 CALL PUTCHAR ; print the char 0BCB 74 72 MOV A,#'r' ; get r to mark register 0BCD 12 13F2 CALL PUTCHAR ; print the char 0BD0 E8 MOV A,R0 ; move index to A 0BD1 12 15D7 CALL PHXBYTE ; print address 0BD4 74 3A MOV A,#':' ; get colon 0BD6 12 13F2 CALL PUTCHAR ; print the char 0BD9 12 1619 CALL SPACE2 ; space 2 times 0BDC 12 13B0 CALL GSFR ; get data at SFR pointed to by R0 0BDF 12 15D7 CALL PHXBYTE ; print data 0BE2 12 161C CALL SPACE1 ; space 0BE5 12 158B CALL GARGNSP ; user input, no leading spaces 0BE8 60 04 JZ SUBSF20 ; jump if none 0BEA EC MOV A,R4 ; put data in A 0BEB 12 139C CALL PSFR ; put data in A to SFR pointed to by R0 0BEE 20 D7 03 SUBSF20 JB CY,SUBSF30 ; end if CR pressed 0BF1 08 INC R0 ; inc address pointer 0BF2 80 CC JMP SUBSF10 ; loop again 0BF4 12 1437 SUBSF30 CALL CRLF ; print new line 0BF7 22 RET ; that's all RX ; receive intel hex code, usage: r 0BF8 12 161C CALL SPACE1 ; move over one space 0BFB 12 154F CALL GARG ; get offset, do it fast 0BFE 12 1437 CALL CRLF ; move to new line 0C01 90 EF01 MOV DPTR,#ARGV0 ; pt to ARGV0 high 0C04 EB MOV A,R3 ; get high value 0C05 F0 MOVX @DPTR,A ; save high value 0C06 A3 INC DPTR ; pt to ARGV0 low 0C07 EC MOV A,R4 ; get low value 0C08 F0 MOVX @DPTR,A ; save low value ;;;;; CALL DUMPBP ; dump any outstanding break pts 0C09 12 1077 RX10 CALL RLINE ; get one record 0C0C 30 D7 03 JNB CY,RX20 ; jump if not error 0C0F 02 1400 JMP SYSERR ; do error routine 0C12 70 F5 RX20 JNZ RX10 ; if not zero get another 0C14 12 165C CALL DECDPTR ; decrement DPTR to point to last byte Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 39 FUNC3.ASM: Main Function Code, part 3 0C17 AD 83 MOV R5,DPH ; save last address high in R5 0C19 AC 82 MOV R4,DPL ; save last address low in R4 0C1B 90 170B MOV DPTR,#RXOKMSG ; get RX OK message 0C1E 12 1491 CALL CPUTS ; put string 0C21 ED MOV A,R5 ; get last address high from R5 0C22 12 15D7 CALL PHXBYTE ; put to console 0C25 EC MOV A,R4 ; get last address low from R4 0C26 12 15D7 CALL PHXBYTE ; put to console 0C29 12 1437 CALL CRLF ; end with newline 0C2C 12 1437 CALL CRLF ; end with newline 0C2F D2 D7 SETB CY ; want prompt 0C31 22 RET VERIFY ; verify memory with intel hex code, usage: v 0C32 12 161C CALL SPACE1 ; move over one space 0C35 12 154F CALL GARG ; get offset, do it fast 0C38 12 1437 CALL CRLF ; move to new line 0C3B 90 EF01 MOV DPTR,#ARGV0 ; pt to ARGV0 high 0C3E EB MOV A,R3 ; get high value 0C3F F0 MOVX @DPTR,A ; save high value 0C40 A3 INC DPTR ; pt to ARGV0 low 0C41 EC MOV A,R4 ; get low value 0C42 F0 MOVX @DPTR,A ; save low value ;;;;; CALL DUMPBP ; dump any outstanding break pts 0C43 12 10DD VERIF10 CALL VLINE ; get one record 0C46 30 D7 03 JNB CY,VERIF20 ; jump if not error 0C49 02 1400 JMP SYSERR ; do error routine 0C4C 70 F5 VERIF20 JNZ VERIF10 ; if not zero get another 0C4E 12 165C CALL DECDPTR ; decrement DPTR to point to last byte 0C51 AD 83 MOV R5,DPH ; save last address high in R5 0C53 AC 82 MOV R4,DPL ; save last address low in R4 0C55 90 170B MOV DPTR,#RXOKMSG ; get RX OK message 0C58 12 1491 CALL CPUTS ; put string 0C5B ED MOV A,R5 ; get last address high from R5 0C5C 12 15D7 CALL PHXBYTE ; put to console 0C5F EC MOV A,R4 ; get last address low from R4 0C60 12 15D7 CALL PHXBYTE ; put to console 0C63 12 1437 CALL CRLF ; end with newline 0C66 12 1437 CALL CRLF ; end with newline 0C69 D2 D7 SETB CY ; want prompt 0C6B 22 RET $RESETLN $SETLN(FUNC4.ASM); %INCLUDE FUNC4.ASM ; functions part 4 $SUBTITLE(FUNC3.ASM: Main Function Code, part 3) Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 40 FUNC3.ASM: Main Function Code, part 3 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; Functions for monitor ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; EXAMINE ; x - examine CPU registers 0C6C 12 1452 CALL GETUCHE ; get an input char with echo 0C6F B4 0D 06 CJNE A,#ACR,EXAMI05 ; jump if not a dump 0C72 12 0D9F CALL DSPREG ; display special registers 0C75 C2 D7 CLR CY ; no prompt wanted 0C77 22 RET ; that's all 0C78 B4 41 17 EXAMI05 CJNE A,#'A',EXAMI10 ; jump if not ACC mod 0C7B 12 1437 CALL CRLF ; newline 0C7E 90 17BB MOV DPTR,#RACC ; get ACC reg message 0C81 12 1491 CALL CPUTS ; put the string 0C84 90 EF11 MOV DPTR,#UACC ; pt to user ACC 0C87 12 11D6 CALL XLOAD ; do the examine and load 0C8A 50 0C JNC EXAMI12 ; do next if no CR 0C8C 12 1437 CALL CRLF ; newline 0C8F D2 D7 SETB CY ; want prompt 0C91 22 RET ; that's all 0C92 B4 57 17 EXAMI10 CJNE A,#'W',EXAMI15 ; jump if not PSW mod 0C95 12 1437 CALL CRLF ; newline 0C98 90 17C3 EXAMI12 MOV DPTR,#RPSW ; get PSW reg message 0C9B 12 1491 CALL CPUTS ; put the string 0C9E 90 EF12 MOV DPTR,#UPSW ; pt to user ACC 0CA1 12 11D6 CALL XLOAD ; do the examine and load 0CA4 50 0C JNC EXAMI17 ; do next if no CR 0CA6 12 1437 CALL CRLF ; newline 0CA9 D2 D7 SETB CY ; want prompt 0CAB 22 RET ; that's all 0CAC B4 4B 32 EXAMI15 CJNE A,#'K',EXAMI20 ; jump if not RB mod 0CAF 12 1437 CALL CRLF ; newline 0CB2 90 17CB EXAMI17 MOV DPTR,#RRB ; get RB reg message 0CB5 12 1491 CALL CPUTS ; put the string 0CB8 90 EF12 MOV DPTR,#UPSW ; pt to user ACC 0CBB E0 MOVX A,@DPTR ; get data 0CBC 54 18 ANL A,#018H ; look only at sig bits 0CBE 23 RL A ; rotate left 0CBF C4 SWAP A ; swap nibbles 0CC0 12 15D7 CALL PHXBYTE ; print data 0CC3 12 161C CALL SPACE1 ; space 0CC6 12 158B CALL GARGNSP ; user input, no leading spaces 0CC9 60 0B JZ EXAMI18 ; jump if none 0CCB EC MOV A,R4 ; put data in A 0CCC 54 03 ANL A,#003H ; ensure just two bits 0CCE C4 SWAP A ; move to upper nibble 0CCF 03 RR A ; move down on 0CD0 FC MOV R4,A ; save in R4 0CD1 E0 MOVX A,@DPTR ; get actual PSW data 0CD2 54 E7 ANL A,#0E7H ; mask out RBANK data 0CD4 4C ORL A,R4 ; or in new data 0CD5 F0 MOVX @DPTR,A ; save in memory Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 41 FUNC3.ASM: Main Function Code, part 3 0CD6 12 1437 EXAMI18 CALL CRLF ; new line 0CD9 50 2E JNC EXAMI23 ; do next if no CR 0CDB 12 1437 CALL CRLF ; newline 0CDE D2 D7 SETB CY ; want prompt 0CE0 22 RET ; else, that's all 0CE1 B4 52 4A EXAMI20 CJNE A,#'R',EXAMI26 ; jump if not Rn mod 0CE4 90 EF12 MOV DPTR,#UPSW ; pt to UPSW 0CE7 E0 MOVX A,@DPTR ; get data 0CE8 54 18 ANL A,#018H ; look only at RS bits 0CEA 64 00 XRL A,#DEFRB ; see if same 0CEC 70 09 JNZ EXAMI21 ; skip over if not 0CEE 90 EF13 MOV DPTR,#UR0 ; pt to UR0 0CF1 12 121C CALL REGNX ; else, regs in image 0CF4 02 0D01 JMP EXAMI22 ; see if CR ended 0CF7 90 EF12 EXAMI21 MOV DPTR,#UPSW ; pt to UPSW 0CFA E0 MOVX A,@DPTR ; get UPSW 0CFB 54 18 ANL A,#018H ; look only at RS bits 0CFD F8 MOV R0,A ; move address of xR0 to ptr 0CFE 12 12FC CALL REGNX50 ; regs not in image 0D01 50 31 EXAMI22 JNC EXAMI27 ; do next if no CR 0D03 12 1437 CALL CRLF ; newline 0D06 D2 D7 SETB CY ; want prompt 0D08 22 RET ; else, that's all 0D09 90 EF12 EXAMI23 MOV DPTR,#UPSW ; pt to UPSW 0D0C E0 MOVX A,@DPTR ; get data 0D0D 54 18 ANL A,#018H ; look only at RS bits 0D0F 64 00 XRL A,#DEFRB ; see if same 0D11 70 09 JNZ EXAMI24 ; skip over if not 0D13 90 EF13 MOV DPTR,#UR0 ; pt to UR0 0D16 12 1225 CALL REGNX01 ; else, regs in image, start R0 0D19 02 0D26 JMP EXAMI25 ; see if CR ended 0D1C 90 EF12 EXAMI24 MOV DPTR,#UPSW ; pt to UPSW 0D1F E0 MOVX A,@DPTR ; get UPSW 0D20 54 18 ANL A,#018H ; look only at RS bits 0D22 F8 MOV R0,A ; move address of xR0 to ptr 0D23 12 1305 CALL REGNX51 ; regs not in image, start R0 0D26 50 0C EXAMI25 JNC EXAMI27 ; do next if no CR 0D28 12 1437 CALL CRLF ; newline 0D2B D2 D7 SETB CY ; want prompt 0D2D 22 RET ; else, that's all 0D2E B4 44 17 EXAMI26 CJNE A,#'D',EXAMI30 ; jump if not DPTR mod 0D31 12 1437 CALL CRLF ; newline 0D34 90 1813 EXAMI27 MOV DPTR,#RDPTR ; get reg message 0D37 12 1491 CALL CPUTS ; put the string 0D3A 90 EF1B MOV DPTR,#UDPH ; pt to user DPTR 0D3D 12 11E8 CALL XLOAD20 ; do the examine and load (for word) 0D40 50 0C JNC EXAMI32 ; do next if no CR 0D42 12 1437 CALL CRLF ; newline 0D45 D2 D7 SETB CY ; want prompt 0D47 22 RET ; that's all 0D48 B4 42 17 EXAMI30 CJNE A,#'B',EXAMI35 ; jump if not B mod 0D4B 12 1437 CALL CRLF ; newline 0D4E 90 181B EXAMI32 MOV DPTR,#RB ; get B reg message Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 42 FUNC3.ASM: Main Function Code, part 3 0D51 12 1491 CALL CPUTS ; put the string 0D54 90 EF1D MOV DPTR,#UB ; pt to user B reg 0D57 12 11D6 CALL XLOAD ; do the examine and load 0D5A 50 0C JNC EXAMI37 ; do next if no CR 0D5C 12 1437 CALL CRLF ; newline 0D5F D2 D7 SETB CY ; want prompt 0D61 22 RET ; that's all 0D62 B4 53 17 EXAMI35 CJNE A,#'S',EXAMI40 ; jump if not SP mod 0D65 12 1437 CALL CRLF ; newline 0D68 90 1823 EXAMI37 MOV DPTR,#RSP ; get SP reg message 0D6B 12 1491 CALL CPUTS ; put the string 0D6E 90 EF1E MOV DPTR,#USP ; pt to user SP reg 0D71 12 11D6 CALL XLOAD ; do the examine and load 0D74 50 0C JNC EXAMI42 ; do next if no CR 0D76 12 1437 CALL CRLF ; newline 0D79 D2 D7 SETB CY ; want prompt 0D7B 22 RET ; that's all 0D7C B4 50 17 EXAMI40 CJNE A,#'P',EXAMI45 ; jump if not PC mod 0D7F 12 1437 CALL CRLF ; newline 0D82 90 182B EXAMI42 MOV DPTR,#RPC ; get reg message 0D85 12 1491 CALL CPUTS ; put the string 0D88 90 EF1F MOV DPTR,#UPCH ; pt to user PC high 0D8B 12 11E8 CALL XLOAD20 ; do the examine and load (for word) 0D8E 50 09 JNC EXAMI47 ; do next if no CR 0D90 12 1437 CALL CRLF ; newline 0D93 D2 D7 SETB CY ; want prompt 0D95 22 RET ; that's all 0D96 02 1400 EXAMI45 JMP SYSERR ; bad command 0D99 12 1437 EXAMI47 CALL CRLF ; newline 0D9C D2 D7 SETB CY ; want prompt 0D9E 22 RET ; that's all DSPREG ; display regs 0D9F 74 0D MOV A,#ACR ; get CR 0DA1 12 13F2 CALL PUTCHAR ; ensure starting at column one 0DA4 90 EF11 MOV DPTR,#UACC ; pt to UACC 0DA7 E0 MOVX A,@DPTR ; get UACC 0DA8 12 15D7 CALL PHXBYTE ; print as two HEX chars 0DAB 12 161C CALL SPACE1 ; space over one 0DAE A3 INC DPTR ; pt to UPSW 0DAF E0 MOVX A,@DPTR ; get UPSW 0DB0 C0 E0 PUSH ACC ; save value on stack 0DB2 12 15F4 CALL PBINARY ; print as binary 0DB5 12 161C CALL SPACE1 ; space over one 0DB8 D0 E0 POP ACC ; restore UPSW 0DBA 12 15D7 CALL PHXBYTE ; print as two HEX chars 0DBD 12 161C CALL SPACE1 ; space over one 0DC0 E0 MOVX A,@DPTR ; get UPSW 0DC1 54 18 ANL A,#18H ; look only at RB bits 0DC3 23 RL A ; rotate left 0DC4 C4 SWAP A ; move to lower nibble 0DC5 12 15D7 CALL PHXBYTE ; print as two HEX chars 0DC8 12 161C CALL SPACE1 ; space over one Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 43 FUNC3.ASM: Main Function Code, part 3 0DCB E0 MOVX A,@DPTR ; get UPSW 0DCC A3 INC DPTR ; pt to UR0, just in case 0DCD 54 18 ANL A,#018H ; look only at RS bits 0DCF B4 00 28 CJNE A,#DEFRB,DSPRE20 ; jump if not default register bank 0DD2 7A 08 MOV R2,#8 ; do 8 loops 0DD4 E0 DSPRE10 MOVX A,@DPTR ; get URn 0DD5 12 15D7 CALL PHXBYTE ; print as two HEX chars 0DD8 12 161C CALL SPACE1 ; space over one 0DDB A3 INC DPTR ; pt to next 0DDC DA F6 DJNZ R2,DSPRE10 ; loop through all 8 0DDE 12 161C CALL SPACE1 ; space over two 0DE1 90 EF13 MOV DPTR,#UR0 ; pt to UR0 0DE4 E0 MOVX A,@DPTR ; get the data 0DE5 F8 MOV R0,A ; move to R0 0DE6 E6 MOV A,@R0 ; get @R0 0DE7 12 15D7 CALL PHXBYTE ; print as two HEX chars 0DEA 12 1619 CALL SPACE2 ; space over one 0DED A3 INC DPTR ; pt to UR1 0DEE E0 MOVX A,@DPTR ; get the data 0DEF F8 MOV R0,A ; move to R0 0DF0 E6 MOV A,@R0 ; get @R0 0DF1 12 15D7 CALL PHXBYTE ; print as two HEX chars 0DF4 12 161C CALL SPACE1 ; space over one 0DF7 02 0E1B JMP DSPRE60 ; done with xRn 0DFA F8 DSPRE20 MOV R0,A ; move address of xR0 to ptr 0DFB FF MOV R7,A ; move to R7 for temp as well 0DFC 7A 08 MOV R2,#8 ; do 8 loops 0DFE E6 DSPRE40 MOV A,@R0 ; get xRn 0DFF 12 15D7 CALL PHXBYTE ; print as two HEX chars 0E02 12 161C CALL SPACE1 ; space over one 0E05 08 INC R0 ; pt to next 0E06 DA F6 DJNZ R2,DSPRE40 ; loop through all 8 0E08 7A 02 MOV R2,#2 ; want two loops 0E0A 12 161C DSPRE50 CALL SPACE1 ; space over one 0E0D EF MOV A,R7 ; recover address of xR0 0E0E F8 MOV R0,A ; get the address to R0 0E0F E6 MOV A,@R0 ; get the data @R0 0E10 F9 MOV R1,A ; move to R1 0E11 E7 MOV A,@R1 ; and that to A (double indirection) 0E12 12 15D7 CALL PHXBYTE ; print as two HEX chars 0E15 12 161C CALL SPACE1 ; space over one 0E18 0F INC R7 ; pt to xR1 0E19 DA EF DJNZ R2,DSPRE50 ; loop two times 0E1B 90 EF1B DSPRE60 MOV DPTR,#UDPH ; pt to user's DPTR high 0E1E E0 MOVX A,@DPTR ; get high byte 0E1F 12 15D7 CALL PHXBYTE ; print as two HEX chars 0E22 A3 INC DPTR ; pt to low byte 0E23 E0 MOVX A,@DPTR ; get low byte 0E24 12 15D7 CALL PHXBYTE ; print as two HEX chars 0E27 12 1619 CALL SPACE2 ; space over one 0E2A 90 EF1B MOV DPTR,#UDPH ; pt to user's DPTR 0E2D 12 1626 CALL DPATDP ; and move that to DPTR 0E30 E0 MOVX A,@DPTR ; get value pointed to by DPTR Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 44 FUNC3.ASM: Main Function Code, part 3 0E31 12 15D7 CALL PHXBYTE ; print as two HEX chars 0E34 12 161C CALL SPACE1 ; space over one 0E37 90 EF1D MOV DPTR,#UB ; pt to user's B reg 0E3A E0 MOVX A,@DPTR ; get it 0E3B 12 15D7 CALL PHXBYTE ; print as two HEX chars 0E3E 12 161C CALL SPACE1 ; space over one 0E41 A3 INC DPTR ; pt to USP 0E42 E0 MOVX A,@DPTR ; get it 0E43 12 15D7 CALL PHXBYTE ; print as two HEX chars 0E46 12 161C CALL SPACE1 ; space over one 0E49 A3 INC DPTR ; pt to UPC high 0E4A E0 MOVX A,@DPTR ; get high byte 0E4B 12 15D7 CALL PHXBYTE ; print as two HEX chars 0E4E A3 INC DPTR ; pt to low byte 0E4F E0 MOVX A,@DPTR ; get low byte 0E50 12 15D7 CALL PHXBYTE ; print as two HEX chars 0E53 12 161C CALL SPACE1 ; space over one 0E56 90 EF1F MOV DPTR,#UPCH ; pt to user's PC 0E59 12 1626 CALL DPATDP ; and move that to DPTR 0E5C 7A 03 MOV R2,#3 ; do thee loops 0E5E 12 161C DSPRE70 CALL SPACE1 ; space over one 0E61 E0 MOVX A,@DPTR ; get value pointed to by DPTR 0E62 12 15D7 CALL PHXBYTE ; print as two HEX chars 0E65 A3 INC DPTR ; pt to next PC 0E66 DA F6 DJNZ R2,DSPRE70 ; loop through all 0E68 12 1437 CALL CRLF ; move to next line 0E6B 90 176B MOV DPTR,#REGID ; pt to register ID line 0E6E 12 1491 CALL CPUTS ; put the string 0E71 74 0D MOV A,#ACR ; get just a CR 0E73 12 13F2 CALL PUTCHAR ; output to console 0E76 22 RET $RESETLN $SETLN(FSUP1.ASM); %INCLUDE FSUP1.ASM ; function support 1 $SUBTITLE(FSUP1.ASM: Function Support Code, part 1) Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 45 FSUP1.ASM: Function Support Code, part 1 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; function support code ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; PILINE ; print a line of internal ram using @R0 0E77 C0 82 PUSH DPL ; save DPL on stack 0E79 E5 82 MOV A,DPL ; move index to A 0E7B F8 MOV R0,A ; and put in R0 0E7C 12 1619 CALL SPACE2 ; print two space chars 0E7F 74 69 MOV A,#'i' ; mark as internal data memory 0E81 12 13F2 CALL PUTCHAR ; output it 0E84 E8 MOV A,R0 ; get address 0E85 12 15D7 CALL PHXBYTE ; print as byte 0E88 74 3A MOV A,#':' ; get colon 0E8A 12 13F2 CALL PUTCHAR ; output it 0E8D 12 161C CALL SPACE1 ; print space char 0E90 7B 10 MOV R3,#16 ; number of bytes per line 0E92 E6 PILIN10 MOV A,@R0 ; get byte 0E93 08 INC R0 ; pt to next byte 0E94 12 15D7 CALL PHXBYTE ; print as HX byte 0E97 12 161C CALL SPACE1 ; print a space 0E9A EB MOV A,R3 ; get position counter 0E9B 54 03 ANL A,#003H ; look only at 2 lsb 0E9D B4 01 03 CJNE A,#01H,PILIN20 ; space every fourth byte 0EA0 12 161C CALL SPACE1 ; print a space 0EA3 DB ED PILIN20 DJNZ R3,PILIN10 ; loop through line 0EA5 D0 82 POP DPL ; restore original DPL 0EA7 E5 82 MOV A,DPL ; move index to A 0EA9 F8 MOV R0,A ; and put in R0 0EAA 12 161C CALL SPACE1 ; print another space char 0EAD 7B 10 MOV R3,#16 ; number of bytes per line 0EAF E6 PILIN30 MOV A,@R0 ; get byte 0EB0 08 INC R0 ; pt to next byte 0EB1 A3 INC DPTR ; this will be used for next line 0EB2 12 1607 CALL PASCHAR ; print as ASCII char 0EB5 DB F8 DJNZ R3,PILIN30 ; loop through line 0EB7 12 1437 CALL CRLF ; new line 0EBA 22 RET ; that's all PXLINE ; print a line of external ram using DPTR 0EBB C0 82 PUSH DPL ; save DPL on stack 0EBD C0 83 PUSH DPH ; save DPH on stack 0EBF 74 78 MOV A,#'x' ; mark as internal data memory 0EC1 12 13F2 CALL PUTCHAR ; output it 0EC4 E5 83 MOV A,DPH ; get address 0EC6 12 15D7 CALL PHXBYTE ; print as byte 0EC9 E5 82 MOV A,DPL ; get address 0ECB 12 15D7 CALL PHXBYTE ; print as byte 0ECE 74 3A MOV A,#':' ; get colon 0ED0 12 13F2 CALL PUTCHAR ; output it 0ED3 12 161C CALL SPACE1 ; print space char 0ED6 7B 10 MOV R3,#16 ; number of bytes per line Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 46 FSUP1.ASM: Function Support Code, part 1 0ED8 E0 PXLIN10 MOVX A,@DPTR ; get byte 0ED9 A3 INC DPTR ; pt to next byte 0EDA 12 15D7 CALL PHXBYTE ; print as HX byte 0EDD 12 161C CALL SPACE1 ; print a space 0EE0 EB MOV A,R3 ; get position counter 0EE1 54 03 ANL A,#003H ; look only at 2 lsb 0EE3 B4 01 03 CJNE A,#01H,PXLIN20 ; space every fourth byte 0EE6 12 161C CALL SPACE1 ; print a space 0EE9 DB ED PXLIN20 DJNZ R3,PXLIN10 ; loop through line 0EEB D0 83 POP DPH ; restore original DPH 0EED D0 82 POP DPL ; restore original DPL 0EEF 12 161C CALL SPACE1 ; print another space char 0EF2 7B 10 MOV R3,#16 ; number of bytes per line 0EF4 E0 PXLIN30 MOVX A,@DPTR ; get byte 0EF5 A3 INC DPTR ; pt to next byte 0EF6 12 1607 CALL PASCHAR ; print as ASCII char 0EF9 DB F9 DJNZ R3,PXLIN30 ; loop through line 0EFB 12 1437 CALL CRLF ; new line 0EFE 22 RET ; that's all PPLINE ; print a line of program memory using DPTR 0EFF C0 82 PUSH DPL ; save DPL on stack 0F01 C0 83 PUSH DPH ; save DPH on stack 0F03 74 70 MOV A,#'p' ; mark as internal data memory 0F05 12 13F2 CALL PUTCHAR ; output it 0F08 E5 83 MOV A,DPH ; get address 0F0A 12 15D7 CALL PHXBYTE ; print as byte 0F0D E5 82 MOV A,DPL ; get address 0F0F 12 15D7 CALL PHXBYTE ; print as byte 0F12 74 3A MOV A,#':' ; get colon 0F14 12 13F2 CALL PUTCHAR ; output it 0F17 12 161C CALL SPACE1 ; print space char 0F1A 7B 10 MOV R3,#16 ; number of bytes per line 0F1C E4 PPLIN10 CLR A ; clear A 0F1D 93 MOVC A,@A+DPTR ; get byte from progam memory 0F1E A3 INC DPTR ; pt to next byte 0F1F 12 15D7 CALL PHXBYTE ; print as HX byte 0F22 12 161C CALL SPACE1 ; print a space 0F25 EB MOV A,R3 ; get position counter 0F26 54 03 ANL A,#003H ; look only at 2 lsb 0F28 B4 01 03 CJNE A,#01H,PPLIN20 ; space every fourth byte 0F2B 12 161C CALL SPACE1 ; print a space 0F2E DB EC PPLIN20 DJNZ R3,PPLIN10 ; loop through line 0F30 D0 83 POP DPH ; restore original DPH 0F32 D0 82 POP DPL ; restore original DPL 0F34 12 161C CALL SPACE1 ; print another space char 0F37 7B 10 MOV R3,#16 ; number of bytes per line 0F39 E4 PPLIN30 CLR A ; clear A 0F3A 93 MOVC A,@A+DPTR ; get byte from program memory 0F3B A3 INC DPTR ; pt to next byte 0F3C 12 1607 CALL PASCHAR ; print as ASCII char 0F3F DB F8 DJNZ R3,PPLIN30 ; loop through line 0F41 12 1437 CALL CRLF ; new line Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 47 FSUP1.ASM: Function Support Code, part 1 0F44 22 RET ; that's all PSLINE ; print a line of SFR data using direct addressing 0F45 C0 82 PUSH DPL ; save DPL on stack 0F47 E5 82 MOV A,DPL ; move index to A 0F49 F8 MOV R0,A ; and put in R0 0F4A 12 161C CALL SPACE1 ; print one space char 0F4D 74 66 MOV A,#'f' ; mark as SFR data 0F4F 12 13F2 CALL PUTCHAR ; output it 0F52 74 72 MOV A,#'r' ; mark as above 0F54 12 13F2 CALL PUTCHAR ; output it 0F57 E8 MOV A,R0 ; get address 0F58 12 15D7 CALL PHXBYTE ; print as byte 0F5B 74 3A MOV A,#':' ; get colon 0F5D 12 13F2 CALL PUTCHAR ; output it 0F60 12 161C CALL SPACE1 ; print space char 0F63 7B 10 MOV R3,#16 ; number of bytes per line 0F65 12 13B0 PSLIN10 CALL GSFR ; get SFR data 0F68 08 INC R0 ; pt to next byte 0F69 12 15D7 CALL PHXBYTE ; print as HX byte 0F6C 12 161C CALL SPACE1 ; print a space 0F6F EB MOV A,R3 ; get position counter 0F70 54 03 ANL A,#003H ; look only at 2 lsb 0F72 B4 01 03 CJNE A,#01H,PSLIN20 ; space every fourth byte 0F75 12 161C CALL SPACE1 ; print a space 0F78 DB EB PSLIN20 DJNZ R3,PSLIN10 ; loop through line 0F7A D0 82 POP DPL ; restore original DPL 0F7C E5 82 MOV A,DPL ; move index to A 0F7E F8 MOV R0,A ; and put in R0 0F7F 12 161C CALL SPACE1 ; print another space char 0F82 7B 10 MOV R3,#16 ; number of bytes per line 0F84 12 13B0 PSLIN30 CALL GSFR ; get SFR data 0F87 08 INC R0 ; pt to next byte 0F88 A3 INC DPTR ; this will be used for next line 0F89 12 1607 CALL PASCHAR ; print as ASCII char 0F8C DB F6 DJNZ R3,PSLIN30 ; loop through line 0F8E 12 1437 CALL CRLF ; new line 0F91 22 RET ; that's all DPGV1 ; set CY if DP greater than ARGV1 0F92 C0 E0 PUSH ACC ; save A on stack 0F94 E8 MOV A,R0 ; put R0 in A 0F95 C0 E0 PUSH ACC ; save R0 on stack 0F97 C0 82 PUSH DPL ; save DPL 0F99 C0 83 PUSH DPH ; save DPH 0F9B 90 EF03 MOV DPTR,#ARGV1 ; pt to ARGV1 high 0F9E E0 MOVX A,@DPTR ; A gets high value or ARGV1 0F9F A8 81 MOV R0,SP ; move SP to R0 (to pt to old DPTR on stk 0FA1 C2 D7 CLR CY ; clear C 0FA3 96 SUBB A,@R0 ; A-@R0, H:ARGV1 - H:DPTR ; this sets C if H:DPTR > H:ARGV1 ; if CY then DPTR > ARGV1, past threshold 0FA4 40 0C JC DPGV110 ; jump to "past" if H:DPTR > H:ARGV1 Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 48 FSUP1.ASM: Function Support Code, part 1 0FA6 70 0F JNZ DPGV120 ; jump to OK if H:DPTR < H:ARGV1 0FA8 A3 DPBV105 INC DPTR ; pt to ARGV1 low 0FA9 18 DEC R0 ; pt to DPL image on stack 0FAA E0 MOVX A,@DPTR ; A gets L:ARGV1 0FAB C2 D7 CLR CY ; clear C 0FAD 96 SUBB A,@R0 ; A-@R0, L:ARGV1 - L:DPTR 0FAE 50 07 JNC DPGV120 ; fail if L:ARGV1 is more than L:DPTR 0FB0 60 05 JZ DPGV120 ; equal is also a failure DPGV110 ; come here if DPTR is > ARGV1 0FB2 D2 D7 SETB CY ; mark that DPTR is greater than ARGV1 0FB4 02 0FB9 JMP DPGV130 ; end DPGV120 ; come here if DPTR is <= ARGV1 0FB7 C2 D7 CLR CY ; mark that DPTR is <= than ARGV1 DPGV130 ; restore stack 0FB9 D0 83 POP DPH ; restore DPH 0FBB D0 82 POP DPL ; restore DPL 0FBD D0 E0 POP ACC ; get old R0 0FBF F8 MOV R0,A ; restore it 0FC0 D0 E0 POP ACC ; restore ACC 0FC2 22 RET ; that's all ;DPGV1 ; set CY if DP greater than ARGV1 ; MOV R6,A ; save A in R6 ; PUSH DPL ; save DPL ; PUSH DPH ; save DPH ; MOV DPTR,#ARGV1 ; pt to ARGV1 high ; MOVX A,@DPTR ; get value ; MOV R7,A ; move to R7 ; MOV R0,SP ; move SP to R0 (to pt to old DPTR on stk ; MOV A,@R0 ; get DPH image to A ; CLR CY ; clear C ; SUBB A,R7 ; DPTR - ARGV1 (high) ; JB CY,DPGV120 ; jump if h DPTR is less than h ARGV1 ; JNZ DPGV110 ; jump DPTR h is > ARGV1 ; INC DPTR ; pt to ARGV1 low ; DEC R0 ; pt to DPL image on stack ; MOVX A,@DPTR ; get value of ARGV1 low ; MOV R7,A ; move to R7 ; MOV A,@R0 ; get DPL to A ; CLR CY ; clear C ; SUBB A,R7 ; DPTR - ARGV1 (low) ; JB CY,DPGV120 ; fail if h DPTR is less than h ARGV1 ; JZ DPGV120 ; equal is also a failure ;DPGV110 SETB CY ; mark that DPTR is greater than ARGV1 ; JMP DPGV130 ; end ;DPGV120 CLR CY ; mark that DPTR is <= than ARGV1 ;DPGV130 POP DPH ; restore DPH ; POP DPL ; restore DPL ; MOV A,R6 ; recover A from R6 ; RET ; that's all SBKPT ; set break points at addresses in ARGV0 and ARGV1 0FC3 90 EF01 MOV DPTR,#ARGV0 ; pt to 0th argument Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 49 FSUP1.ASM: Function Support Code, part 1 0FC6 12 1626 CALL DPATDP ; move to DPTR 0FC9 E5 83 MOV A,DPH ; get high 0FCB 70 07 JNZ SBKPT10 ; not zero, set break point 0FCD E5 82 MOV A,DPL ; get high 0FCF 70 03 JNZ SBKPT10 ; not zero, set break point 0FD1 02 0FEA JMP SBKPT20 ; this one is zero, try next 0FD4 AC 83 SBKPT10 MOV R4,DPH ; put address high to R4 0FD6 AD 82 MOV R5,DPL ; put address low to R5 0FD8 12 1012 CALL GBDADP ; get break point data at DPTR 0FDB 90 EF21 MOV DPTR,#BKS0A ; pt to break storage 0 address 0FDE 12 101B CALL SBDADP ; save break point data at DPTR 0FE1 90 EF01 MOV DPTR,#ARGV0 ; pt to 0th argument 0FE4 12 1626 CALL DPATDP ; move to DPTR 0FE7 12 106B CALL BPADP ; insert breakpoint at DPTR location 0FEA 90 EF03 SBKPT20 MOV DPTR,#ARGV1 ; pt to 1th argument 0FED 12 1626 CALL DPATDP ; move to DPTR 0FF0 E5 83 MOV A,DPH ; get high 0FF2 70 07 JNZ SBKPT30 ; not zero, set break point 0FF4 E5 82 MOV A,DPL ; get high 0FF6 70 03 JNZ SBKPT30 ; not zero, set break point 0FF8 02 1011 JMP SBKPT40 ; this one is zero, try next 0FFB AC 83 SBKPT30 MOV R4,DPH ; put address high to R4 0FFD AD 82 MOV R5,DPL ; put address low to R5 0FFF 12 1012 CALL GBDADP ; get break point data at DPTR 1002 90 EF26 MOV DPTR,#BKS1A ; pt to break storage 0 address 1005 12 101B CALL SBDADP ; save break point data at DPTR 1008 90 EF03 MOV DPTR,#ARGV1 ; pt to 1th argument 100B 12 1626 CALL DPATDP ; move to DPTR 100E 12 106B CALL BPADP ; insert breakpoint at DPTR location 1011 22 SBKPT40 RET ; that's all GBDADP ; get break point data at DPTR 1012 E0 MOVX A,@DPTR ; get data byte 1 1013 F9 MOV R1,A ; save in R1 1014 A3 INC DPTR ; pt to data byte 2 1015 E0 MOVX A,@DPTR ; get data byte 2 1016 FA MOV R2,A ; save in R2 1017 A3 INC DPTR ; pt to data byte 3 1018 E0 MOVX A,@DPTR ; get data byte 3 1019 FB MOV R3,A ; save in R3 101A 22 RET SBDADP ; save break point data at DPTR 101B EC MOV A,R4 ; recover address high from R4 101C F0 MOVX @DPTR,A ; save address high 101D A3 INC DPTR ; pt to address low 101E ED MOV A,R5 ; recover address low from R5 101F F0 MOVX @DPTR,A ; save address low 1020 A3 INC DPTR ; pt to data first 1021 E9 SBDAD10 MOV A,R1 ; recover data 1 from R1 1022 F0 MOVX @DPTR,A ; save it 1023 A3 INC DPTR ; pt to next data 1024 EA MOV A,R2 ; recover data 2 from R2 Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 50 FSUP1.ASM: Function Support Code, part 1 1025 F0 MOVX @DPTR,A ; save it 1026 A3 INC DPTR ; pt to next data 1027 EB MOV A,R3 ; recover data 3 from R3 1028 F0 MOVX @DPTR,A ; save it 1029 22 RET ; that's all CBKPT ; clear break points at addresses in BKS0A and BKS1A 102A 90 EF21 MOV DPTR,#BKS0A ; pt to first storage address 102D 12 1626 CALL DPATDP ; move to DPTR 1030 E5 83 MOV A,DPH ; get high 1032 70 07 JNZ CBKPT10 ; not zero, need to clear BKpoint 1034 E5 82 MOV A,DPL ; get high 1036 70 03 JNZ CBKPT10 ; not zero, need to clear BKpoint 1038 02 104A JMP CBKPT20 ; this one is zero, try next 103B C0 82 CBKPT10 PUSH DPL ; save low 103D C0 83 PUSH DPH ; save high 103F 90 EF23 MOV DPTR,#BKS0D ; pt to first storage data 1042 1112 CALL GBDADP ; get break point data at DPTR 1044 D0 83 POP DPH ; restore high 1046 D0 82 POP DPL ; restore low 1048 1121 CALL SBDAD10 ; save break point data at DPTR 104A 90 EF26 CBKPT20 MOV DPTR,#BKS1A ; pt to first storage address 104D 12 1626 CALL DPATDP ; move to DPTR 1050 E5 83 MOV A,DPH ; get high 1052 70 07 JNZ CBKPT30 ; not zero, need to clear BKpoint 1054 E5 82 MOV A,DPL ; get high 1056 70 03 JNZ CBKPT30 ; not zero, need to clear BKpoint 1058 02 106A JMP CBKPT40 ; this one is zero, try next 105B C0 82 CBKPT30 PUSH DPL ; save low 105D C0 83 PUSH DPH ; save high 105F 90 EF28 MOV DPTR,#BKS1D ; pt to first storage data 1062 1112 CALL GBDADP ; get break point data at DPTR 1064 D0 83 POP DPH ; restore high 1066 D0 82 POP DPL ; restore low 1068 1121 CALL SBDAD10 ; save break point data at DPTR 106A 22 CBKPT40 RET ; that's all BPADP ; insert breakpoint at DPTR location 106B 74 12 MOV A,#012H ; get call address 106D F0 MOVX @DPTR,A ; save to memory 106E A3 INC DPTR ; pt ot next memory 106F 74 09 MOV A,#HIGH RBKPNT ; get call address high 1071 F0 MOVX @DPTR,A ; save to memory 1072 A3 INC DPTR ; pt ot next memory 1073 74 12 MOV A,#LOW RBKPNT ; get call address low 1075 F0 MOVX @DPTR,A ; save to memory 1076 22 RET ; that's all $RESETLN $SETLN(FSUP2.ASM); %INCLUDE FSUP2.ASM ; function support 2 $SUBTITLE(FSUP2.ASM: Function Support Code, part 2) Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 51 FSUP2.ASM: Function Support Code, part 2 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; function support code ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; RLINE ; get line, put in memory, offset in ARG0 ; ret w/CY = 1 if error, ACC = 0 if length zero 1077 12 13E8 CALL GETCHAR ; get a char 107A B4 3A FA CJNE A,#':',RLINE ; loop if not colon 107D 7B 00 MOV R3,#0 ; clear CKSUM accumulator 107F 12 11B4 CALL GASCBY ; get length 1082 FC MOV R4,A ; save length at R4 1083 70 20 JNZ RLINE20 ; jump if not zero (not EOF) 1085 7A 04 MOV R2,#4 ; skip addr, type, and check 1087 12 11B4 RLINE10 CALL GASCBY ; get a pair 108A DA FB DJNZ R2,RLINE10 ; loop 108C 7D 20 RLINE13 MOV R5,#020H ; get max outside count 108E 7E 00 RLINE15 MOV R6,#00H ; get max inside count 1090 DE FE DJNZ R6,$ ; delay during inside loop 1092 DD FA DJNZ R5,RLINE15 ; delay during outside loop 1094 12 13DA CALL RBRDY ; any data waiting? 1097 30 D7 05 JNB CY,RLINE17 ; jump if no 109A 12 13E8 CALL GETCHAR ; clear any garbage characters 109D 80 ED JMP RLINE13 ; do it until no data waiting 109F 12 1437 RLINE17 CALL CRLF ; newline 10A2 E4 CLR A ; ACC=0 for end of file 10A3 C3 CLR C ; clear CY for no error 10A4 22 RET ; thats all 10A5 12 11B4 RLINE20 CALL GASCBY ; get address high 10A8 FD MOV R5,A ; save at R5 10A9 12 11B4 CALL GASCBY ; get address low to A 10AC 90 EF01 MOV DPTR,#ARGV0 ; pt to offset location 10AF 12 1626 CALL DPATDP ; move offset value to DPTR 10B2 25 82 ADD A,DPL ; add offset low to address low 10B4 F5 82 MOV DPL,A ; and restore in DPL 10B6 ED MOV A,R5 ; move address high to A 10B7 35 83 ADDC A,DPH ; add offset high to address high 10B9 F5 83 MOV DPH,A ; and restore in DPH 10BB 12 11B4 CALL GASCBY ; get type and drop it 10BE 12 11B4 RLINE30 CALL GASCBY ; get data byte 10C1 F0 MOVX @DPTR,A ; save it to external RAM 10C2 A3 INC DPTR ; point to next 10C3 DC F9 DJNZ R4,RLINE30 ; loop till record done 10C5 12 11B4 CALL GASCBY ; get checksum 10C8 EB MOV A,R3 ; recover checksum accumulator 10C9 60 09 JZ RLINE40 ; jump if no checksum error 10CB 74 78 MOV A,#'x' ; get record bad mark 10CD 12 13F2 CALL PUTCHAR ; put to terminal 10D0 74 01 MOV A,#1 ; mark not end of file 10D2 D3 SETB C ; mark error 10D3 22 RET ; that's all 10D4 74 2E RLINE40 MOV A,#'.' ; get record OK mark 10D6 12 13F2 CALL PUTCHAR ; put to terminal Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 52 FSUP2.ASM: Function Support Code, part 2 10D9 74 01 MOV A,#1 ; mark not end of file 10DB C3 CLR C ; mark NO error 10DC 22 RET ; that's all VLINE ; get line, verify with memory, offset in ARG0 ; print address and data for each byte in error ; ret w/CY = 1 if error, ACC = 0 if length zero 10DD 12 13E8 CALL GETCHAR ; get a char 10E0 B4 3A FA CJNE A,#':',VLINE ; loop if not colon 10E3 7B 00 MOV R3,#0 ; clear CKSUM accumulator 10E5 12 11B4 CALL GASCBY ; get length 10E8 FC MOV R4,A ; save length at R4 10E9 70 20 JNZ VLINE20 ; jump if not zero (not EOF) 10EB 7A 04 MOV R2,#4 ; skip addr, type, and check 10ED 12 11B4 VLINE10 CALL GASCBY ; get a pair 10F0 DA FB DJNZ R2,VLINE10 ; loop 10F2 7D 20 VLINE13 MOV R5,#020H ; get max outside count 10F4 7E 00 VLINE15 MOV R6,#00H ; get max inside count 10F6 DE FE DJNZ R6,$ ; delay during inside loop 10F8 DD FA DJNZ R5,VLINE15 ; delay during outside loop 10FA 12 13DA CALL RBRDY ; any data waiting? 10FD 30 D7 05 JNB CY,VLINE17 ; jump if no 1100 12 13E8 CALL GETCHAR ; clear any garbage characters 1103 80 ED JMP VLINE13 ; do it until no data waiting 1105 12 1437 VLINE17 CALL CRLF ; newline 1108 E4 CLR A ; ACC=0 for end of file 1109 C3 CLR C ; clear CY for no error 110A 22 RET ; thats all 110B 12 11B4 VLINE20 CALL GASCBY ; get address high 110E FD MOV R5,A ; save at R5 110F 12 11B4 CALL GASCBY ; get address low to A 1112 90 EF01 MOV DPTR,#ARGV0 ; pt to offset location 1115 12 1626 CALL DPATDP ; move offset value to DPTR 1118 25 82 ADD A,DPL ; add offset low to address low 111A F5 82 MOV DPL,A ; and restore in DPL 111C ED MOV A,R5 ; move address high to A 111D 35 83 ADDC A,DPH ; add offset high to address high 111F F5 83 MOV DPH,A ; and restore in DPH 1121 12 11B4 CALL GASCBY ; get type and drop it 1124 12 11B4 VLINE30 CALL GASCBY ; get data byte 1127 F5 F0 MOV B,A ; save in B 1129 E0 MOVX A,@DPTR ; get data from memory 112A 65 F0 XRL A,B ; compare 112C 60 03 JZ VLINE32 ; jump if good 112E 12 114C CALL PVERR ; print verify errors 1131 A3 VLINE32 INC DPTR ; point to next 1132 DC F0 DJNZ R4,VLINE30 ; loop till record done 1134 12 11B4 CALL GASCBY ; get checksum 1137 EB MOV A,R3 ; recover checksum accumulator 1138 60 09 JZ VLINE40 ; jump if no checksum error 113A 74 78 MOV A,#'x' ; get record bad mark 113C 12 13F2 CALL PUTCHAR ; put to terminal 113F 74 01 MOV A,#1 ; mark not end of file Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 53 FSUP2.ASM: Function Support Code, part 2 1141 D3 SETB C ; mark error 1142 22 RET ; that's all 1143 74 2E VLINE40 MOV A,#'.' ; get record OK mark 1145 12 13F2 CALL PUTCHAR ; put to terminal 1148 74 01 MOV A,#1 ; mark not end of file 114A C3 CLR C ; mark NO error 114B 22 RET ; that's all PVERR ; print verify errors 114C C0 82 PUSH DPL ; save DPL on stack 114E C0 83 PUSH DPH ; save DPH 1150 90 118A MOV DPTR,#PVERR50 ; get opening error msg 1153 12 1491 CALL CPUTS ; print to console 1156 D0 83 POP DPH ; get DPH from stack 1158 D0 82 POP DPL ; get DPl from stack 115A C0 82 PUSH DPL ; save DPL on stack 115C C0 83 PUSH DPH ; save DPH on stack 115E E5 83 MOV A,DPH ; get DPH to A 1160 12 15D7 CALL PHXBYTE ; print as HEX to console 1163 E5 82 MOV A,DPL ; get DPL to A 1165 12 15D7 CALL PHXBYTE ; print as HEX to console 1168 90 119E MOV DPTR,#PVERR55 ; get as found message 116B 12 1491 CALL CPUTS ; print to console 116E D0 83 POP DPH ; get DPH from stack 1170 D0 82 POP DPL ; get DPl from stack 1172 C0 82 PUSH DPL ; save DPL on stack 1174 C0 83 PUSH DPH ; save DPH on stack 1176 E0 MOVX A,@DPTR ; get value as found from memory 1177 12 15D7 CALL PHXBYTE ; print as hex to console 117A 90 11A7 MOV DPTR,#PVERR60 ; get expected message 117D 12 1491 CALL CPUTS ; print to console 1180 E5 F0 MOV A,B ; get expected data 1182 12 15D7 CALL PHXBYTE ; print as hex to console 1185 D0 83 POP DPH ; get DPH from stack 1187 D0 82 POP DPL ; get DPL from stack 1189 22 RET 118A 0D 0A 45 72 PVERR50 DB ACR,ALF,'Error at address ',0 118E 72 6F 72 20 1192 61 74 20 61 1196 64 64 72 65 119A 73 73 20 00 119E 2C 20 46 6F PVERR55 DB ', Found=',0 11A2 75 6E 64 3D 11A6 00 11A7 2C 20 45 78 PVERR60 DB ', Expected= ',0 11AB 70 65 63 74 11AF 65 64 3D 20 11B3 00 GASCBY ; get ascii byte and add to checksum 11B4 12 13E8 CALL GETCHAR ; get MSByte 11B7 12 146E CALL MAPUC ; map to upper char 11BA 12 1594 CALL CHARHX ; convert to HX Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 54 FSUP2.ASM: Function Support Code, part 2 11BD C4 SWAP A ; move lower nibble to upper 11BE 54 F0 ANL A,#0F0H ; mask off lower bits 11C0 F5 F0 MOV B,A ; save in B 11C2 12 13E8 CALL GETCHAR ; get LSByte 11C5 12 146E CALL MAPUC ; map to upper char 11C8 12 1594 CALL CHARHX ; convert to HX 11CB 54 0F ANL A,#00FH ; mask off upper bits 11CD 45 F0 ORL A,B ; or them together 11CF F5 F0 MOV B,A ; save it in B 11D1 2B ADD A,R3 ; add to checksum 11D2 FB MOV R3,A ; restore in checksum 11D3 E5 F0 MOV A,B ; restore data to A 11D5 22 RET XLOAD ; examine load procedure for data in image format (and Rx format) 11D6 E0 MOVX A,@DPTR ; get data 11D7 12 15D7 CALL PHXBYTE ; print data 11DA 12 161C CALL SPACE1 ; space 11DD 12 158B CALL GARGNSP ; user input, no leading spaces 11E0 60 02 JZ XLOAD10 ; jump if none 11E2 EC MOV A,R4 ; put data in A 11E3 F0 MOVX @DPTR,A ; save in memory 11E4 12 1437 XLOAD10 CALL CRLF ; new line 11E7 22 RET ; that's all XLOAD20 ; do for word values 11E8 C0 82 PUSH DPL ; save DPL 11EA C0 83 PUSH DPH ; and DPH 11EC E0 MOVX A,@DPTR ; get high byte 11ED 12 15D7 CALL PHXBYTE ; print data 11F0 A3 INC DPTR ; get low byte 11F1 E0 MOVX A,@DPTR ; get high byte 11F2 12 15D7 CALL PHXBYTE ; print data 11F5 12 161C CALL SPACE1 ; space 11F8 12 158B CALL GARGNSP ; user input, no leading spaces 11FB D0 83 POP DPH ; restore DPH 11FD D0 82 POP DPL ; restore DPL 11FF 60 05 JZ XLOAD30 ; jump if none 1201 EB MOV A,R3 ; put data high in A 1202 F0 MOVX @DPTR,A ; save in memory 1203 A3 INC DPTR ; pt to next 1204 EC MOV A,R4 ; put data low in A 1205 F0 MOVX @DPTR,A ; save in memory 1206 12 1437 XLOAD30 CALL CRLF ; new line 1209 22 RET ; that's all 120A E6 XLOAD40 MOV A,@R0 ; get data 120B 12 15D7 CALL PHXBYTE ; print data 120E 12 161C CALL SPACE1 ; space 1211 12 158B CALL GARGNSP ; user input, no leading spaces 1214 60 02 JZ XLOAD50 ; jump if none 1216 EC MOV A,R4 ; put data in A 1217 F6 MOV @R0,A ; save in memory 1218 12 1437 XLOAD50 CALL CRLF ; new line 121B 22 RET ; that's all Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 55 FSUP2.ASM: Function Support Code, part 2 REGNX ; register N examine, external (monitor's) registers 121C 12 1452 CALL GETUCHE ; get an input char with echo 121F 12 1437 CALL CRLF ; newline 1222 B4 30 17 CJNE A,#'0',REGNX05 ; jump if not R0 1225 C0 83 REGNX01 PUSH DPH ; save ptr to data 1227 C0 82 PUSH DPL 1229 90 17D3 MOV DPTR,#RR0 ; get R1 reg message 122C 12 1491 CALL CPUTS ; put the string 122F D0 82 POP DPL ; restore reg 1231 D0 83 POP DPH 1233 31D6 CALL XLOAD ; do the examine and load 1235 A3 INC DPTR ; pt to UR1 1236 50 08 JNC REGNX07 ; do next if no CR 1238 12 1437 CALL CRLF ; newline 123B 22 RET 123C A3 REGNX05 INC DPTR ; pt to UR1 123D B4 31 17 CJNE A,#'1',REGNX10 ; jump if not R1 1240 C0 83 REGNX07 PUSH DPH ; save ptr to data 1242 C0 82 PUSH DPL 1244 90 17DB MOV DPTR,#RR1 ; get R1 reg message 1247 12 1491 CALL CPUTS ; put the string 124A D0 82 POP DPL ; restore reg 124C D0 83 POP DPH 124E 31D6 CALL XLOAD ; do the examine and load 1250 A3 INC DPTR ; pt to UR2 1251 50 08 JNC REGNX12 ; do next if no CR 1253 12 1437 CALL CRLF ; newline 1256 22 RET 1257 A3 REGNX10 INC DPTR ; pt to UR2 1258 B4 32 17 CJNE A,#'2',REGNX15 ; jump if not R2 125B C0 83 REGNX12 PUSH DPH ; save ptr to data 125D C0 82 PUSH DPL 125F 90 17E3 MOV DPTR,#RR2 ; get R2 reg message 1262 12 1491 CALL CPUTS ; put the string 1265 D0 82 POP DPL ; restore reg 1267 D0 83 POP DPH 1269 31D6 CALL XLOAD ; do the examine and load 126B A3 INC DPTR ; pt to UR3 126C 50 08 JNC REGNX17 ; do next if no CR 126E 12 1437 CALL CRLF ; newline 1271 22 RET 1272 A3 REGNX15 INC DPTR ; pt to UR3 1273 B4 33 17 CJNE A,#'3',REGNX20 ; jump if not R3 1276 C0 83 REGNX17 PUSH DPH ; save ptr to data 1278 C0 82 PUSH DPL 127A 90 17EB MOV DPTR,#RR3 ; get R3 reg message 127D 12 1491 CALL CPUTS ; put the string 1280 D0 82 POP DPL ; restore reg 1282 D0 83 POP DPH 1284 31D6 CALL XLOAD ; do the examine and load 1286 A3 INC DPTR ; pt to UR4 1287 50 08 JNC REGNX22 ; do next if no CR Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 56 FSUP2.ASM: Function Support Code, part 2 1289 12 1437 CALL CRLF ; newline 128C 22 RET 128D A3 REGNX20 INC DPTR ; pt to UR4 128E B4 34 17 CJNE A,#'4',REGNX25 ; jump if not R4 1291 C0 83 REGNX22 PUSH DPH ; save ptr to data 1293 C0 82 PUSH DPL 1295 90 17F3 MOV DPTR,#RR4 ; get R4 reg message 1298 12 1491 CALL CPUTS ; put the string 129B D0 82 POP DPL ; restore reg 129D D0 83 POP DPH 129F 31D6 CALL XLOAD ; do the examine and load 12A1 A3 INC DPTR ; pt to UR5 12A2 50 08 JNC REGNX27 ; do next if no CR 12A4 12 1437 CALL CRLF ; newline 12A7 22 RET 12A8 A3 REGNX25 INC DPTR ; pt to UR5 12A9 B4 35 17 CJNE A,#'5',REGNX30 ; jump if not R5 12AC C0 83 REGNX27 PUSH DPH ; save ptr to data 12AE C0 82 PUSH DPL 12B0 90 17FB MOV DPTR,#RR5 ; get R5 reg message 12B3 12 1491 CALL CPUTS ; put the string 12B6 D0 82 POP DPL ; restore reg 12B8 D0 83 POP DPH 12BA 31D6 CALL XLOAD ; do the examine and load 12BC A3 INC DPTR ; pt to UR6 12BD 50 08 JNC REGNX32 ; do next if no CR 12BF 12 1437 CALL CRLF ; newline 12C2 22 RET 12C3 A3 REGNX30 INC DPTR ; pt to UR6 12C4 B4 36 17 CJNE A,#'6',REGNX35 ; jump if not R6 12C7 C0 83 REGNX32 PUSH DPH ; save ptr to data 12C9 C0 82 PUSH DPL 12CB 90 1803 MOV DPTR,#RR6 ; get R6 reg message 12CE 12 1491 CALL CPUTS ; put the string 12D1 D0 82 POP DPL ; restore reg 12D3 D0 83 POP DPH 12D5 31D6 CALL XLOAD ; do the examine and load 12D7 A3 INC DPTR ; pt to UR7 12D8 50 08 JNC REGNX37 ; do next if no CR 12DA 12 1437 CALL CRLF ; newline 12DD 22 RET 12DE A3 REGNX35 INC DPTR ; pt to UR7 12DF B4 37 16 CJNE A,#'7',REGNX40 ; jump if not R7 12E2 C0 83 REGNX37 PUSH DPH ; save ptr to data 12E4 C0 82 PUSH DPL 12E6 90 180B MOV DPTR,#RR7 ; get R7 reg message 12E9 12 1491 CALL CPUTS ; put the string 12EC D0 82 POP DPL ; restore reg 12EE D0 83 POP DPH 12F0 31D6 CALL XLOAD ; do the examine and load 12F2 50 07 JNC REGNX42 ; do next if no CR 12F4 12 1437 CALL CRLF ; newline 12F7 22 RET ; that's all Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 57 FSUP2.ASM: Function Support Code, part 2 12F8 02 1400 REGNX40 JMP SYSERR ; no such register, show error 12FB 22 REGNX42 RET ; that's all REGNX50 ; register N examine, internal registers 12FC 12 1452 CALL GETUCHE ; get an input char with echo 12FF 12 1437 CALL CRLF ; newline 1302 B4 30 0F CJNE A,#'0',REGNX55 ; jump if not R0 1305 90 17D3 REGNX51 MOV DPTR,#RR0 ; get R0 reg message 1308 12 1491 CALL CPUTS ; put the string 130B 510A CALL XLOAD40 ; do the examine and load 130D 08 INC R0 ; pt to R1 130E 50 08 JNC REGNX57 ; do next if no CR 1310 12 1437 CALL CRLF ; newline 1313 22 RET 1314 08 REGNX55 INC R0 ; pt to R1 1315 B4 31 0F CJNE A,#'1',REGNX60 ; jump if not R1 1318 90 17DB REGNX57 MOV DPTR,#RR1 ; get R1 reg message 131B 12 1491 CALL CPUTS ; put the string 131E 510A CALL XLOAD40 ; do the examine and load 1320 08 INC R0 ; pt to R2 1321 50 08 JNC REGNX62 ; do next if no CR 1323 12 1437 CALL CRLF ; newline 1326 22 RET 1327 08 REGNX60 INC R0 ; pt to R2 1328 B4 32 0F CJNE A,#'2',REGNX65 ; jump if not R2 132B 90 17E3 REGNX62 MOV DPTR,#RR2 ; get R2 reg message 132E 12 1491 CALL CPUTS ; put the string 1331 510A CALL XLOAD40 ; do the examine and load 1333 08 INC R0 ; pt to R3 1334 50 08 JNC REGNX67 ; do next if no CR 1336 12 1437 CALL CRLF ; newline 1339 22 RET 133A 08 REGNX65 INC R0 ; pt to R2 133B B4 33 0F CJNE A,#'3',REGNX70 ; jump if not R3 133E 90 17EB REGNX67 MOV DPTR,#RR3 ; get R3 reg message 1341 12 1491 CALL CPUTS ; put the string 1344 510A CALL XLOAD40 ; do the examine and load 1346 08 INC R0 ; pt to R4 1347 50 08 JNC REGNX72 ; do next if no CR 1349 12 1437 CALL CRLF ; newline 134C 22 RET 134D 08 REGNX70 INC R0 ; pt to R2 134E B4 34 0F CJNE A,#'4',REGNX75 ; jump if not R4 1351 90 17F3 REGNX72 MOV DPTR,#RR4 ; get R4 reg message 1354 12 1491 CALL CPUTS ; put the string 1357 510A CALL XLOAD40 ; do the examine and load 1359 08 INC R0 ; pt to R5 135A 50 08 JNC REGNX77 ; do next if no CR 135C 12 1437 CALL CRLF ; newline 135F 22 RET 1360 08 REGNX75 INC R0 ; pt to R2 1361 B4 35 0F CJNE A,#'5',REGNX80 ; jump if not R5 1364 90 17FB REGNX77 MOV DPTR,#RR5 ; get R5 reg message 1367 12 1491 CALL CPUTS ; put the string Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 58 FSUP2.ASM: Function Support Code, part 2 136A 510A CALL XLOAD40 ; do the examine and load 136C 08 INC R0 ; pt to R2 136D 50 08 JNC REGNX82 ; do next if no CR 136F 12 1437 CALL CRLF ; newline 1372 22 RET 1373 08 REGNX80 INC R0 ; pt to R6 1374 B4 36 0F CJNE A,#'6',REGNX85 ; jump if not R6 1377 90 1803 REGNX82 MOV DPTR,#RR6 ; get R6 reg message 137A 12 1491 CALL CPUTS ; put the string 137D 510A CALL XLOAD40 ; do the examine and load 137F 08 INC R0 ; pt to R2 1380 50 08 JNC REGNX87 ; do next if no CR 1382 12 1437 CALL CRLF ; newline 1385 22 RET 1386 08 REGNX85 INC R0 ; pt to R7 1387 B4 37 0E CJNE A,#'7',REGNX90 ; jump if not R7 138A 90 180B REGNX87 MOV DPTR,#RR7 ; get R7 reg message 138D 12 1491 CALL CPUTS ; put the string 1390 510A CALL XLOAD40 ; do the examine and load 1392 50 07 JNC REGNX92 ; do next if no CR 1394 12 1437 CALL CRLF ; newline 1397 22 RET ; that's all 1398 02 1400 REGNX90 JMP SYSERR ; no such register, jump to error 139B 22 REGNX92 RET ; that's all PSFR ; put data at A to SFR pointed to by R0 139C C0 E0 PUSH ACC ; save ACC on stack 139E 90 EF2B MOV DPTR,#SFRPGM ; SFR program memory location 13A1 74 F5 MOV A,#0F5H ; get MOV direct,A opcode 13A3 F0 MOVX @DPTR,A ; move to memory 13A4 A3 INC DPTR ; pt to next location 13A5 E8 MOV A,R0 ; get address 13A6 F0 MOVX @DPTR,A ; move to memory 13A7 A3 INC DPTR ; pt to next location 13A8 74 22 MOV A,#022H ; get RET opcode 13AA F0 MOVX @DPTR,A ; move to memory 13AB D0 E0 POP ACC ; restore ACC 13AD 02 EF2B JMP SFRPGM ; jump to routine, return from there GSFR ; get data from SFR pointed to by R0, return data in A 13B0 C0 82 PUSH DPL ; save DPTR 13B2 C0 83 PUSH DPH 13B4 90 EF2B MOV DPTR,#SFRPGM ; SFR program memory 13B7 74 E5 MOV A,#0E5H ; get MOV A,direct opcode 13B9 F0 MOVX @DPTR,A ; move to memory 13BA A3 INC DPTR ; pt to next location 13BB E8 MOV A,R0 ; get address 13BC F0 MOVX @DPTR,A ; move to memory 13BD A3 INC DPTR ; pt to next location 13BE 74 22 MOV A,#022H ; get RET opcode 13C0 F0 MOVX @DPTR,A ; move to memory 13C1 D0 83 POP DPH ; restore DPTR 13C3 D0 82 POP DPL Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 59 FSUP2.ASM: Function Support Code, part 2 13C5 02 EF2B JMP SFRPGM ; jump to routine, return from there $RESETLN $SETLN(IO.ASM); %INCLUDE IO.ASM ; i/o functions $SUBTITLE(IO.ASM: Serial I/O) Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 60 IO.ASM: Serial I/O ; %IF UARTINT ; if internal uart ; %IF CPU52 ; if internal 8052 UART ;;;;;;;; UART internal to 8052 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; INITSP ; now init the serial port 13C8 75 98 50 MOV SCON,#050H ; mode 1, 8 bits 13CB 43 87 80 ORL PCON,#080H ; set SMOD = 1 13CE 75 C8 34 MOV T2CON,#034H ; T2 baud gen ; MOV RCAP2L,#0F7H ; reload value 38400 @ 11.0592 MHz ; MOV RCAP2L,#0EEH ; reload value 19200 @ 11.0592 MHz ; MOV RCAP2L,#0DCH ; reload value 9600 @ 11.0592 MHz ; MOV RCAP2L,#0B8H ; reload value 4800 @ 11.0592 MHz ; MOV RCAP2L,#070H ; reload value 2400 @ 11.0592 MHz 13D1 75 CB FF MOV RCAP2H,#0FFH ; FF for rates >= 2400 13D4 75 CA EE MOV RCAP2L,#0EEH ; reload value 19200 @ 11.0592 MHz 13D7 D2 99 SETB TI ; enable transmitter 13D9 22 RET ; %ELSE ; ;;;;;;;;; UART internal to 8051 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; ;INITSP ; now init the serial port ; ; MOV SCON,#050H ; mode 1, 8 bits ; ORL PCON,#080H ; set SMOD = 1 ; MOV TMOD,#066H ; mode 2, auto reload ; ;;;;;; MOV TH1,#-43 ; reload value 1200 @ 10 MHz ;;;;;; MOV TH1,#-27 ; reload value 1200 @ 6.144 MHz ;;;;;; MOV TH1,#-2 ; reload value 9600 @ 3.6864 MHz ;;;;;; MOV TH1,#-48 ; reload value 1200 @ 11.0592 MHz ;;;;;; MOV TH1,#-24 ; reload value 2400 @ 11.0592 MHz ;;;;;; MOV TH1,#-12 ; reload value 4800 @ 11.0592 MHz ;;;;;; MOV TH1,#-6 ; reload value 9600 @ 11.0592 MHz ;;;;;; MOV TH1,#-3 ; reload value 19200 @ 11.0592 MHz ; ; MOV TH1,#-48 ; reload value 1200 @ 11.0592 MHz ; SETB TR1 ; enable timer ; SETB TI ; enable transmitter ; RET ; ; %ENDIF RBRDY ; CY=1 if char is waiting in receive buffer 13DA C3 CLR C ; clear CY just in case 13DB 20 98 01 JB RI,RBRDY10 ; jump if RX data waiting Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 61 IO.ASM: Serial I/O 13DE 22 RET ; else, just return with CY clear 13DF D3 RBRDY10 SETB C ; mark data ready 13E0 22 RET ; that's all TBRDY ; CY=1 if TX buffer is ready for next char 13E1 C3 CLR C ; clear CY just in case 13E2 20 99 01 JB TI,TBRDY10 ; jump if buffer ready for data 13E5 22 RET ; else, just return with CY clear 13E6 D3 TBRDY10 SETB C ; mark data ready 13E7 22 RET ; that's all GETCHAR ; get char from console 13E8 30 98 FD JNB RI,$ ; loop if RX without data 13EB C2 98 CLR RI ; mark it clear 13ED E5 99 MOV A,SBUF ; get data from port 13EF 54 7F ANL A,#7FH ; look only at 7 bits 13F1 22 RET ; that's all PUTCHAR ; put char to console 13F2 30 99 FD JNB TI,$ ; loop if TX not idle 13F5 C2 99 CLR TI ; mark it clear 13F7 C0 E0 PUSH ACC ; save data 13F9 44 80 ORL A,#080H ; ensure MSB is high 13FB F5 99 MOV SBUF,A ; save data to port 13FD D0 E0 POP ACC ; restore data 13FF 22 RET ; that's all ; %ELSE ; else assume 8250 at 0xF100 ; ; ;;;;;;;;; UART using external 8250 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; ;INITSP ; init the 8250 serial port ; MOV DPTR,#ACEBAS+3 ; pt to line control register ; MOV A,#080H ; cmd to access baud rate ; MOVX @DPTR,A ; open divisor latch ; MOV DPTR,#ACEBAS+0 ; pt to lsbyte baud rate ; ;;;; pick only one of the following values ; MOV A,#6 ; low BRATE for 19200 @ 11.0592 MHz ;;;;; MOV A,#12 ; low BRATE for 9600 @ 11.0592 MHz ;;;;; MOV A,#48 ; low BRATE for 2400 @ 11.0592 MHz ;;;;; MOV A,#96 ; low BRATE for 1200 @ 11.0592 MHz ; ;;;;; MOV A,#2 ; low BRATE for 19200 @ 3.6864 MHz ;;;;; MOV A,#4 ; low BRATE for 9600 @ 3.6864 MHz ;;;;; MOV A,#16 ; low BRATE for 2400 @ 3.6864 MHz ;;;;; MOV A,#32 ; low BRATE for 1200 @ 3.6864 MHz ; ; MOVX @DPTR,A ; move to port ; INC DPTR ; pt to msbyte baud rate ; MOV A,#0 ; get baud rate value high ; MOVX @DPTR,A ; move to port Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 62 IO.ASM: Serial I/O ; INC DPTR ; tp to int reg ; INC DPTR ; pt to line control reg ; MOV A,#003H ; 8 bits, 1 stp, no parity ; MOVX @DPTR,A ; move to port ; RET ; ;GETCHAR ; console input ; PUSH DPL ; save DPTR on stack ; PUSH DPH ; MOV DPTR,#ACEBAS+5 ; pt to status register ;GETCH10 MOVX A,@DPTR ; get status ; JNB ACC.0,GETCH10 ; loop until data is waiting ; MOV DPTR,#ACEBAS+0 ; pt to data register ; MOVX A,@DPTR ; get data ; ANL A,#07FH ; only 7 bits ; POP DPH ; POP DPL ; restore DPTR from stack ; RET ; ;GETCHE ; console input with echo ; CALL GETCHAR ; get the char ; CALL PUTCHAR ; put the char ; RET ; ;PUTCHAR ; console output ; PUSH DPL ; save DPTR on stack ; PUSH DPH ; PUSH ACC ; save char on stack ; MOV DPTR,#ACEBAS+5 ; pt to status register ;PUTCH10 MOVX A,@DPTR ; get status ; JNB ACC.5,PUTCH10 ; loop until data is waiting ; POP ACC ; get data from stack ; MOV DPTR,#ACEBAS+0 ; pt to data register ; MOVX @DPTR,A ; get data ; POP DPH ; POP DPL ; restore DPTR from stack ; RET ; ;RBRDY ; if char waiting return CY == 1 ; PUSH DPL ; save DPTR on stack ; PUSH DPH ; MOV DPTR,#ACEBAS+5 ; pt to status register ; MOVX A,@DPTR ; get status ; MOV C,ACC.0 ; set C to 1 if data waiting ; POP DPH ; POP DPL ; restore DPTR from stack ; RET ; ;TBRDY ; ret CY = 1 if transmit buffer is ready for data ; PUSH DPL ; save DPTR on stack ; PUSH DPH ; MOV DPTR,#ACEBAS+5 ; pt to status register ; MOVX A,@DPTR ; get status Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 63 IO.ASM: Serial I/O ; MOV C,ACC.5 ; set C to 1 if tx buffer available ; POP DPH ; POP DPL ; restore DPTR from stack ; RET ; ; %ENDIF $RESETLN $SETLN(MISC.ASM); %INCLUDE MISC.ASM ; misc support functions $SUBTITLE(MISC.ASM: Misc Code) Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 64 MISC.ASM: Misc Code ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; misc code ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; SYSERR ; print system error message and start all over ; first, load the stack pointer depending on IDM size 1400 78 E0 MOV R0,#STKHI ; try for high stack 1402 E6 MOV A,@R0 ; get a byte 1403 FB MOV R3,A ; save data in R3 1404 F4 CPL A ; complement it 1405 F6 MOV @R0,A ; put back to IDM 1406 00 NOP ; kill some time 1407 00 NOP ; to ensure that the bus 1408 00 NOP ; has fully settled 1409 E6 MOV A,@R0 ; get data from RAM, if any 140A F4 CPL A ; restore to original 140B 6B XRL A,R3 ; see if same 140C 70 06 JNZ SYSER10 ; jump if not the same 140E 75 81 E0 MOV SP,#STKHI ; go with a high stack value 1411 02 1417 JMP SYSER20 ; skip the alternate load 1414 75 81 60 SYSER10 MOV SP,#STKLOW ; default to low stack value 1417 90 16F7 SYSER20 MOV DPTR,#ERRMSG ; point to error message 141A 12 1491 CALL CPUTS ; print the message to console 141D 12 1437 CALL CRLF ; one new line 1420 12 1437 CALL CRLF ; and one more 1423 02 00E8 JMP MAIN ; start all over SIGNON ; output the sign on message 1426 90 166A MOV DPTR,#SIGNMSG ; get the text index 1429 12 1491 CALL CPUTS ; print the message to console 142C 12 149B CALL PCKSUM ; print code space checksum 142F 22 RET PROMPT ; output the system prompt 1430 90 16F0 MOV DPTR,#PMTMSG ; get the text index 1433 12 1491 CALL CPUTS ; print the message to console 1436 22 RET CRLF ; output a CR/LF to the console 1437 C0 E0 PUSH ACC ; save ACC on stack 1439 74 0D MOV A,#ACR ; get CR 143B 71F2 CALL PUTCHAR ; put to console 143D 74 0A MOV A,#ALF ; get LF 143F 71F2 CALL PUTCHAR ; put to console 1441 D0 E0 POP ACC ; restore ACC from stack 1443 22 RET CR ; output a CR only to the console 1444 C0 E0 PUSH ACC ; save ACC on stack 1446 74 0D MOV A,#ACR ; get CR 1448 71F2 CALL PUTCHAR ; put to console 144A D0 E0 POP ACC ; restore ACC from stack Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 65 MISC.ASM: Misc Code 144C 22 RET GETCE ; get a char and echo 144D 71E8 CALL GETCHAR ; get the char 144F 71F2 CALL PUTCHAR ; echo it 1451 22 RET ; that's all GETUCHE ; get an input char with echo and map to upper case 1452 914D CALL GETCE ; get char and echo 1454 12 1458 CALL MAPC ; map chars as needed 1457 22 RET ; and that's all MAPC ; map chars as required 1458 12 146E CALL MAPUC ; convert to uppercase 145B 12 1462 CALL MAPDLBS ; map delete to back-space 145E 12 1468 CALL MAPLFCR ; map LF to CR 1461 22 RET MAPDLBS ; map DEL to back-space 1462 B4 7F 02 CJNE A,#ADEL,MAPDL10 ; see if delete, jump if not 1465 74 08 MOV A,#ABSP ; else, load BS 1467 22 MAPDL10 RET ; that's all MAPLFCR ; map LF to CR 1468 B4 0A 02 CJNE A,#ALF,MAPLF10 ; see if LF, jump if not 146B 74 0D MOV A,#ACR ; else, load CR 146D 22 MAPLF10 RET MAPUC ; map char to upper case 146E FF MOV R7,A ; save A in R7 146F 24 85 ADD A,#255-'z' ; see if more than 'z' 1471 40 09 JC MUC10 ; jump if so 1473 EF MOV A,R7 ; restore data 1474 24 9F ADD A,#256-'a' ; see if 'a' or more 1476 50 04 JNC MUC10 ; jump if not 1478 EF MOV A,R7 ; restore data 1479 24 E0 ADD A,#'A'-'a' ; convert to upper case 147B 22 RET 147C EF MUC10 MOV A,R7 ; not in 'a' to 'z' so just return old data 147D 22 RET KBESC ; keyboard escape (or period) waiting?, CY=1 if true, CY=0 if not 147E 71DA CALL RBRDY ; see if char is ready 1480 40 01 JC KBPE10 ; jump if so 1482 22 RET ; return if not with CY=0 1483 71E8 KBPE10 CALL GETCHAR ; get the char 1485 B4 1B 02 CJNE A,#AESC,KBPE20 ; ESC? 1488 D3 SETB C ; found!, set flag 1489 22 RET ; that's all 148A B4 2E 02 KBPE20 CJNE A,#'.',KBPE30 ; see if period 148D D3 SETB C ; found!, set flag 148E 22 RET ; that's all 148F C3 KBPE30 CLR C ; data there but not ESC or . Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 66 MISC.ASM: Misc Code 1490 22 RET ; that's all CPUTS ; output string from code space pointed to by DPTR 1491 E4 CLR A ; clear A 1492 93 MOVC A,@A+DPTR ; get a char 1493 70 01 JNZ CPUTS10 ; jump if not null 1495 22 RET ; else, that's all 1496 71F2 CPUTS10 CALL PUTCHAR ; output the char 1498 A3 INC DPTR ; increment the data pointer 1499 80 F6 JMP CPUTS ; loop till done PCKSUM ; print checksum over code space to console 149B 90 0000 MOV DPTR,#PGMBAS ; pt to start of program 149E 7C 00 MOV R4,#0 ; cksum low 14A0 7D 00 MOV R5,#0 ; cksum high 14A2 E4 PCKSU10 CLR A ; clear A 14A3 93 MOVC A,@A+DPTR ; get a byte from code space 14A4 2C ADD A,R4 ; add to check sum 14A5 FC MOV R4,A ; save in R4 14A6 50 01 JNC PCKSU20 ; jump if no carry 14A8 0D INC R5 ; if carry then inc ms byte 14A9 A3 PCKSU20 INC DPTR ; increment the DPTR 14AA E5 83 MOV A,DPH ; get high DPTR 14AC B4 1C F3 CJNE A,#HIGH PGMEND,PCKSU10 ; see if same as high of 14AF E5 82 MOV A,DPL ; if so then check low byte 14B1 B4 CE EE CJNE A,#LOW PGMEND,PCKSU10 ; jump if not same as low 14B4 90 16E3 MOV DPTR,#CKSMSG ; else, done so get pt to checksum msg 14B7 9191 CALL CPUTS ; put it 14B9 ED MOV A,R5 ; get checksum high 14BA 12 15D7 CALL PHXBYTE ; print as hex value 14BD EC MOV A,R4 ; get checksum low 14BE 12 15D7 CALL PHXBYTE ; print as hex value 14C1 9137 CALL CRLF ; end the line 14C3 22 RET POVTG ; power on vector, test and go 14C4 90 EFCA MOV DPTR,#POVMEM ; pt to vector memory 14C7 12 1626 CALL DPATDP ; get value at DPTR to DPTR 14CA E5 82 MOV A,DPL ; move low to A 14CC 45 83 ORL A,DPH ; or with high 14CE 70 01 JNZ POVTG10 ; jump if non zero vector 14D0 22 RET ; else, return POVTG10 ; gets here if unchecked vector wasn't 0000 14D1 E5 82 MOV A,DPL ; move low to A 14D3 55 83 ANL A,DPH ; or with high 14D5 F4 CPL A ; compliment A 14D6 70 01 JNZ POVTG20 ; jump if not all ones vector 14D8 22 RET ; else, return POVTG20 ; gets here if unchecked vector wasn't FFFF ; now calculate checksum 14D9 90 EFCA MOV DPTR,#POVMEM ; pt to vector memory 14DC 7A 04 MOV R2,#4 ; want 4 loops 14DE 7B 00 MOV R3,#0 ; clear R3 Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 67 MISC.ASM: Misc Code 14E0 E0 POVTG30 MOVX A,@DPTR ; get value 14E1 A3 INC DPTR ; pt to next 14E2 2B ADD A,R3 ; add value 14E3 FB MOV R3,A ; save value in R3 14E4 DA FA DJNZ R2,POVTG30 ; loop till done 14E6 E0 MOVX A,@DPTR ; get check value 14E7 A3 INC DPTR ; pt to next 14E8 6B XRL A,R3 ; compare with check value 14E9 60 01 JZ POVTG40 ; jump if same 14EB 22 RET ; else, return if no match POVTG40 ; gets here if check value is OK 14EC EB MOV A,R3 ; get calced value 14ED 65 0F XRL A,00FH ; invert low nibble 14EF FA MOV R2,A ; save calced mod checksum in R2 14F0 E0 MOVX A,@DPTR ; get mod check value 14F1 6A XRL A,R2 ; compare with check value 14F2 60 01 JZ POVTG50 ; jump if same 14F4 22 RET ; else, return if no match POVTG50 ; gets here if modified check value is OK 14F5 90 EFCA MOV DPTR,#POVMEM ; pt to vector memory 14F8 E0 MOVX A,@DPTR ; get high value 14F9 FB MOV R3,A ; save in R3 14FA A3 INC DPTR ; pt to next 14FB E0 MOVX A,@DPTR ; get low value 14FC FA MOV R2,A ; save in R2 14FD A3 INC DPTR ; pt to next 14FE E0 MOVX A,@DPTR ; get mod high value 14FF 64 A8 XRL A,#0A8H ; un mod it 1501 6B XRL A,R3 ; compare with high 1502 60 01 JZ POVTG60 ; jump if same 1504 22 RET ; else, return if no match POVTG60 ; gets here if high bytes compare 1505 A3 INC DPTR ; pt to next 1506 E0 MOVX A,@DPTR ; get mod low value 1507 64 58 XRL A,#058H ; un mod it 1509 6A XRL A,R2 ; compare with low 150A 60 01 JZ POVTG70 ; jump if same 150C 22 RET ; else, return if no match POVTG70 ; it's a real vector, now do some loops while checking for ; keyboard ESC in case the user want's to break in ; and ignore power on vector 150D 7A FF MOV R2,#255 ; get big value for outer loop 150F 7B FF POVTG80 MOV R3,#255 ; get big value for inner loop 1511 917E POVTG90 CALL KBESC ; see if escape char 1513 50 01 JNC POVTG95 ; jump if no escape 1515 22 RET ; else, stop now 1516 DB F9 POVTG95 DJNZ R3,POVTG90 ; inner loop 1518 DA F5 DJNZ R2,POVTG80 ; outer loop ; everything checks out, now go to vectored routine 151A 90 EFCA MOV DPTR,#POVMEM ; pt to vector memory 151D 12 1626 CALL DPATDP ; get value at DPTR to DPTR 1520 C0 82 PUSH DPL ; save low address on stack 1522 C0 83 PUSH DPH ; save high address on stack Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 68 MISC.ASM: Misc Code ; now any RET w/o CALL goes to the ; value placed on the stack (i.e., the ; value at the first two bytes of ; VECMEM) 1524 22 RET ; go do to vector routine ; if this routine doesn't change the ; stack and does a RET w/o CALL, then ; control will return to the address ; after the call to POVTG CARG ; collect up to 8 arguments 1525 12 15B9 CALL ZARG ; zero arg memory 1528 7D 00 MOV R5,#0 ; clear R5, the arg counter 152A 90 EF01 MOV DPTR,#ARGV0 ; pt to first argument 152D 12 154F CALL GARG ; get an arg 1530 60 0F JZ CARG20 ; no data, save arg count and end 1532 7E 08 MOV R6,#8 ; up to 8 arguments 1534 12 1547 CARG10 CALL CARGDAT ; get arg data 1537 20 D7 07 JB CY,CARG20 ; line terminator, save arg ct and end 153A 12 154F CALL GARG ; get an arg 153D 60 02 JZ CARG20 ; no data, save arg count and end 153F DE F3 DJNZ R6,CARG10 ; loop till done 1541 90 EF00 CARG20 MOV DPTR,#ARGC ; pt to arg count 1544 ED MOV A,R5 ; get arg count 1545 F0 MOVX @DPTR,A ; save arg count at ARGC 1546 22 RET ; that's all CARGDAT ; collect argument data 1547 EB MOV A,R3 ; move high data to A 1548 F0 MOVX @DPTR,A ; save high 1549 A3 INC DPTR ; pt to lower 154A EC MOV A,R4 ; move low data to A 154B F0 MOVX @DPTR,A ; save low 154C A3 INC DPTR ; pt to next higher 154D 0D INC R5 ; increment arg counter 154E 22 RET GARG ; get arg to R3 (high) and R4 (low), A=0 if no input, CY = 1 if CR 154F 9152 CALL GETUCHE ; get a char and echo 1551 B4 20 02 CJNE A,#ASP,GARG05 ; jump if char is not space 1554 80 F9 JMP GARG ; do again if space 1556 7B 00 GARG05 MOV R3,#0 ; zero the high value 1558 7C 00 MOV R4,#0 ; zero the low value 155A B4 0D 03 CJNE A,#ACR,GARG10 ; jump if not CR 155D D3 SETB C ; show CR 155E E4 CLR A ; and no input 155F 22 RET ; that's all 1560 12 1594 GARG10 CALL CHARHX ; convert to hex 1563 C0 E0 PUSH ACC ; save hex on stack 1565 30 D7 04 JNB CY,GARG20 ; jump if valid hex 1568 7B 00 MOV R3,#0 ; zero the high value 156A 7C 00 MOV R4,#0 ; zero the low value 156C 7A 04 GARG20 MOV R2,#4 ; want 4 loops Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 69 MISC.ASM: Misc Code 156E C3 GARG30 CLR C ; clear CY 156F EC MOV A,R4 ; get low value 1570 33 RLC A ; rotate low value 1571 FC MOV R4,A ; save low value 1572 EB MOV A,R3 ; get high value 1573 33 RLC A ; rotate high value 1574 FB MOV R3,A ; save high value 1575 DA F7 DJNZ R2,GARG30 ; do till done 1577 D0 E0 POP ACC ; restore hex 1579 4C ORL A,R4 ; or in new hex value into lower 157A FC MOV R4,A ; save in R3 157B 9152 CALL GETUCHE ; get another char 157D B4 20 04 CJNE A,#ASP,GARG40 ; jump if not space 1580 74 01 MOV A,#1 ; ensure that A is non-zero (data valid) 1582 C3 CLR C ; flag that CR did NOT end entry 1583 22 RET ; that's all 1584 B4 0D D9 GARG40 CJNE A,#ACR,GARG10 ; continue if not CR 1587 74 01 MOV A,#1 ; ensure that A is non-zero (data valid) 1589 D3 SETB C ; flag that CR ended entry 158A 22 RET ; that's all GARGNSP ; get arg, don't allow leading spaces 158B 9152 CALL GETUCHE ; get character 158D B4 20 C6 CJNE A,#ASP,GARG05 ; jump if not space 1590 E4 CLR A ; clear A to show no data 1591 C2 D7 CLR CY ; show no CR 1593 22 RET CHARHX ; convert ASCII char to hex, set CY if invalid 1594 FF MOV R7,A ; save data in R7 1595 24 D0 ADD A,#-'0' ; see if '0' or more 1597 EF MOV A,R7 ; restore data 1598 30 D7 18 JNB CY,CHARH20 ; fail if minus 159B 24 C6 ADD A,#-('9'+1) ; see if more than 9 159D EF MOV A,R7 ; restore data 159E 20 D7 03 JB CY,CHARH10 ; fail if so 15A1 94 30 SUBB A,#'0' ; convert to hex (C is already 0) 15A3 22 RET ; that's all (C is still 0) 15A4 24 BF CHARH10 ADD A,#-'A' ; see if A or more 15A6 EF MOV A,R7 ; restore data 15A7 30 D7 09 JNB CY,CHARH20 ; fail if minus 15AA 24 B9 ADD A,#-('F'+1) ; see if more than F 15AC EF MOV A,R7 ; restore data 15AD 20 D7 03 JB CY,CHARH20 ; jump if so 15B0 94 37 SUBB A,#'A'-10 ; convert to hex (C is already 0) 15B2 22 RET ; that's all (C is still 0) 15B3 74 00 CHARH20 MOV A,#0 ; clear A 15B5 D3 SETB C ; mark failure 15B6 8100 JMP SYSERR ; that's a fatal error 15B8 22 RET ; that's all ZARG ; zero the argument memory 15B9 C0 82 PUSH DPL ; save DPTR Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 70 MISC.ASM: Misc Code 15BB C0 83 PUSH DPH 15BD 90 EF00 MOV DPTR,#ARGC ; point to ARG memory 15C0 E4 CLR A ; clear A 15C1 7A 11 MOV R2,#ARGVT-ARGC ; number of bytes to zero 15C3 F0 ZARG10 MOVX @DPTR,A ; move a zero 15C4 A3 INC DPTR ; p++ 15C5 DA FC DJNZ R2,ZARG10 ; do till done 15C7 D0 83 POP DPH ; restore DPTR 15C9 D0 82 POP DPL 15CB 22 RET PDPTR ; print value in DPTR as hex 15CC E5 83 MOV A,DPH ; get high byte 15CE 12 15D7 CALL PHXBYTE ; msb first 15D1 E5 82 MOV A,DPL ; get low byte 15D3 12 15D7 CALL PHXBYTE ; lsb next 15D6 22 RET PHXBYTE ; print A as hex byte 15D7 C0 E0 PUSH ACC ; save the char on stack 15D9 C4 SWAP A ; swap nibbles 15DA 12 15E3 CALL PHXCHAR ; print the MS byte 15DD D0 E0 POP ACC ; restore char LS byte 15DF 12 15E3 CALL PHXCHAR ; print the char 15E2 22 RET PHXCHAR ; print hex character 15E3 54 0F ANL A,#00FH ; only look at LSB 15E5 24 F6 ADD A,#256-10 ; CY set if 10 or more 15E7 20 D7 05 JB CY,PHXCH10 ; jump if 10 or more 15EA 24 3A ADD A,#10+'0' ; adjust and add '0' offset 15EC 02 15F1 JMP PHXCH20 ; skip whats next 15EF 24 41 PHXCH10 ADD A,#'A' ; adjust for alpha char 15F1 71F2 PHXCH20 CALL PUTCHAR ; put the character 15F3 22 RET PBINARY ; print as binary, MSBit first 15F4 7F 08 MOV R7,#8 ; do 8 bits 15F6 33 PBINA10 RLC A ; rotate MSB into CY 15F7 FE MOV R6,A ; save data in R6 15F8 40 05 JC PBINA20 ; jump if carry set 15FA 74 30 MOV A,#'0' ; get a zero 15FC 02 1601 JMP PBINA30 ; jump to print 15FF 74 31 PBINA20 MOV A,#'1' ; get a one 1601 71F2 PBINA30 CALL PUTCHAR ; print it 1603 EE MOV A,R6 ; restore A 1604 DF F0 DJNZ R7,PBINA10 ; loop till done 1606 22 RET PASCHAR ; print a byte as ascii 1607 24 E0 ADD A,#-' ' ; see if space or more 1609 30 D7 05 JNB CY,PASCH10 ; jump if not 160C 24 20 ADD A,#' ' ; restore value Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 71 MISC.ASM: Misc Code 160E 30 E7 02 JNB ACC.7,PASCH20 ; jump if not negative value 1611 74 2E PASCH10 MOV A,#'.' ; use '.' to show non-printable 1613 71F2 PASCH20 CALL PUTCHAR ; put the character 1615 22 RET ; print a space characters 1616 12 161C SPACE3 CALL SPACE1 ; print 3 spaces 1619 12 161C SPACE2 CALL SPACE1 ; print 2 spaces SPACE1 161C 74 20 SPACE MOV A,#ASP ; get space char 161E 71F2 CALL PUTCHAR ; put to console 1620 22 RET ; that's all 1621 74 2C COMMA MOV A,#',' ; get comma char 1623 71F2 CALL PUTCHAR ; put to console 1625 22 RET ; that's all DPATDP ; make DPTR = @DPTR, no other regs affected 1626 C0 E0 PUSH ACC ; save regs on stack 1628 C0 F0 PUSH B 162A E0 MOVX A,@DPTR ; get high value to A 162B F5 F0 MOV B,A ; save at B 162D A3 INC DPTR ; pt to low value 162E E0 MOVX A,@DPTR ; get low value to A 162F F5 82 MOV DPL,A ; move to DPL 1631 E5 F0 MOV A,B ; get high value 1633 F5 83 MOV DPH,A ; move to DPH 1635 D0 F0 POP B ; restore regs 1637 D0 E0 POP ACC 1639 22 RET INCATDP ; increment 16 bit value pointed to by DPTR 163A C0 83 PUSH DPH ; save regs on stack 163C C0 82 PUSH DPL 163E C0 E0 PUSH ACC 1640 A3 INC DPTR ; pt to low byte 1641 E0 MOVX A,@DPTR ; get byte 1642 04 INC A ; increment it 1643 F0 MOVX @DPTR,A ; save it back 1644 70 06 JNZ INCAT10 ; jump if no overflow 1646 12 165C CALL DECDPTR ; pt to high byte 1649 E0 MOVX A,@DPTR ; get byte 164A 04 INC A ; increment it 164B F0 MOVX @DPTR,A ; save it back 164C D0 E0 INCAT10 POP ACC ; restore regs 164E D0 82 POP DPL 1650 D0 83 POP DPH 1652 22 RET DPSWAP ; make DPL = DPTH and DPH = DPL 1653 C0 83 PUSH DPH ; save H to stack 1655 C0 82 PUSH DPL ; save L on stack 1657 D0 83 POP DPH ; pop in reverse order Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 72 MISC.ASM: Misc Code 1659 D0 82 POP DPL 165B 22 RET DECDPTR ; decrement the DPTR 165C C0 E0 PUSH ACC ; save ACC 165E 15 82 DEC DPL ; decrement DPL 1660 E5 82 MOV A,DPL ; get new DPL to A 1662 B4 FF 02 CJNE A,#0FFH,DECDP10 ; jump if not underflow 1665 15 83 DEC DPH ; decrement DPH as well 1667 D0 E0 DECDP10 POP ACC ; restore reg 1669 22 RET ; that's all ;******************************************** ; W800MS -- Wait 800 milli-seconds at 11.0952 MHz clock ; entry: none ; exit: delay accomplished ; mod: R5, R6, R7 ;******************************************** ; ;W800MS MOV R5,#7 ; make 7 laps ;W800M10 CALL W140MS ; delay 140 mS ; DJNZ R5,W800M10 ; loop till done, then fall through ;W140MS ; wait 140 milli-seconds, at 11.0952 MHz clock ; MOV R6,#0 ; do 256 outer loops ;W14MS10 MOV R7,#0 ; do 256 inner loops ;W14MS20 DJNZ R7,W14MS20 ; inner loop (2.17 uS per lap) ; DJNZ R6,W14MS10 ; outer loop (558.81 uS per lap) ; RET ; $RESETLN $SETLN(STRING.ASM); %INCLUDE STRING.ASM ; string definitions $SUBTITLE(STRING.ASM: Strings For Canned Messages) Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 73 STRING.ASM: Strings For Canned Messages ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; Strings ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; 166A FF 11 SIGNMSG DB 0FFH,CTLQ ; sync uart and unstall 166C 0D 0A 0D 0A DB ACR,ALF,ACR,ALF 1670 4D 6F 6E 35 DB 'Mon51 Ver 980121-3.01-11:20 ' 1674 31 20 56 65 1678 72 20 39 38 167C 30 31 32 31 1680 2D 33 2E 30 1684 31 2D 31 31 1688 3A 32 30 20 168C 66 6F 72 20 DB 'for TAPR TUC-52' 1690 54 41 50 52 1694 20 54 55 43 1698 2D 35 32 ; %IF DEV ; if development ; DB ' *** DEVELOPEMENT *** ' ; %ELSE ; must be finished ROMed code ; %ENDIF 169B 0D 0A DB ACR,ALF 169D 43 6F 70 79 DB 'Copyright (c) 1991 -- 1998 Paul Newland, P.E. ' 16A1 72 69 67 68 16A5 74 20 28 63 16A9 29 20 31 39 16AD 39 31 20 2D 16B1 2D 20 31 39 16B5 39 38 20 50 16B9 61 75 6C 20 16BD 4E 65 77 6C 16C1 61 6E 64 2C 16C5 20 50 2E 45 16C9 2E 20 20 16CC 41 6C 6C 20 DB 'All Rights Reserved.' 16D0 52 69 67 68 16D4 74 73 20 52 16D8 65 73 65 72 16DC 76 65 64 2E 16E0 0D 0A 00 DB ACR,ALF,ANULL 16E3 43 68 65 63 CKSMSG DB 'Checksum: 0x',ANULL ; checksum header 16E7 6B 73 75 6D 16EB 3A 20 30 78 16EF 00 ; %IF DEV ; if development ;PMTMSG DB 'dev-> ',ANULL ; %ELSE 16F0 6D 35 31 2D PMTMSG DB 'm51-> ',ANULL 16F4 3E 20 00 ; %ENDIF Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 74 STRING.ASM: Strings For Canned Messages 16F7 07 20 20 20 ERRMSG DB ABELL,' *** ERROR! ',ANULL 16FB 20 2A 2A 2A 16FF 20 45 52 52 1703 4F 52 21 20 1707 00 1708 0D 0A 00 CRLFMSG DB ACR,ALF,ANULL 170B 52 58 20 4F RXOKMSG DB 'RX OK, DATA ENDING AT 0x',ANULL 170F 4B 2C 20 44 1713 41 54 41 20 1717 45 4E 44 49 171B 4E 47 20 41 171F 54 20 30 78 1723 00 ; misc command messages 1724 41 44 52 3A LSTMSG0 DB 'ADR: ',ANULL 1728 20 00 172A 0D 0A LSTMSG1 DB ACR,ALF 172C 20 20 20 20 DB ' ----------------------- SP ----' 1730 20 2D 2D 2D 1734 2D 2D 2D 2D 1738 2D 2D 2D 2D 173C 2D 2D 2D 2D 1740 2D 2D 2D 2D 1744 2D 2D 2D 2D 1748 20 53 50 20 174C 2D 2D 2D 2D 1750 2D 2D 2D 2D DB '-------------------',ACR,ALF 1754 2D 2D 2D 2D 1758 2D 2D 2D 2D 175C 2D 2D 2D 2D 1760 2D 2D 2D 0D 1764 0A 1765 44 41 54 3A DB 'DAT: ',ANULL 1769 20 00 ; messages for register display REGID 176B 20 41 20 DB ' A ' 176E 43 41 46 42 DB 'CAFBBOFP ' 1772 42 4F 46 50 1776 20 1777 50 53 20 52 DB 'PS RB ' 177B 42 20 177D 52 30 20 52 DB 'R0 R1 R2 R3 R4 R5 R6 R7 ' 1781 31 20 52 32 1785 20 52 33 20 1789 52 34 20 52 178D 35 20 52 36 1791 20 52 37 20 1795 40 52 30 20 DB '@R0 @R1 DPTR @DP B SP PCTR @PC +1 +2' 1799 40 52 31 20 Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 75 STRING.ASM: Strings For Canned Messages 179D 44 50 54 52 17A1 20 40 44 50 17A5 20 20 42 20 17A9 53 50 20 50 17AD 43 54 52 20 17B1 40 50 43 20 17B5 2B 31 20 2B 17B9 32 17BA 00 DB ANULL 17BB 20 20 41 43 RACC DB ' ACC: ',ANULL 17BF 43 3A 20 00 17C3 20 20 50 53 RPSW DB ' PSW: ',ANULL 17C7 57 3A 20 00 17CB 20 20 20 52 RRB DB ' RB: ',ANULL 17CF 42 3A 20 00 17D3 20 20 20 52 RR0 DB ' R0: ',ANULL 17D7 30 3A 20 00 17DB 20 20 20 52 RR1 DB ' R1: ',ANULL 17DF 31 3A 20 00 17E3 20 20 20 52 RR2 DB ' R2: ',ANULL 17E7 32 3A 20 00 17EB 20 20 20 52 RR3 DB ' R3: ',ANULL 17EF 33 3A 20 00 17F3 20 20 20 52 RR4 DB ' R4: ',ANULL 17F7 34 3A 20 00 17FB 20 20 20 52 RR5 DB ' R5: ',ANULL 17FF 35 3A 20 00 1803 20 20 20 52 RR6 DB ' R6: ',ANULL 1807 36 3A 20 00 180B 20 20 20 52 RR7 DB ' R7: ',ANULL 180F 37 3A 20 00 1813 20 44 50 54 RDPTR DB ' DPTR: ',ANULL 1817 52 3A 20 00 181B 20 20 20 20 RB DB ' B: ',ANULL 181F 42 3A 20 00 1823 20 20 20 53 RSP DB ' SP: ',ANULL 1827 50 3A 20 00 182B 20 50 43 54 RPC DB ' PCTR: ',ANULL 182F 52 3A 20 00 HLPMSG ; text for help message 1833 0D 0A DB ACR,ALF 1835 0D 0A DB ACR,ALF 1837 0D 0A DB ACR,ALF 1839 4D 35 31 20 DB 'M51 COMMANDS AND HELP FILE' 183D 43 4F 4D 4D 1841 41 4E 44 53 1845 20 41 4E 44 1849 20 48 45 4C 184D 50 20 46 49 1851 4C 45 1853 0D 0A DB ACR,ALF Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 76 STRING.ASM: Strings For Canned Messages 1855 0D 0A DB ACR,ALF 1857 44 69 73 70 DB 'Display PM DP start end' 185B 6C 61 79 20 185F 50 4D 20 20 1863 20 20 20 20 1867 20 20 20 44 186B 50 20 73 74 186F 61 72 74 20 1873 65 6E 64 1876 0D 0A DB ACR,ALF 1878 44 69 73 70 DB 'Display IDM DI start end' 187C 6C 61 79 20 1880 49 44 4D 20 1884 20 20 20 20 1888 20 20 20 44 188C 49 20 73 74 1890 61 72 74 20 1894 65 6E 64 1897 0D 0A DB ACR,ALF 1899 44 69 73 70 DB 'Display XDM DX start end' 189D 6C 61 79 20 18A1 58 44 4D 20 18A5 20 20 20 20 18A9 20 20 20 44 18AD 58 20 73 74 18B1 61 72 74 20 18B5 65 6E 64 18B8 0D 0A DB ACR,ALF 18BA 44 69 73 70 DB 'Display SFR DF start end' 18BE 6C 61 79 20 18C2 53 46 52 20 18C6 20 20 20 20 18CA 20 20 20 44 18CE 46 20 73 74 18D2 61 72 74 20 18D6 65 6E 64 18D9 0D 0A DB ACR,ALF 18DB 53 75 62 73 DB 'Substitue IDM SI addr (space for next, CR to end)' 18DF 74 69 74 75 18E3 65 20 49 44 18E7 4D 20 20 20 18EB 20 20 20 53 18EF 49 20 61 64 18F3 64 72 20 20 18F7 28 73 70 61 18FB 63 65 20 66 18FF 6F 72 20 6E 1903 65 78 74 2C 1907 20 43 52 20 190B 74 6F 20 65 190F 6E 64 29 1912 0D 0A DB ACR,ALF 1914 53 75 62 73 DB 'Substitue XDM SX addr' Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 77 STRING.ASM: Strings For Canned Messages 1918 74 69 74 75 191C 65 20 58 44 1920 4D 20 20 20 1924 20 20 20 53 1928 58 20 61 64 192C 64 72 192E 0D 0A DB ACR,ALF 1930 53 75 62 73 DB 'Substitue SFR SF addr' 1934 74 69 74 75 1938 65 20 53 46 193C 52 20 20 20 1940 20 20 20 53 1944 46 20 61 64 1948 64 72 194A 0D 0A DB ACR,ALF 194C 65 58 61 6D DB 'eXamine REGs Xy (where y is reg,' 1950 69 6E 65 20 1954 52 45 47 73 1958 20 20 20 20 195C 20 20 20 58 1960 79 20 28 77 1964 68 65 72 65 1968 20 79 20 69 196C 73 20 72 65 1970 67 2C 1972 20 73 70 61 DB ' space for next, CR to end)' 1976 63 65 20 66 197A 6F 72 20 6E 197E 65 78 74 2C 1982 20 20 20 43 1986 52 20 74 6F 198A 20 65 6E 64 198E 29 198F 0D 0A DB ACR,ALF 1991 20 20 20 20 DB ' Xa Xw Xk Xr0 ... Xr7 Xd Xb Xs Xp' 1995 20 20 20 20 1999 20 20 20 20 199D 20 20 20 20 19A1 20 20 20 58 19A5 61 20 58 77 19A9 20 58 6B 20 19AD 58 72 30 20 19B1 2E 2E 2E 20 19B5 58 72 37 20 19B9 58 64 20 58 19BD 62 20 58 73 19C1 20 58 70 19C4 0D 0A DB ACR,ALF 19C6 4E 65 78 74 DB 'Next Inst N (do one instruction)' 19CA 20 49 6E 73 19CE 74 20 20 20 19D2 20 20 20 20 19D6 20 20 20 4E Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 78 STRING.ASM: Strings For Canned Messages 19DA 20 28 64 6F 19DE 20 6F 6E 65 19E2 20 69 6E 73 19E6 74 72 75 63 19EA 74 69 6F 6E 19EE 29 19EF 0D 0A DB ACR,ALF 19F1 5A 6E 65 78 DB 'Znext Inst Z (no break in calls)' 19F5 74 20 49 6E 19F9 73 74 20 20 19FD 20 20 20 20 1A01 20 20 20 5A 1A05 20 28 6E 6F 1A09 20 62 72 65 1A0D 61 6B 20 69 1A11 6E 20 63 61 1A15 6C 6C 73 29 1A19 0D 0A DB ACR,ALF 1A1B 47 6F 20 50 DB 'Go PM G ' 1A1F 4D 20 20 20 1A23 20 20 20 20 1A27 20 20 20 20 1A2B 20 20 20 47 1A2F 3C 61 64 64 1A33 72 3E 20 3C 1A37 62 70 31 3E 1A3B 20 3C 62 70 1A3F 32 3E 1A41 0D 0A DB ACR,ALF 1A43 52 58 20 49 DB 'RX Intel R ' 1A47 6E 74 65 6C 1A4B 20 20 20 20 1A4F 20 20 20 20 1A53 20 20 20 52 1A57 20 3C 6F 66 1A5B 66 73 65 74 1A5F 3E 1A60 0D 0A DB ACR,ALF 1A62 46 69 6E 64 DB 'Find XDM F d0 ...' 1A66 20 58 44 4D 1A6A 20 20 20 20 1A6E 20 20 20 20 1A72 20 20 20 46 1A76 20 64 30 20 1A7A 3C 64 31 3E 1A7E 20 3C 64 32 1A82 3E 20 2E 2E 1A86 2E 1A87 0D 0A DB ACR,ALF 1A89 48 65 6C 70 DB 'Help H (print this file)' 1A8D 20 20 20 20 1A91 20 20 20 20 1A95 20 20 20 20 Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 79 STRING.ASM: Strings For Canned Messages 1A99 20 20 20 48 1A9D 20 28 70 72 1AA1 69 6E 74 20 1AA5 74 68 69 73 1AA9 20 66 69 6C 1AAD 65 29 1AAF 0D 0A DB ACR,ALF 1AB1 42 6C 61 73 DB 'Blast TO DM BT addr data' 1AB5 74 20 54 4F 1AB9 20 44 4D 20 1ABD 20 20 20 20 1AC1 20 20 20 42 1AC5 54 20 61 64 1AC9 64 72 20 64 1ACD 61 74 61 1AD0 0D 0A DB ACR,ALF 1AD2 42 6C 61 73 DB 'Blast FROM DM BF addr' 1AD6 74 20 46 52 1ADA 4F 4D 20 44 1ADE 4D 20 20 20 1AE2 20 20 20 42 1AE6 46 20 61 64 1AEA 64 72 1AEC 0D 0A DB ACR,ALF 1AEE 43 68 65 63 DB 'Checksum PM CP start end' 1AF2 6B 73 75 6D 1AF6 20 50 4D 20 1AFA 20 20 20 20 1AFE 20 20 20 43 1B02 50 20 73 74 1B06 61 72 74 20 1B0A 65 6E 64 1B0D 0D 0A DB ACR,ALF 1B0F 43 68 65 63 DB 'Checksum EDM CX start end' 1B13 6B 73 75 6D 1B17 20 45 44 4D 1B1B 20 20 20 20 1B1F 20 20 20 43 1B23 58 20 73 74 1B27 61 72 74 20 1B2B 65 6E 64 1B2E 0D 0A DB ACR,ALF 1B30 4C 69 73 74 DB 'List Stack L' 1B34 20 53 74 61 1B38 63 6B 20 20 1B3C 20 20 20 20 1B40 20 20 20 4C 1B44 0D 0A DB ACR,ALF 1B46 4D 6F 76 65 DB 'Move EDM M start end to' 1B4A 20 45 44 4D 1B4E 20 20 20 20 1B52 20 20 20 20 1B56 20 20 20 4D Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 80 STRING.ASM: Strings For Canned Messages 1B5A 20 73 74 61 1B5E 72 74 20 65 1B62 6E 64 20 74 1B66 6F 1B67 0D 0A DB ACR,ALF 1B69 4A 61 6D 20 DB 'Jam EDM J start end data' 1B6D 45 44 4D 20 1B71 20 20 20 20 1B75 20 20 20 20 1B79 20 20 20 4A 1B7D 20 73 74 61 1B81 72 74 20 65 1B85 6E 64 20 64 1B89 61 74 61 1B8C 0D 0A DB ACR,ALF 1B8E 50 6F 77 65 DB 'Power On Vector P start' 1B92 72 20 4F 6E 1B96 20 56 65 63 1B9A 74 6F 72 20 1B9E 20 20 20 50 1BA2 20 73 74 61 1BA6 72 74 1BA8 0D 0A DB ACR,ALF 1BAA 0D 0A DB ACR,ALF 1BAC 4E 75 6C 6C DB 'Null commands return the prompt without an error message.' 1BB0 20 63 6F 6D 1BB4 6D 61 6E 64 1BB8 73 20 72 65 1BBC 74 75 72 6E 1BC0 20 74 68 65 1BC4 20 70 72 6F 1BC8 6D 70 74 20 1BCC 77 69 74 68 1BD0 6F 75 74 20 1BD4 61 6E 20 65 1BD8 72 72 6F 72 1BDC 20 6D 65 73 1BE0 73 61 67 65 1BE4 2E 1BE5 20 20 44 6F DB ' Don',AAPOS,'t use DI' 1BE9 6E 27 74 20 1BED 75 73 65 20 1BF1 44 49 1BF3 0D 0A DB ACR,ALF 1BF5 6F 72 20 53 DB 'or SI to read or modify registers. Use the EXAMINE (Xy) ' 1BF9 49 20 74 6F 1BFD 20 72 65 61 1C01 64 20 6F 72 1C05 20 6D 6F 64 1C09 69 66 79 20 1C0D 72 65 67 69 1C11 73 74 65 72 1C15 73 2E 20 20 Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 81 STRING.ASM: Strings For Canned Messages 1C19 55 73 65 20 1C1D 74 68 65 20 1C21 45 58 41 4D 1C25 49 4E 45 20 1C29 28 58 79 29 1C2D 20 1C2E 63 6F 6D 6D DB 'command instead.' 1C32 61 6E 64 20 1C36 69 6E 73 74 1C3A 65 61 64 2E 1C3E 0D 0A DB ACR,ALF 1C40 54 79 70 69 DB 'Typically, mon51 uses RB 0 for working registers and the ' 1C44 63 61 6C 6C 1C48 79 2C 20 6D 1C4C 6F 6E 35 31 1C50 20 75 73 65 1C54 73 20 52 42 1C58 20 30 20 66 1C5C 6F 72 20 77 1C60 6F 72 6B 69 1C64 6E 67 20 72 1C68 65 67 69 73 1C6C 74 65 72 73 1C70 20 61 6E 64 1C74 20 74 68 65 1C78 20 1C79 61 63 74 75 DB 'actual values of' 1C7D 61 6C 20 76 1C81 61 6C 75 65 1C85 73 20 6F 66 1C89 0D 0A DB ACR,ALF 1C8B 74 68 65 20 DB 'the user',AAPOS,'s registers are available through' 1C8F 75 73 65 72 1C93 27 73 20 72 1C97 65 67 69 73 1C9B 74 65 72 73 1C9F 20 61 72 65 1CA3 20 61 76 61 1CA7 69 6C 61 62 1CAB 6C 65 20 74 1CAF 68 72 6F 75 1CB3 67 68 1CB5 74 68 65 20 DB 'the eXamine command.' 1CB9 65 58 61 6D 1CBD 69 6E 65 20 1CC1 63 6F 6D 6D 1CC5 61 6E 64 2E 1CC9 0D 0A DB ACR,ALF 1CCB 0D 0A DB ACR,ALF 1CCD 00 DB ANULL $RESETLN 1CCE 00 PGMEND DB 0 ; mark end of program Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 82 STRING.ASM: Strings For Canned Messages $SETLN(XRAM.ASM); %INCLUDE XRAM.ASM ; external ram allocations $SUBTITLE(XRAM.ASM: External Ram Allocations) Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 83 XRAM.ASM: External Ram Allocations ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; External RAM Allocation ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; =EF00 ORG XRAMBAS ; start of external ram ; space for parser EF00 (0001) ARGC DS 1 ; number of arguments EF01 (0002) ARGV0 DS 2 ; first argument EF03 (0002) ARGV1 DS 2 ; second argument EF05 (0002) ARGV2 DS 2 ; third argument EF07 (0002) ARGV3 DS 2 ; fourth argument EF09 (0002) ARGV4 DS 2 ; fifth argument EF0B (0002) ARGV5 DS 2 ; sixth argument EF0D (0002) ARGV6 DS 2 ; seventh argument EF0F (0002) ARGV7 DS 2 ; eighth argument =EF11 ARGVT EQU $ ; end of argument list ; space for user's registers EF11 (0001) UACC DS 1 ; user ACC image EF12 (0001) UPSW DS 1 ; user PSW image EF13 (0001) UR0 DS 1 ; user R0 image EF14 (0001) UR1 DS 1 ; user R1 image EF15 (0001) UR2 DS 1 ; user R2 image EF16 (0001) UR3 DS 1 ; user R3 image EF17 (0001) UR4 DS 1 ; user R4 image EF18 (0001) UR5 DS 1 ; user R5 image EF19 (0001) UR6 DS 1 ; user R6 image EF1A (0001) UR7 DS 1 ; user R7 image EF1B (0001) UDPH DS 1 ; user DPTR LOW image EF1C (0001) UDPL DS 1 ; user DPTR LOW image EF1D (0001) UB DS 1 ; user B image EF1E (0001) USP DS 1 ; user SP image EF1F (0001) UPCH DS 1 ; user PC HIGH image EF20 (0001) UPCL DS 1 ; user PC LOW image ; storage for break point information EF21 (0002) BKS0A DS 2 ; break point 0 storage address EF23 (0003) BKS0D DS 3 ; break point 0 storage data EF26 (0002) BKS1A DS 2 ; break point 1 storage address EF28 (0003) BKS1D DS 3 ; break point 1 storage data ; program space to put/get data to/from special function registers EF2B (0003) SFRPGM DS 3 ; space for subroutine to get/put SFR data ; space for find function EF2E (0010) FBUF DS 16 ; reserve 16 bytes ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; system vectors go here ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Avocet 8051 Assembler v2.02, #01245 Chip=8051 12/09/98 14:35:30 MON51-TUC52 950530-1.02 Page 84 XRAM.ASM: External Ram Allocations ; =EFCA ORG VECBAS ; reorg for vectores ; power on vector EFCA (0006) POVMEM DS 6 ; L, H, L+m, H+n, CK, CK+y ; interrupt vectors EFD0 (0003) VEC7B DS 3 ; vector from 007BH, EFD3 (0003) VEC73 DS 3 ; vector from 0073H, EFD6 (0003) VEC6B DS 3 ; vector from 006BH, EFD9 (0003) VEC63 DS 3 ; vector from 0063H, EFDC (0003) VEC5B DS 3 ; vector from 005BH, EFDF (0003) VEC53 DS 3 ; vector from 0053H, EFE2 (0003) VEC4B DS 3 ; vector from 004BH, EFE5 (0003) VEC43 DS 3 ; vector from 0043H, EFE8 (0003) VEC3B DS 3 ; vector from 003BH, EFEB (0003) VEC33 DS 3 ; vector from 0033H, EFEE (0003) VEC2B DS 3 ; vector from 002BH, TF2+EXF2 EFF1 (0003) VEC23 DS 3 ; vector from 0023H, RI+TI EFF4 (0003) VEC1B DS 3 ; vector from 001BH, TF1 EFF7 (0003) VEC13 DS 3 ; vector from 0013H, IE1 EFFA (0003) VEC0B DS 3 ; vector from 000BH, TF0 EFFD (0003) VEC03 DS 3 ; vector from 0003H, IE0 $RESETLN END