skip navigational linksPJRC
Shopping Cart Checkout Shipping Cost Download Website
Home Products Teensy Blog Forum
You are here: 8051 Tools PAULMON Monitor Version 1 Original Docs

PJRC Store
8051 Board, $79
LCD 128x64 Pixel, $29
LCD 16x2 Char, $14
Serial Cable, $5
9 Volt Power, $6
More Components...
8051 Tools
Main Page
Software
PAULMON Monitor
Development Board
Code Library
89C2051 Programmer
Other Resources

Introduction to PAULMON 1.0 (Very Old Documentation)

Administrators Note: Paulmon 2.0 is going to be released soon so it would not be wise to use 1.0 in any new boards since using 2.0 will have many advantages over 1.0. If you are intrested in beta testing the new version, please contact Paul via E-Mail paul@ece.orst.edu to get on the mailing list

The PAULMON debugger is my attempt to make a user-friendly 8051 debugger, with enough on-line information that it should be unnecessary to read this doc file. PAULMOM is targeted for use by the microprocessor design course at Oregon State, but may be used by anyone (who can figure it out) for projects ranging from research to commercial products. PAULMON is free and may not be distributed for profit whatsoever.

Since I don't expect Prof's or TA's at OSU to make students aware of this documentation nor to provide it nor do I expect students to read much of it, I wrote PAULMON to be very simple and to provide lots of on-line clues about what it can do and how to go about it. I hope that you find PAULMON to be useful and easy to use. Good Luck.

-Paul Stoffregen (paul@ece.orst.edu)

DISCLAIMER: This is free software. As far as warranty is concerned, you get exactly what you pay for! I have tried to make this code as good as possible during the four weeks I worked on it, but nobody is perfect and portions (the single step in particular) were never well tested. USE AT YOUR OWN RISK. The assembly source is provided in case there's something you don't like.

ADDITIONAL DISCLAIMER: This doc file has lots of tyopes and other errorss, and I really don't care. PAULMON was written to be easy enough that this file ought to be unnecessary, but people ask for it nonetheless, usually before they even try to use the thing.

What You Will Need to use it:

PAULMON is 8051 assembly code which is intended to be burned into a 2764 EPROM, though a pair of 2732's could be used or a bigger rom can be used with the rest being empty or filled with other code. The EPROM with PAULMON should be addressed so that it is read from 0000 to 1FFF with the 8051's EA pin wired to make it read all code from external memory.

The compiled version is availible along with the source code on the ECE web site. PAULMON uses the built in UART in the 8051 to communicate with the user. Typically, a PC computer is used with a terminal program, an 8051 assembler, and a text editor to form a simple, low cost 8051 development system with PAULMON. A serial line receiver and driver should be used (the MAX232 is a good choice, IMHO) to interface the 8051 to the PC's serial port. Only TxD, RxD and ground are used (no handshaking) and PAULMON adapts to use whatever baud rate the computer is using (if it can with the crystal you select, see below)

PAULMON is intended to be used with RAM as well, and the default location for the beginning of the RAM is 2000 (hex), right after the EPROM, though the RAM can be used anywhere in the range of 2000 - FFFF. The read enable signal to the RAM should be the logical OR of the RD and PSEN signals, so that read attempts to external code memory or program memory spaces will read from the RAM. (use an AND gate to do the logical OR of these signals, since they are active low!) Obviously the write enable of the RAM should be connected to the WR pin of the 8051.

Having a RAM connected in this way will allow the download command in PAULMON to write your program into the RAM (writing into the external data memory space). Then you can run your program, since read attempts from the external program memory space will read from the RAM chip.

How to get is set up:

