EECE 259 - Lab 5 - Using The Assembler and Debug Monitor.pdf

Rational: The purpose of this lab is
University of British Columbia
Electrical and Computer Engineering
EECE 259
Laboratory 5 – Microcomputers
Copyright © 2012 PJ Davies
1. To familiarise yourself with using the IDE68 integrated development
environment, i.e. the 68000 Assembler
2. To familiarise yourself with the Debug Monitor on the DE2 board
3. Modify a simple program
4. Write some simple programs of your own
When demo’ing, you will have to show that you can enter, assemble and download a
program to the DE2 board and use the debugger to disassemble, single step, set
breakpoints, examine and change memory, display CPU registers and make simple
changes to your program.
You will also have to demo Part F (the two programs that you have written)
Part A
Make sure you have downloaded and installed/programmed the following
o The IDE68k integrated development environment.
o The HyperTerminal communications program.
o The 68k.pof file (from the web site) has been programmed into the DE2
using Quartus and active serial programming which means it is
permanently stored in the DE2 when power is turned off.
When this has been performed correctly, you will see the message “68k
Bug V1.73 By Paul Davies” appear on the LCD display when you turn on
the power. Make sure switches SW16 and SW17 on the DE2 board are in
the down position or this won’t happen.
o Make sure you have connected an RS232 – USB converter cable from
your DE2 to your Laptop. You do not need the Quartus download cable
once you have programmed your DE2 with the above ‘.pof’ file (just in
case you are running short of USB ports on your laptop – you can run the
DE2 from its small power supply.)
Instructions on how to download and use the above software can be found on the
259 web site – make sure you read it.

Part B
Using the IDE68k Instructions:
Setup the various IDE options, e.g. editor etc. as per the instructions in the
handout.
Create a new assembly language program based on the source code found on Page
12 of the Lecture “Introduction to 68000 and Assembly Language Programming –
Part A”
Build the program, i.e. assemble it – correct errors as required.
Locate the listing file and the hex file produced. Examine them in an editor to see
what they look like.
Part C
Make sure your RS232-USB dongle is plugged into the RS232 port on the DE2
board (top right corner)
Plug your USB extension cable (that came with the dongle) into the dongle and
the other end into a spare USB port on your Laptop. Make sure Windows has
recognised and installed the drivers for the dongle. The image below shows the
driver installed as COM5 under Ports.
Start the HyperTerminal program and following the instructions posted on the 259
web site about using this software, make sure you have established a serial
communications link between the 68000 running on the DE2 and the
HyperTerminal Program. (Note: Pressing the blue push button Key0 on the DE2
will reset the 68000 processor at any time).
Hit return, you will see a menu of debugger commands
Read the instructions from the 259 web site “Using the 68000 soft core processor
debug monitor with the DE2 board”

Enter the ‘L’ command to load a program into memory. The 68000 will wait for
HyperTerminal to send it a program file (the HEX file you created in Part B
above)
In HyperTerminal, click the transfer menu button and locate the hex file
containing the machine code
The download will progress.(See below)
At the ‘#’ prompt enter the ‘G’ command to the debugger to run the program.
You should see that the program will copy the switches SW0-7 to the RED Leds
0-7, i.e. as you change switches, the leds will change value.
Press the reset button (Key0) on the DE2 to stop the program and return to the
debug monitor prompt ‘#’.
Using the instructions in the handout “Using the 68000 soft core processor debug
monitor with the DE2 board”, program the flash memory on the DE2 board to
make a ROM based system (Enter the ‘P’ command – see below).
If you have done this correctly, when you power up your DE2 with SW17 in the
UP position, the 68000 will automatically run your program without you having
to download it each time it is turned on.

Part D – Using the Debug Monitor Commands
Using the ‘M’ command – Memory Examine and Change, enter the start address
of your program in memory (hex 00800000). You should see your program
(machine code) bytes located in memory. Compare these to the bytes created by
the Assembler (as shown in the listing file produced by the assembler).
Using the DU (Dump Memory) command, dump your program contents to the
screen. This is another way to examine memory and view its contents, but
displaying large blocks at a time instead of just 1 byte.
The data is displayed in hex and over to the right of the screen, if each byte of
data could be a printable ASCII character, it will attempt to display it as such,
otherwise it puts out a ‘.’. This feature makes it easy to spot text strings in
memory.
Using the DI command – Disassemble Program, enter the start address of your
program in memory. It should produce a disassembly of your program, i.e. it will
try to convert the machine code bytes back into assembly code for you.

Note the debugger does not know where each instruction starts or where your
program ends. It simply attempts to interpret bytes of data in memory at the
address you specify as if they were instructions.
Note also that the original assembly language labels cannot be recreated (why do
you think that is?) so they are created as addresses. Can you see the 3 instructions
from your program in the listing below? The rest is just the debugger trying to
disassemble random bytes of data stored in memory into instructions.
Using the ‘R’ – Register Dump command, display the 68000 internal registers.
Now see if you can change them using the ‘.(reg)’ command e.g. ‘.D0’ etc. Notice
that you are not really displaying or changing the actual 68000 registers with
these commands. What you are doing is viewing and changing variables within
the debug monitor that represent the 68000 registers. When you run your
program, these variables are loaded into the real 68000 registers.
o What is the default value for the program counter (PC)?

