Hacettepe University
Department of Electrical and Electronics Engineering
ELE 402 Final Project Report
Instructor: Asst. Prof. Ali Ziya ALKAR

Spring 2000


This project is prepared in the aim of helping to understand of the instruction execution and memory management of 8-bit Intel 8085 microprocessor. For this purpose, a program, which is run on Intel 80386 based CPU's and under Win32 operating system, is written using a high level visual programming language. With this program, namely Sim8085, one can be write a 8085 microprocessor assembly language code in text format and then simulate it line by line just as it runs on the original CPU. While the assembly codes are executed (simulated), the register, memory (code, stack or data) and port contents can be viewed instantly. There can be also made some modifications to these values at run-time, if needed. With the Sim8085, all the work is done in very user-friendly environment. This report will guide reader in detail about the program specifications, program usage and language coding steps with operating system background.



Nowadays, personal computers (PC) do all the hard work for us, including the complex calculations and scheduling. There are many different microprocessor based platforms and we can also simulate these different platforms on PC's. One of them is 8085 microprocessor (p). It is one of the first produced controllers in the electronics age.
Writing a program means that, building algorithm(s) for doing something according to a purpose. And than, check the whole for any error (bug). For the point of engineering, writing 8085-p assembly programs and checking them for error under 8085-p environment is quite difficult and it takes long time. At this point, the PC's come to the help of us.
The "8085 Microprocessor Simulator", Sim8085, is such a Win32 based program that runs on Intel 80386 based 32-bit microprocessors and simulates the original 8085-p with its instructions. The program(s) and/or algorithm(s) can be debugged within the program. In addition, it has a text editor with very enhanced functions that you can write your assembly code without any external text editor.

So, the Sim8085 is mainly separated into two parts:

Editor: Sim8085 has an enhanced internal text editor with standard and Sim8085 specific functions. The Editor also has a build-in compiler that makes the syntax checking. There are some pseudo-directives that included for coding easily. (e.g., "FillByte", "Org", "Db", "KickOff") With these pseudo-directives, Sim8085 does the all related hard work instead of user. The object and binary (machine) codes of the written program(s) can also be obtained, while syntax checking is made.

Debugger:"Debug" means, find and correct the mistakes, if any. From this point, the debugger part is designed to analyse the implemented code easily. There is a 64-KB virtual memory where the written program is kept as 8085-p machine codes. All the register, flag, code, data, stack and port contents can be viewed while tracing thorough the code lines. The content of the areas mentioned above is changed instantly according to the instruction that just executed. Port operations can also be viewed and controlled visually.



2.1 Editor Part

The Sim8085 has a very user-friendly text editor. A general layout is shown at figure 2.1. There can be opened up to ten different files at a time. Default file extension for opening and saving files is "85".

Figure 2.1 "Editor Mode Screen Snapshot"

There is an adjustable undo-buffer. And, in a visual manner, there is some more: Firstly, background and foreground of the text can be chosen. Also, editor can make syntax highlighting to written text; user can choose the color of the all reserved assembly words. Secondly, there are some information-based tags: Cursor position, editor buffer modification, editor cursor mode, file read-only info, and context sensitive help are shown instantly at the "Status Bar". The editor and file commands in the Sim8085 are: "New", "Open", "ReOpen", "Save", "Save As", "Save All", "Close", "Print", "Undo", "ReDo", "Cut", "Copy", "Paste", "Select All", "Find", "Replace".
The editor part has a built-in compiler that checks the written assembly code for syntax errors. After all the lines are checked, the erroneous line is shown with respective error message and line number, if there is any mistake; otherwise, the user is informed with a message including the compiled code size. Screen snapshots are shown below.

Figure 2.2 "Erroneous Code Screen Snapshot"

Figure 2.3 "Compiled Code Screen Snapshot"

The list and object files can be generated automatically every time the source code is compiled or manual by the user, depending on the settings. Screen snapshots of these text-based files are shown below.

