SWTBUG Monitor ROM

In a 1K EPROM residing at addresses $E000 to $E3FF lives the SWTBUG monitor program. In most machines, its main purpose in life is to hold the boot program, which knows just enough about the disk drive to read its boot sector, which in turn is smart enough to load an operating system. It also necessarily has subroutines for simple I/O, which may (or may not) be used by whatever O/S is loaded.

However, it can be used without any O/S or disk drives, letting you examine and alter the contents of memory and run machine-code, "programming on the bare metal". This was important in the good old days, since not every hobbyist could afford disk drives.

Command list

B - breakpoint
C - clear screen
D - boot from disk
E - punch end-of-tape
F - find byte
G - go to user program
J - jump to address
L - load program from paper tape or cassette
M - memory examine and change
O - optional port
P - punch ASCII tape
R - register dump
Z - jump to user PROM

Command summaries

C - clear screen
Sends ASCII codes 16 and 22. For a SWTPC CT-1024 terminal, these are home-up and clear-to-end-of-frame, respectively.
Example: $C
D - boot from disk
Boots from an MF-68 floppy disk subsystem.
Example: $D
F - find byte
Searches a region of memory for a designated byte value, and displays the addresses that contain it. The command is used by entering the region's upper address, followed by its lower address, followed by the byte to search for. Addresses must be four hex digits, the byte is two, and no spacing or punctuation of any sort should seperate them - enter ten hex digits in a row. Be careful to enter the upper address first.
Example: $F 012C01003A
J - jump to address
Following the 'J', you enter four hex digits, and the computer begins execution at that address.
Example: $J 0109
M - memory examine and change
Following the 'M', you enter four hex digits, and the computer displays the contents of the memory at that address. You can change the contents by entering a new value (two-digit hex), see the contents of the previous address by entering an up-arrow character '^', see the next by entering almost anything else, or go back to the command prompt by entering a carriage return.
Example:
```
        $M 0108
        $0108 12  00
        $0109 A4  00
        $010A CB
```
Z - jump to user PROM
Jumps to address $C000, at which address a user-written PROM is assumed to be.
Example: $Z
G - go to user program
Executes an RTI instruction, pulling new register contents from the stack. Values could have been left there by a breakpoint, or could have been entered with the M command. Because SWTBUG's stack is based at $A042, the 'G' command is equivalent to jumping to whatever address is stored at $A048 and $A049 after loading values into registers.
Example: $G
R - register dump
Displays the contents of the registers that are on the stack as if pushed there by an interrupt. (But they may have been manually entered there by the user.) Registers are listed in this order: CCR, B, A, X, PC, SP
Example:
```
        $R
        $2A 41 6C 2A4D 083C A042
```
B - breakpoint
Inserts a "breakpoint" into a machine-code program by putting a software-interrupt (SWI) instruction at the designated address, after copying its contents aside so that they can be restored later. That address is entered immediately after the "B", as four hex digits. The "G" command should be used to continue the program. Only one break-level is supported, so entering a second breakpoint automatically clears the first. This involves putting back the instruction that was copied aside, so it is a bad idea to set a breakpoint, load another program into the same region of memory, and then set another breakpoint; the instruction from the first program would overwrite whatever byte of the second program happened to be at its location. Also, a reset will lose any active breakpoint return-address, so the program should be restarted from the beginning if this happens while breakpoints were in use. A breakpoint can be cleared without setting another by entering a carriage return rather than an address after the "B". Since breakpoints make use of interrupts, they will not work properly with programs that need interrupts for their own purposes.
Example: $B 0200
P - punch ASCII tape
Punches the contents of a region of memory in Motorola S1 format. The region is specified by putting its (inclusive) lower and upper addresses into memory locations $A002:$A003 and $A004:$A005, respectively. (In each, the MS byte goes into the lower address). Before beginning, an "PUNCH ON" control character is sent (ASCII code 18) and if the output port is an MP-C then its PIA lines are strobed as necessary to control an attached AC-30 cassette interface. After ending, "PUNCH OFF" is sent (ASCII code 20) and the MP-C PIA lines are again strobed as appropriate for the AC-30. Output is normally either an MP-C or MP-S on port 1, but the "O" command can make this use an MP-C on port 0 instead.
Example: $P
E - punch end-of-tape
Similar to the "P" command, but punches the end-of-tape info. This includes the range of addresses that were entered for the punch command, and the starting address (assuming it is a program). The starting address is taken from memory locations $A048:$A049, as with the "G" command. Punch "on" and "off" controls are sent as by the "P" command.
Example: $E
L - load program from paper tape or cassette
In the same vein as the "P" punch command, but loads a program rather than saving it. Responds with a question mark "?" if anything goes wrong and the load fails. As with the punch command, this normally uses port 1, but can be overridden to use port 0 by the "O" command.
Example: $L
O - optional port
Forces the following "P", "E", or "L" command to use I/O port 0 instead of the default I/O port 1. However, on I/O port 0 you must have an MP-C interface, not the MP-S ACIA-type interface. A reset will not turn off the reader or punch on port 0 as it will on port 1.
Example: $OP

8-Mar-1998

yakowenk@csx.unxc.edu

(remove all "x"s to get a valid address)