Design and build your 8051 board. All that is really required is the 8051, an EPROM, a latch (74xx373), some sort of address decoding to enable the EPROM for memory access between 0000-1FFF, and a line receiver to convert the high voltage RS232 to a TTL (or CMOS) compatible signal (or else you'll toast the 8051 before it even has a chance).

To really use PAULMON, a RAM is required as well as the AND gate to allow both program and data read cycles to read the RAM memory, and a reset button to easily get back to PAULMON when your program crashes.

With just the minimal setup, set the computer's baud rate to something slow (like 1200 bps) and power up the board. Press Enter (Return) and hopefully you'll see a screenful of text from PAULMON. PAULMON does not send line feed characters, so the terminal emulator software must be configured to translate CR -> CR/LF. (PAULMON ignores LF characters is receives.) If the entire message ends up on one line, then the terminal is not translating CR -> CR/LF. After it works, you can try increasing the baud rate and COLD-BOOTING (you must turn the power off, taking the reset line high will not make PAULMON look for the new baud rate... or change the bytes where it stores the old baud rate... see the code if you're interested) If the minimal system shows no signs of life, it's time to check the wiring, usually starting by making sure you didn't swap the TxD and RxD lines.

The Automatic Baud Rate detection:

This code was borrowed from MDP/51 by Kei-Yong Khoo. It is run immediatly after a system reset. It waits for a <RETURN> character, and uses it to calculate the timer #1 reload value. Some modifications have been made to Khoo's code. It requires only one character. It also stores the reload value in four memory locations in internal ram (78H, 79H, 7AH, and 7BH). These four locations are unlikely to be changed during a user program's execution or while the debugger is running. When another reset occurs (without removing the power) the program looks at those four locations. If all four agree, then it uses that reload value and does not require another keypress. It is interesting to note that occasionally, with cystal values which produce exact reload values (such an 7.3728 MHz), the baud rate detection routine may not correctly calculate the reload value. Garbage will get printed all over the screen. If this happens, just switch off the power and try again. The advantage of crystals such as the 7.3728 Mhz is that they allow transmission at speeds of 9600 and 19200 baud! It is highly reccomended that you use the highest possible baud rate with this debugger, as is tends to print quite a bit of text to the screen.

The Commands

  • On-line Help:

    By typing '?' at the main menu, a help screen summarizing the available commands is printed. On-line help is also available regarding the single step run feature. This help is accessed by typing '?' just after using the 'R' command. While in the single step mode, a summary of commands is also available, again by typing '?'.

  • The <ESC> key:

    The <ESC> key is supported extensively. It will abort all commands from any prompt. It will stop the list and hex dump commands in the middle of their printing. It will also interrupt the printing of text to the screen! This is useful at slow baud rates, since a full screen of text can take quite a while to print at 300 baud.

  • The Download Program command (type 'D')

    This allows you to send the object code from the assembler to the external ram. The object file must be a standard Intel Hex Format file, such as the .OBJ file created by the Psuedo- Assembler, by Psuedo-Corp. The file must be sent as an ASCII transfer. The protocal such as XMODEM is used. Pressing the <ESC> key at any time will abort the transfer. Please note that most communications programs use the <ESC> key to abort their transfer. In this is the case, the first <ESC> will halt the terminal, pressing it again will abort the recieve at the 8051/31. Unlike some other debuggers, PAULMON will recognize the <ESC> key anywhere in the middle of the incoming data, not just at the beginning of a line.

  • The Run Program command (type 'R')

    The run command allows you to execute your program. Two types of run are supported, Normal and Single-Step. The single step mode is explained later, as it is fairly complex. During a normal run, the quiviliant of an LCALL to your code is given. During the execution of your program, the debugger obviously has no control of the system, unless of course your program calls one of the subroutines offered by the degugger in the jump table at location 0030H. After specifying which run mode you need, the location of your program is prompted, with the current memory pointer value as the default choice. As is the case at all prompts, pressing the <ESC> key will abort the run command. It is interesting to note that the run command leaves timer #1 in auto-baud rate generation mode. If serial communication is desired at the same baud rate as that used for the debugger, timer #1 need not be given a new reload value. It is recommended that the character input and output routines from the debugger be used via the jump table.

  • The New Memory Location command (type 'N')

    The debugger operates with a pointer to the data memory with which you are working. This pointer is used by the list and hex dump command. It is also the default run location. The pointer is incremented as memory is viewed or modified. Just type 'N' to change it.

  • The List command (type 'L')

    This debugger gives you the ability to list your program's code directly from the computer's memory. All the 8051/31 mnemunonics are supports, as well as the names of the special function registers. Bit addressable locations are displayed using the standard syntax (e.g. PWS.2 or 20.5), but individual bit location names are not supported (e.g. SCON.0 will print in place of RI). Obviously, the original labels used in the source code cannot be printed, instead the memory locations are displayed. Other special Intel assembly formats, such as $ and CALL are not supported. However, the list command can provide a reassuring look at the program directly from the memory.

  • The Hex Dump command (type 'H')

    By typing 'H', the next 256 bytes of ram are dumped to the screen in hex and ascii. The <ESC> key may be pressed to abort the printout.

  • The Edit command (type 'E')

    This command allows you to change the values of memory locations in the external ram. Each location's old value is shown. If <ESC> is pressed, the current location's value is not changed.

  • The Jump Table:

    Desipte the use of the word "jump", the user must LCALL to these locations! The individual locations contain jumps to the subroutines, which all terminate with a RET. The table provides the user with a memory location to call to that WILL NOT CHANGE if the debugger is reassembled. The routines available are:

            0030:   Cout    -Sends the byte in Acc to the
                             serial port.
            0032:   Cin     -Waits for a character from
                             the serial port, returned in Acc.
            0034:   pHex    -Prints the two digit hex value 
                             in Acc to the serial port.
            0036:   pHex16  -Prints the four digit hex value
                             in DPTR to the serial port.
            0038:   pString -Prints the string in code memory
                             pointed to by DPTR to the serial
                             port.  The string must terminate
                             with 00H or a high bit set
            003A:   gHex    -Gets a two digit hex value from
                             the serial port, returned in Acc
            003C:   gHex16  -Gets a four digit hex value from
                             the serial port, returned in DPTR
            003E:   Esc     -Checks to see if the <ESC> key is
                             waiting in SBUF.  Clears the buffer
                             if it is, and returns with the
                             carry set.  Otherwise, leaves SBUF
                             untouched, and returns with C=0.
            0040:   Upper   -Converts character in Acc to
                             uppercase if it is lowercase.
            0042:   Init    -Automatic baud rate detection.
    
    The memory location can be placed directly in your code, or an EQU can be used to make your code more readable. For example:
    Program:.EQU    gHex16, 003AH           ;this make the code nice
            MOV     DPTR, #StrLoc           ;load DPTR 
            LCALL   gHex16                  ;print the DPTR
            MOV     A,#13
            LCALL   0030H                   ;print a <RET>
            LCALL   0038H                   ;print the string
            RET
    StrLoc: .DB     "This is my String.", 0
    
    Most of these routines leave the registers unchanged, however, it is a good idea to consult the source code just to be sure... In particular, the phex routine DESTROYS the contents of Acc, so beware. (this has cause some people some grief, who had assumed the phex would leave Acc unchanged. If you want it unchanged, the original .ASM file is provided for you to modify)

  • The Single-Step Run:

    [This part was never written, and the single step run code is somewhat buggy, primarily due to a lack of available beta testers... so docs were never written, but PAULMON ought to give you enough clues to figure it out if you try.]


Return to 8051 page