Figure 2.4 "List File Screen Snapshot"

Figure 2.5 "Object File Screen Snapshot"

Sim8085 assembly compiler has some more flexible rules: There can be entered binary, decimal and hexadecimal numbers. Comment lines can be included. These lines are begun separated with a semicolon and discarded by the compiler. Loop names can be entered up to thirteen characters ended by a colon. Also, there are some pre-assigned words, which are called as "Pseudo-Directives". These directives make the writing of programs and/or algorithms easy.The meaning and usage syntax of each pseudo-directive is shown below:

"FillByte count,byte": Fills the memory starting from the current memory address with the given byte at a given count.

"Org address": Tells to the compiler to place the machine codes starting from the given address.

"KickOff address": Tells to the compiler that where the entry point (starting address) of the written assembly code is.

"Db string of bytes/characters": This directive makes the entry of any string, character or byte is easy. The all characters in a string are individually follows each other in the memory. An example of usage is, "Db 13,10,'This is a sample text',13,00001010b,24h"

2.2 Debugger Part

After the source code is compiled successfully, meaning there is no any syntax error, debugger mode can be begun. Debugger screen consists of a code pane, a register pane, a flag pane, a stack pane and a data pane. The screen layout is shown below.

Figure 2.6 "Debugger Mode Screen Snapshot"

In fact, code, stack and data panes show the memory content according to their duties; however, the memory location they point can be different. Code pane interprets the bytes in virtual memory as 8085-p machine codes; whereas data pane interprets the bytes in virtual memory as pure characters, but also showing the hexadecimal equivalents. Both the code and stack panes show their content with the respective offset address in a tabular form. Stack pane shows the memory location as two bytes (word), indicated by the stack pointer register, SP, with a range of ?5 words. Register pane shows the all 8085-p register contents and also the memory byte location indexed by HL register pair. Likewise, flag pane shows the flag register and the individual bits of it. To make the following easy, the changed registers and flag bits are drawn with a separate color while tracing. The current line or location in each pane is shown by a highlighted bar. The user can be cycle through the panes with keyboard or even a mouse click. Contents of the ports can be viewed and even changed bit by bit within the "Ports Form". Port numbers are pre-assigned and can be changed from the "Options Menu". Values are shown in decimal, hexadecimal and octal, too. Snapshot is show below.

Figure 2.7 "Ports Form Screen Snapshot"

The debugger mode has a unique advantage that makes the usage so easy with allowing instant changes to any register or memory content while still debugging the code. User can add, delete and change the instructions in the code pane by writing as string or hexadecimal bytes. Likewise, in the data pane, user can change the memory content by inserting new data bytes or just changing the old ones as string or hexadecimal bytes. With this way, user does not have to go back into the editor mode and change the written assembly text code for small changes or tests. But, of course, the original code text does not change after leaving the debugger mode. All the changes made in debugger mode are discarded.
The simulation of 8085-p instructions is done with some trick: Instead of completely simulating all these instructions by software, it is used some CPU help. For instance, the CPU of the PC has done parts of all arithmetic instructions, since addition or multiplication logic does not change according to CPU platform, except instruction syntax changes.
There are keyboard shortcuts that assigned to events like above and they are explained here for convenience.

In the Code Pane:
Enter: Edits the current line
Insert: Inserts a new code line into the current line
Delete: Deletes the current code line
Home: Jumps to the beginning of code (offset 0000)
End: Jumps to the end of code (last offset address)
Page Up: Scroll the code pane view 15 lines up
Page Down: Scroll the code pane view 15 lines down
Ctrl+Page Up: Scroll the code pane view 60 lines up
Ctrl+Page Down: Scroll the code pane view 60 lines down
Shift+A: Go to an address entered by user
Shift+O: Go to origin, which is the current code line
Shift+C: Caller; returns to the entry point within a "call" function
Shift+F: Fallow; fallows a "call" or "jump" function entry point
Shift+N: New Origin; marks the current code line as origin
Shift+S: Searches a given string or hexadecimal byte(s) in memory
Shift+L: Continues to search again

