CSC270 Lab 6
This lab is your first introduction to the 6811 microprocessor Kit.
Introduction
First, let's explore the kits. The keyboard can be used to enter hexadecimal value into memory as well as into CPU registers. The table below lists the main commands and the actions they perform. You can get more information by checking this Heathkit document starting Page 15 in the pdf, which corresponds to Page 13 of the actual document.
| Key | Name | Description |
|---|---|---|
|
|
RESET |
Takes you out of trouble! Press this key whenever you want to return to the "main prompt" showing CPU UP. |
|
- |
Return |
Press the RETURN key to exit a function and save data contained in the CPU registers. |
|
+ |
List |
Use List in break mode to list the breakpoints. |
|
RPO |
Help |
Display a help message. Keep pressing it for more messages. |
|
D |
RS-232 |
Press this key to transfer control from the kit's keyboard to the serial port. |
|
E |
Baud |
Press this key to set the transfer rate to the outside serial port. |
|
F |
Insert |
Use Insert to change the contents of the memory. |
|
A |
Load |
Use Load to transfer a file stored in the memory module to the memory in the kit. We will not use the memory module in this course. |
|
B |
Save |
Use Save to transfer a file from the kit memory to the memory module. We will not use the memory module in this course. |
|
C |
Dup |
Press Dup (Duplicate) to copy a fie from one memory module to another. |
|
7 |
Break |
Use the Break key to set a breakpoint in memory. |
|
8 |
W Reg |
Use W-Reg to break a program when a register value reaches a desired value |
|
9 |
W Loc |
Press the W-Loc key to break a program when an address location reaches a desired value. This mode is similar to Break. |
|
4 |
M Blk |
Use the M-Bkl key to move a block of data in memory from another memory location. |
|
5 |
I Blk |
Press the I-Blk key to set a block of memory to a desired value. First enter the start address, then the end address. |
|
6 |
Down |
Press Down to download a Motoral Shex file into the kit's memory. |
|
1 |
Exm Mem |
Pressing this key in the select mode lets you examine the contents of any memory location. |
|
2 |
Exm Reg |
Pressing this key in the select mode allows you to modify any of the CPU registers |
|
3 |
Go |
Press Go to run a program in memory. The default start address is 0000H, but you can specify another address. |
|
0 |
SS |
Allows for single stepping the program. |
|
|
NMI |
Press NMI to interrupt any program running, or operation being performed by the trainer. The memory is not modified. |
|
|
Reset |
Press Reset to reinitialize the Trainer to its power-up state. All breakpoints are erased. |
Inputing your first program in the Kit
Your next step is to enter a test program in memory. The code of the assembled program is shown in hexadecimal below, with the address in the leftmost column, and the contents of the bytes on the right hand side. These bytes must be stored starting at address 0000 in memory. Do not worry about how this program works for right now. This is simply a test that will get you familiar with the kit and entering hex information.
ADDR BYTES
0000 CC 00 18
0003 BD C0 1B
0006 BD C0 27
0009 CC 00 27
000C BD C0 1B
000F BD C0 27
0012 BD C0 27
0015 BD C0 00
0018 50 72 6F 67 72 61 6D 6D 69 6E 67 20 69 73
0026 00
0027 0D
0028 45 61 73 79 20 61 6E 64 20 46 75 6E 21 21 21
0037 00
To enter the program, follow these steps:
1. press
I 0000
for Insert starting at Address 0)
2. Then enter the bytes, pressing the corresponding keys. The kit will automatically show you the address of the byte you are entering. Be carefull to wait until your 2-digit value is accepted before entering the next one.
3. If you make an entry error, press the - key. Pressing the - key backs you up one address at a time. When you reach the byte with the wrong information, retype it. You can go up and down the memory with - and + keys. .
4. The series of byte is a simple program that should display two strings on the kit. Be careful, the display lasts a few seconds and disappears to show the Kit's greeting line.
5. When you are done, press
NMI
to stop the insert mode and return to the kit's logo.
6. Press
Exm Mem 0000
to examine the memory starting at 0000. Press the + and - keys to go forward or backward in the memory. When you are satisfied that you have entered the sequence correctly, press
NMI
again.
7. Now make the processor start the program:
Go 0000
8. You should two strings appear in the display. If nothing of the sort happens, you probably have an error in your program. Check it again by comparing the contents of the memory to the string of hex numbers in the code above!
Your own test
It is now your turn to write a program, assemble it by hand, and enter it in the kit.
ORG 0000 ; specifies starting address 0
a FCB 2 ; 2 is stored at 0000
b FCB 3 ; 3 is stored at 0001
result FCB ? ;
ORG 0010 ; specifies starting address 10
LDAA 00 ; get Mem[0000] in ACCA (direct addressing)
LDAB 01 ; get Mem[0001] in ACCB
ABA ; ACCA <- ACCA + ACCB
STAA 02 ; Mem[0002] <- ACCA
The ORG statement specifies that the next assembly directive is to take place at the address specified after it. Assemble your program by hand, and use this page of 6800 opcodes to find the opcodes. Remember that when variables are in the first 256 bytes of RAM, you can use direct mode rather than extended. In direct mode you only use the lower byte of an address, not the full two bytes.
Find the hexadecimal values that must be stored in memory, starting with addresses 0 and 0010. You may want to use the table below to store your opcodes.
<
Address Op-Code/Bytes
001B
001A
0019
0018
0017
0016
0015
0014
0013
0012
0011
0010
...
0002 ??
0001 03
0000 02
In the next section you are going to test your program by single-stepping it.
You should include the listing of your program, along with the assembled code in hex in your report. Use the example shown below (sum of array of 5 bytes) as an example of the format to use.
Running your program
1. Then let's initialize ACCA and ACCB to 0.
2(Exm Reg) + 00 00
2. Instead of launching your program with Go 0010 (why isn't it a good idea?), you will single-step it starting at Address 0010
NMI
0(SS) 0010
3. The display is
0010 96 00
LDAA 00
That's the next instruction the kit is about to execute. Note that it is disassembling the instruction for us! (Disassembling means decoding the numbers in hex and figuring out what the name of the instruction is.)
4. Keep pressing SS until the Kit is about to execute the instruction ABA (add ACCB to ACCA)
SS SS ...
5. Let's examine the registers to see that ACCA and ACCB contain 2 and 3:
Exm Reg
+ +
Have ACCA and ACCB changed and do they contain the right values?
6. Continue single stepping until you pass the last instruction of our program and see some strange instruction left over in memory.
RPO
SS
...
7. Examine the registers again and verify that ACCA contains the sum of its old value plus that in ACCB.
8. Examine the memory starting at 0000 and verify that ACCA was correctly stored in memory at Address 3.
RPO
Exm Reg
+
+
If everything went well, the sum of [0000] and [0001] will have been stored in [0002]. If not, you probably have a bug in your program. Double check it, and do not go further until you have figure out the problem, and fixed it!
In your report, make sure you explain why you see a strange instruction in Step 6 above.
Endless Loop
Add a jump instruction (mnemonic JMP, addressing mode EXTENDED) at the end of your program to create an endless loop. The jmp should take you back to the beginning of your program. If you need to see the instruction set, use this reference.
Single step your program again, and to verify that the branch takes you to the correct location.
Five Fibonaccis
Write the program that computes the first 5 fibonaccis. The algorithm you should use is the following:
1. fib[1] = 1
2. fib[2] = 1
3. fib[3] = fib[2] + fib[1]
4. fib[4] = fib[3] + fib[2]
5. fib[5] = fib[4] + fib[3]
In other words, no need of loops for tonight!
To write this program you will need indexing mode. The program below computes the sum of 5 bytes and stores the result in the variable sum. Use it for inspiration!
; compute the sum of the contents of an array (table)
; of 5 bytes. The result is stored in a variable called
; sum
;--- data section ---
ORG 0000
0000 02 table FCB 2,3,4,1,7 ; create an array of 5 bytes
0001 03
0002 04
0003 01
0004 07
0005 00 sum FCB 0
;--- code section ---
ORG 0010
0010 CE 00 00 START: LDX #0000 ; IX = 0, address of 1st byte of array
0013 A6 00 LDAA 0,X ; ACCA = mem[0]
0015 AB 01 ADDA 1,X ; ACCA = ACCA + mem[1]
0017 AB 02 ADDA 2,X ; ACCA = ACCA + mem[2]
0019 AB 03 ADDA 3,X ; ACCA = ACCA + mem[3]
001B AB 04 ADDA 4,X ; ACCA = ACCA + mem[4]
001D 97 05 STAA 05 ; sum = ACCA
001F 7E FC 00 JMP FC00 ; Restart the monitor (OS)
The instruction "LDAA 0,X" is the one of interest here. The "0,X" part indicates that the addressing mode is indexed and that an offset of 0 is used. In other words, "0,X" means "load into ACCA the contents of Mem[X+0]".
"1,X" would have meant "of Mem[X+1]."
Similarily "-1,X" would have meant at Mem[IX-1]. In this case the offset would have been FF, which in hexadecimal is -1. -2 is FE, -3 is FD, etc.
Assemble your program by hand, enter it in the Kit's RAM, and verify that the program computes correctly the first 5 fibonacci numbers. Make sure you demonstrate this to your instructor!
Your assignment for next lab
Write a small program as an endless loop that reads a byte from memory address 0, increments it by 1, and stores the result back at that address. Assemble the program by hand and come back to next lab with its listing.
We will need it to observe in real time how the processor executes your program (we'll use the oscilloscope to capture the signals).
This page was last modified: 03/22/2009 21:02:24