o Explain why your program will run when you enter ‘G’ without having to
specify an address
o What if you changed the value of the PC and pressed ‘G’? Try it; you
cannot do any damage – press reset at any time.
Debugging Programs
Press the reset button key0 on the DE2.
We are now going to single step our program, one instruction at a time. Single
stepping is a powerful debugging tool that allows us to slow down/pause the
68000 so that we can observe the execution of each instruction – one at a time.
After each instruction has executed the 68000 registers are displayed so we can
see what effect that instruction has had on the 68000 and also on the outside
world, (e.g. turning on an LED for example).
To turn on/off single stepping mode, press the ‘S’ key. You should get
confirmation that single stepping mode is [ON]. You should also see a register
dump to the screen and a disassembly of the first instruction that you are about to
execute, i.e. you can see what the next instruction is, i.e. MOVE.B $400000,D0
Now press the ‘G’ command to start the program
Hit the space key to single step (trace) the program one instruction at a time.

Using Break Points
Breakpoints are another powerful debugging technique. A breakpoint can be set
at an address in memory where a chosen instruction is stored. You can then run
the program at full speed, but when that instruction (the one you have set a
breakpoint at) is reached, the program will stop, display the 68000 registers and
enter single step mode so you can trace/single step the program from that point.
Up to 8 separate breakpoints can be set at 8 different instructions (they are all
cleared when you press reset or execute the breakpoint kill command)
Let’s set a break point at the third instruction in our program, the JMP $00800000
instruction that makes our programs loop. To do this, enter the debugger
Breakpoint SET command ‘BS’ and enter the address 0080000C. You should see
the following
Now run the program by pressing ‘G’. When the program reaches the JMP
instruction, it will print @BREAKPOINT and stop (see below).
You can now single step the program from here by hitting the space bar

Using Watch Points
Watch points are another powerful debugging technique. A watch point can be
set at any address in memory (usually it is the address of data not an instruction).
When you enter single step mode, a dump of the memory that you have set a
watch point at is displayed.
Up to 6 separate watch points can be set (they are all cleared when you press reset
or execute the breakpoint kill command)
To set a watch point, enter the Watchpoint SET command ‘WS’ and enter the
address e.g. hex 00010000 which is where we might store our variables.
Turn on single step mode with the ‘S’ command.
Notice in the screen shot below, how the debug monitor displays the data at the
chosen watch point (WP0) address (actually it display 16 bytes, starting at that
address and rising to higher addresses).
Now enter the command ‘G’ and then hit the space bar to single step the program.
The program that we have loaded into memory and are running does not actually
make any changes to the data at memory location $00010000, so we would not
expect the data there to change, but if it did, we would see the change, one
instruction at a time.

Part E – Modifying a Program
Go back to the IDE68k/Assembler and open up the original program you typed in
at the start of the Lab, the one that copies Switches to LEDS.
Modify the program to do the following. For each change, download, disassemble
and single step the new version of the program.
o Read Port B (switches 8-15) and copy the data to the red leds 8-15 and
also the Hex0 Display (look up the addresses of these output ports in the
lecture notes and handouts on using the 68000 on the DE2 board).
o Store the data you read from Port A and Port B to Static Memory at
addresses $00010000 and $00010001. Single step this program and set up
watch points on these two address to observe them change.
Part F – Writing your own program
Write an assembly language program to read in your 8 digit student number using the
slider switches SW0-SW7 on the DE2 board (note these switches are connected to
one of the input ports) and display them on the 8 digit hex displays. To make it
simple, assume your student number only contains digits in the range 0-7 (not 8 or 9)
as this means we do not have to read the other input port where switches 8 and 9 are
connected.
For example, if your student number was 56231447, then you would enter this by
moving SW5 to the up position then back to the down position, followed similarly by
Switches 6,2,3,1,4,4,7. Your software will have to read the switch port, detect when a
switch has moved to the up and then down position and write data to the Hex
displays.
You should investigate the BNE (branch if not equal to zero instruction) and BEQ
(branch if equal to zero instruction) to determine when the switch has been pushed up
or returned to the down position (logic 0). This can be explained as follows.
When the switch is in the up position (logic 1), and you read the value of the switches
into 68000 register d0, it will clear the ‘Z’ bit in the 68000 condition code register.
When the switches are in the down position (logic 0), reading the switches will set the
‘Z’ bit. BNE and BEQ branch if the Z bit is 0 or 1 respectively.
Note you can expect some occasional “contact bounce” on the switches leading to
occasional incorrect detections of up/down movement (this is normal for a
mechanical switch)
When all 8 digits of your student number have been read, the program should stop
and return to the debug monitor with a TRAP #15 instruction. Use the debugger to
single step and debug the program.
Write an assembly language program to read the 1st first 4 digits of your student
number and convert them into a 16 bit (4 digit) BCD number. For example, if the first

4 digits of your student number are “1257”, then the resulting 16 bit BCD number
should be 0001 0010 0101 0111. You should investigate the 68000 instruction set for
arithmetic shift left operations. Store the resulting 16 bit BCD number as a word in
memory (e.g. where there is some static memory such as at address $00010000).
Question: How many bytes of data will be stored and what is the address of each byte
and hence what is the address of the next free byte in memory.
Now read the 2 nd 4 digits of your student number and convert them into a 2 nd 16 bit
(4 digit BCD number) as above and store it somewhere else in memory (do not
overwrite the first data stored at $00010000).
Now, using Switch SW10, add or subtract the 2 nd four digits of your student number,
from the 1 st four digits and display the result as a 4 digit number on the HEX display.
That is, the program should run indefinitely, reading SW10 and performing addition
or subtraction based on SW10 position (up or down). Investigate the ABCD and
SBCD instructions in the 68000 instruction set for adding and subtracting in BCD.
Store the result in memory. Ignore negative results
When SW11 is moved into the up position, the program should stop and return to the
debug monitor using a Trap #15 instruction. Use the debugger to single step and
debug the program.