In the Data Pane:
Enter: Edits current byte
Insert: Inserts byte(s) or string
Ctrl+Page Up: Scroll the data pane view 60 lines up
Ctrl+Page Down: Scroll the data pane view 60 lines down
Shift+A: Go to an address entered by user
Shift+O: Go to origin, which is the current code line
Shift+S: Searches a given string or hexadecimal byte(s) in memory
Shift+L: Continues to search again

In the Register Pane:
Enter: Changes the current register value
Numerical Pad (+) : Increases the current register value
Numerical Pad (-) : Decreases the current register value

In the Flags Pane:
Enter: Toggles the current flag bit

In the Stack Pane:
Enter: Changes the current stack value

2.3 General Usage

Though the Sim8085 is a visual Win32 program, the usage is more likely based on keyboard rather than mouse. Although mouse has the same functionality, keyboard shortcuts make the life easy and quick. With mouse, user can click to the related function buttons or can simply select the function from the main menu. (see figure 2.6) The set of shortcuts for keyboard usage are listed below:

In the Editor Mode:
File Menu, New File: Ctrl+Shift+N
File Menu, Open File: Ctrl+Shift+O
File Menu, Save File: Ctrl+Shift+S
File Menu, Close File: Ctrl+Shift+C
File Menu, Print File: Ctrl+P
File Menu, Exit Program: Alt+X

Edit Menu, Undo: Ctrl+Z
Edit Menu, Redo: Ctrl+D
Edit Menu, Cut: Ctrl+X
Edit Menu, Copy: Ctrl+C
Edit Menu, Paste: Ctrl+V
Edit Menu, Select All: Ctrl+A
Edit Menu, Find: Ctrl+F
Edit Menu, Replace: Ctrl+R

Project Menu, Compile: Ctrl+F9
Project Menu, Debug: Ctrl+F10

In the Debugger Mode:
Project Menu, Terminate: Ctrl+F2
Project Menu, ReLoad: Ctrl+L
Project Menu, Trace Into: F7
Project Menu, Step Over: F8
Project Menu, Run Here: F4
Project Menu, Run: F9
Project Menu, Breakpoint: F5
Project Menu, Breakpoint State Change: Ctrl+F5
Tools Menu, Show Ports: Ctrl+Alt+P
Next Pane: F6 or Ctrl+Right Arrow
Previous Pane: Shift+F6 or Ctrl+Left Arrow

In General:
Tools Menu, Ascii Table: Ctrl+Alt+A
Tools Menu, Base Converter: Ctrl+Alt+B
Tools Menu, Character Map: Ctrl+Alt+C
Tools Menu, Hex Calculator: Ctrl+Alt+H
Tools Menu, Keyboard Scan Codes: Ctrl+Alt+S
Navigation: Arrow Keys

There're other menu items that are not listed here, which don't have keyboard shortcuts but can be accessed through the main menu.Sim8085 can accept a file name as a parameter when it first runs. Also, it has a buffer to keep the last opened five files for quick accessing. All the settings can be made within the "Options" menu.



In this project, simulation of Intel 8085 microprocessor instructions on a different CPU and operating system is discussed. For this purpose, a program, which called as Sim8085, is written in a high level visual language on an Intel 80386 based CPU and Windows 95 based operating system. For the point of engineering, program developing on an 8085-p environment is hard and hence, means that losing time. With the Sim8085, writing 8085-p assembly language based algorithms and checking them for error is so much easy; Sim8085 has come over all these difficulties easily.



Gaonkar, Ramesh S., 1989, "Microprocessor Architecture, Programming, and Applications", Macmillan Publishing Company, New York, Second Edition.