Untitled Document

Microprocessor Simulator V5.0 Help

Website

Home | Previous | Next

General

Tutorials

Reference

Introduction
Architecture
Installation
Un-Installation
To Register
Registration Form
FAQ and Bugs
PC Support Handbook

Use Alt+Tab to switch
between the help and
simulator windows.

Getting Started
All Learning Tasks
01 First Program
-- Nasty Example
02 Traffic Lights
03 Data Moves
04 Counting
05 Keyboard Input
06 Procedures
07 Text I/O
08 Data Tables
09 Parameters
10 SW Interrupts
11 HW Interrupts

Shortcut Keys
ASCII Codes
Glossary
 Hexadecimal and Binary
Instruction Set Summary
Instruction Set Detailed
The List File
Negative Numbers
Pop-up Help
Logic and Truth
The Editor
Peripheral Devices

This simulator is for learners in the 16+ age range although many younger enthusiasts have used it too. It introduces low level programming and microcomputer architecture. Tutorial materials are included covering the subject in some depth.

The tutorials align closely with the British GCE A2 Computing specifications and also the British BTEC National for IT Practitioners (Computer Systems).

The simulator has enough depth and flexibility to be used with university undergraduate students studying low level programming for the first time.

Home | Previous | Next

© C Neil Bauers 2003


Introduction

Who Should Use the Simulator

The simulator is intended for any student studying low level programming, control or machine architecture for the first time.

The simulator can be used by students aged 14 to 16 to solve less complex problems such as controlling the traffic lights and snake.

More advanced students typically 16 or older can solve quite complex low level programming problems involving conditional jumps, procedures, software and hardware interrupts and Boolean logic. Although programs will be small, there is good scope for modular design and separation of code and data tables.

The simulator is suitable for courses such as

  • BTEC National Diploma for IT Practitioners (Computer Systems and Control Technology)
  • AS and A2 Computing (Low Level Programming)
  • Electronics Courses.
  • Courses involving microcontrollers.
  • Courses involving control systems.

Description of the Simulator

In the shareware version the following instructions are not included. CALL, RET, INT and IRET. The hardware timer interrupt does not function because IRET can not be used either. The registered version includes these features. You can register the software here.

This simulator emulates an eight bit CPU that is similar to the low eight bits of the 80x86 family of chips. 256 bytes of RAM are simulated. It is surprising how much can be done with only 256 bytes or RAM.

Features

  • 8 bit CPU
  • 16 Input Output ports. Not all are used.
  • Simulated peripherals on ports 0 to 5.
  • An assembler.
  • On-line help.
  • Single step through programs.
  • Continuously run programs.
  • Interrupt 02 triggered by a hardware timer (simulated).
  • CPU Clock Speed can be altered.

Peripherals

Example Programs
  • Keyboard Input
  • 99keyb.asm
  • Traffic Lights
  • 99tlight.asm
  • Seven Segment Display
  • 99sevseg.asm
  • Heater and Thermostat
  • 99hon.asm and 99hoff.asm
  • Snake and Maze
  • 99snake.asm
  • Stepper Motor
  • 99step.asm
  • Memory Mapped VDU
  • 99keyb.asm

Documentation

On-line hypertext help is stored in a Website. It is possible to copy from the help pages and paste into a word processor or text editor programs. Registered users have permission to modify help files for use by students and to print and or make multiple photocopies.

Disclaimer

This simulation software is not guaranteed in any way. It may differ from reality. It might not even work at all. Try it out and if you like it, please register.


System Architecture

Simplified Simulator Architecture

  • central processing unit (CPU)
  • 256 bytes of random access memory (RAM)
  • 16 input output (IO) ports. Only six are used.
  • A hardware timer that triggers interrupt 02 at regular time intervals that you can pre-set using the configuration tab.
  • A keyboard that triggers interrupt 03.
  • Peripherals connected to the Ports.

The simulator is programmable in that you can run many different programs. In real life, the RAM would be replaced by read only memory (ROM) and the system would only ever run one program hard wired into the ROM. There are hundreds of examples of systems like this controlling traffic lights, CD players, simple games consoles, many children's games, TV remote controls, microwave oven timers, clock radios, car engine management systems, central heating controllers, environmental control systems and the list goes on.

The Central Processing Unit

The central processing unit is the "brain" of the computer. All calculations, decisions and data moves are made here. The CPU has storage locations called registers. It has an arithmetic and logic unit (ALU) where the processing is done. Data is taken from the registers, processed and results go back into the registers. Move (MOV) commands are used to transfer data between RAM locations and the registers. There are many instructions, each with a specific purpose. This collection is called the instruction set.

General Purpose Registers

The CPU has four general-purpose registers called AL, BL, CL and DL. These are eight bits or one byte wide. Registers can hold unsigned numbers in the range 0 to +255 and signed numbers in the range –128 to +127. These are used as temporary storage locations. Registers are used in preference to RAM locations because it takes a relatively long time to transfer data between RAM and the CPU. Faster computers generally have more CPU registers or memory on the CPU chip.

The registers are named AL, BL, CL and DL because the 16-bit version of this CPU has more registers called AH, BH, CH and DH. The 'L' means Low and the 'H' means High. These are the low and high ends of the 16-bit register.

Special Purpose Registers

The special purpose registers in the CPU are called IP, SR and SP.

IP is the Instruction pointer

This register contains the address of the instruction being executed. When execution is complete, IP is increased to point to the next instruction. Jump instructions alter the value of IP so the program flow jumps to a new position. CALL and INT also change the value stored in IP. In the RAM displays, the instruction pointer is highlighted red with yellow text.

SR is the Status Register

This register contains flags that report the CPU status.

The 'Z' zero flag is set to one if a calculation gave a zero result.
The 'S' sign flag is set to one if a calculation gave a negative result.
The 'O' overflow flag is set if a result was too big to fit in a register.
The 'I' interrupt is set if interrupts are enabled. See CLI and STI.

SP is the Stack Pointer

The stack is an area of memory organised using the LIFO last in first out rule. The stack pointer points to the next free stack location. The simulator stack starts at address BF just below the RAM used for the video display. The stack grows towards address zero. Data is pushed onto the stack to save it for later use. Data is popped off the stack when needed. The stack pointer SP keeps track of where to push or pop data items. In the RAM displays, the stack pointer is highlighted blue with yellow text.

Random Access Memory

The simulator has 256 bytes of ram. The addresses are from 0 to 255 in decimal numbers or from [00] to [FF] in hexadecimal. RAM addresses are usually given in square brackets such as [7C] where 7C is a hexadecimal number. Read [7C] as "the data stored at location 7C".

Busses

Busses are collections of wires used to carry signals around the computer. They are commonly printed as parallel tracks on circuit boards. Slots are sockets that enable cards to be connected to the system bus. An 8-bit computer typically has registers 8 bits wide and 8 wires in a bus. A 16-bit computer has 16 bit registers and 16 address and data wires and so on. The original IBM PC had 8 data wires and 20 address wires enabling one megabyte of RAM to be accessed. 32 bit registers and busses are now usual (1997-2003).

Data Bus

The Data Bus is used to carry data between the CPU, RAM and IO ports. The simulator has an 8-bit data bus.

Address Bus

The Address Bus is used to specify what RAM address or IO port should be used. The simulator has an 8-bit address bus.

Control Bus

The Control Bus This has a wire to determine whether to access RAM or IO ports. It also has a wire to determine whether data is being read or written. The CPU reads data when it flows into the CPU. It writes data when it flows out of the CPU to RAM or the IO ports.

The System Clock wire carries regular pulses so that all the electronic components can function at the correct times. Clock speeds between 100 and 200 million cycles per second are typical (1997). This is referred to as the clock speed in MHz or megahertz. The simulator runs in slow motion at about one instruction per second. This is adjustable over a small range.

Hardware Interrupts

Hardware Interrupts require at least one wire. These enable the CPU to respond to events triggered by hardware such as printers running out of paper. The CPU processes some machine code in response to the interrupt. When finished, it continues with its original task. The IBM PC has 16 interrupts controlled by 4 wires.


To Install

Important

FIRST make a back-up copy of the distribution disk or downloaded file.

Print and file Userinfo.Reg. This contains your registration key.

System Requirements

Sms32V50.Exe requires Windows95/98/NT/2000/XP. A mouse or other pointing device is highly recommended to access the hypertext help pages.

To Install

You don't need to run setup. In fact there is no setup program.

Make a folder for all the simulator files and copy them from the distribution disk to this directory. If you have downloaded a Zip file, unzip it into this directory.

Create a shortcut to sms32v50.exe and/or create a shortcut on the start menu.

Suggestion

In a School College or University setting, the exercise files should be made available to students. These files are numbered as in this example - 02tlight.asm and 99snake.asm. The other example files demonstrate the capabilities of the simulator and are typical of the sorts of programs students might write for assignments. DEMO.ASM could be made available.

The other example files should be kept by the teacher for reference.

Note Userinfo.reg, if available, should be in the same directory as Sms32V50.Exe. Userinfo.reg contains the registration key that you need to run the simulator as a registered program. When Userinfo.reg is missing or faulty, the simulator runs in shareware mode. When you register, you will get instructions relating to Userinfo.reg. This file has nothing to do with the Windows registry. It is a text file containing the key. The name is a hangover from the days of Windows 3.11 when there were no registries.

Note The on line help should be in the same directory as Sms32V50.Exe

Network Installation

The simulator has been designed to run from a server. It does not need to be installed on workstations. This makes deployment simple. One day all software will be like this and stressed out network administrators will revert to being normal, kind, cheerful human beings.

Create a read only folder on the server and make sure all users can access it. (Create a share or use a public drive). Copy all the files from the distribution into the folder on the server. If they are zipped, unzip them. Provide a shortcut to sms32v50.exe for users to start up the program. The shortcut should specify a working directory where users have write permission such as their home folder.

Users need write access to their own home folder (a floppy disk would be OK too). Users need to save their work to this folder (or floppy). If the simulator starts in this directory, it will save an INI file in the user's directory that holds information about window positions and preferences. If the INI file is missing, the simulator will start with default settings and will attempt to create the INI file. If SMS starts in a read only directory, it will not be able to save its INI file. If possible, correct this non fatal problem.

To Run

If you have set up an icon, double click the icon or select the icon and press enter. You can double click on Sms32V50.exe within Windows Explorer or My Computer. You can drag and drop an assembly code file onto the program icon. Assembly code file names should end in .asm. You can drop any type of file into the simulator but the result is not likely to be useful.


To Un-Install

Important

FIRST make a back-up copy of the distribution disk or downloaded file.

Print and file Userinfo.Reg. This contains your registration key.

To Un-install

The simulator is completely self contained and can be deleted without upsetting any other applications. Using Windows Explorer or My Computer or Network Neighborhood (for a network installation) delete all the files in the simulator directory. Remove any icons or other references to the simulator from your system. There are NO registry entries or DLL files so the un-install is completely clean.


To Register

Please visit the website for registration information. If you have no internet access, please use this form.

When You Register

You will be sent a software key that unlocks all the features in the simulator. You should enter this key into the place provided. The menu choice for entering your key is

Help - Register Alt+H R

Type or paste your key into the space provided and press the Register button. If there are no spelling errors, the simulator will be registered.

Shareware

The Microcontroller Simulator is shareware. In the unregistered shareware version the following features are not included. CALL, RET, INT, IRET and the simulated hardware timer interrupt 02.

Distribution

The complete unaltered shareware package may be distributed freely without restriction. Re-packaging to suit different distribution media is permitted. Please give a copy to any interested friend, colleague or student.

Copyright

© C N Bauers - 2003 applies to all parts of this product.
EMail nbauers@samphire.demon.co.uk

Student Registration

Individual students may use this software free. There is no need to register. Students may also use registered copies free of charge. These copies should, whenever possible, be obtained from your school, college or university.

Educational Institutions

Schools, Colleges, Universities and other Educational Institutions are asked to register. When you register, you will receive a key that unlocks the full version of this software. The prompts to register will go away and CALL, RET, INT, IRET and simulated hardware timer interrupts will be made available.

Payment

You are asked to register this software by paying 25 Euros (15.00 Pounds Sterling in the UK). To register quickly, use the on-line service. Alternatively please send a cheque in your local currency for the equivalent of 25 Euros. Cash is OK as a last resort. I hope to cover my software and Internet access costs. Please make cheques payable to C N BAUERS.

Registered Sites

All users are invited to visit the website regularly for upgrades and updates. Registered sites may photocopy manuals and help pages as required. You may give registered copies of the software to your students. These copies should be free. You may run unlimited instances of the software on a single site. If you have multiple sites in different villages, towns or cities, you are asked to register and pay for each site separately.

Local Education Authorities

You can register ALL the schools in your area. The cost is 10 Euros per school with learners over the age of 16. This software is intended for the 16+ age group but you may deploy the program for younger pupils too. Schools can download their own software. The registration key can be distributed in a letter to each school or in a newsletter.

Here is an example of a registration key (you will get a valid key)

Bawsetshire Local Education AuthorityABCDE

Home | Previous | Next

© C Neil Bauers 2003


Registration Form

Simulator Registration Form

The fastest way to register is on-line. If you can't use this service, please use this form.

Please fill in this form and mail it to the address below. These details will not be passed to any junk mail organisation.

Educational institutions should include a cheque for 15 GB Pounds OR 25 Euros OR 30 US Dollars OR the equivalent in your own currency.

Cheques should be made payable to C N Bauers.

Please mail me at nbauers@samphire.demon.co.uk to agree a price in your local currency.

Please check this address is up-yo-date on the website.

C N Bauers
87 Cliff Hill
Gorleston
Great Yarmouth
Norfolk
NR31 6DH
United Kingdom

Please provide your details below (please write clearly!) ...

Contact Person ___________________________________________

Institution Name _________________________________________

Institution Address ______________________________________

__________________________________________________________

__________________________________________________________

__________________________________________________________

__________________________________________________________

__________________________________________________________

Your EMail address _______________________________________


Bugs

FAQ and Bugs

Bugs and Features

Here are some bugs and features that I know about.

If you discover other problems, please send me an E Mail.

I will cure the easy bugs and list the hard ones here.

Is there a Discussion Forum?

Yes - it is here - http://groups.yahoo.com/group/learn-asm/

Why is my display messed up?

The simulator was developped using the default windows fonts, colours and borders. Some combinations of colours, fonts and window borders have caused problems. The symptoms include invisible text, text that won't fit inside the window, labels that don't line up with the item they are supposed to label and stretched bitmap images that look untidy. The cure is to use Windows default settings or compatible settings.

Where are my windows?

Beginners and some experts might hit another problem. With the display in a high resolution mode, the simulator windows can be moved towards the bottom right. When the display is restored to a lower resolution and the simulator is re-started, all its windows will be off screen where thay can't be seen or controlled. The cure is to close the simulator and delete Sms32V50.INI. The simulator will restart with its windows in default visible positions.

Why won't this file save? "Sms32v50.Ini"

This is common on a network installation. Make sure the working directory is one that you have permission to write to.

Why can't I save my work?

Make sure you are saving to a folder or directory where you have write permission. This problem usually occurs when you are running the simulator from a network installation.


PC Support Handbook

The PC Support Handbook

This is an excellent book for anyone learning about personal computer hardware.

Details are at http://www.dumbreck.demon.co.uk/

This book covers PC architecture in some detail and makes excellent further reading in conjunction with the use of this simulator.

The book's ISBN reference is 09541711-1-X and it is available in the following ways:

  • From all major book distributors.
  • From the Maplin chain of stores or Maplin mail/web order.
  • Directly from the publishers, Dumbreck Publishing. This is often the quickest method.

Please get up-to-date contact details from their website.

PC Support Handbook Contents

  • Computer Basics
  • Software & Data
  • Operating Systems
  • Numbering Systems
  • Computer Architecture
  • Display Technology
  • Computer Memory
  • Discs & Drives
  • Computer Peripherals
  • System Selection
  • Hardware Installation
  • P.C. Configuration
  • Windows Configuration
  • P.C. Support
  • Faultfinding
  • Computer Security
  • Data Communications
  • Local Area Networks
  • The Internet
  • Creating Websites
  • Multimedia


Getting Started

Using the Simulator - Getting Started

On Line Help

Press the F1 key to get on line help.

Writing a Program

To write and run a program using the simulator, select the source code editor tab by pressing Alt+U.

Type in your program. It is best to get small parts of the program working rather than typing it all in at once.

Here is a simple example. Also look at the tutorial example programs. You can type this into the simulator or copy and paste it. The assembly code has been annotated with comments that explain the code. These comments are ignored by the assembler program. Comments begin with a semicolon and continue to the end of the line.

; ===== COUNT =================================================
    MOV	AL,0	; Move 0 into the AL register
REP:			; This label is used with jump commands
    ADD	AL,2	; Add two to AL
    JMP	REP	; Jump back to the rep label

    END		; Program ends here
; =============================================================

Running a Program

To run a program, you can step through it one line at a time by pressing Alt+P or by clicking this button repeatedly.
You can run a program continuously by pressing F9 or Alt+R or by pressing this button
To speed up or slow down a running program use these buttons or type Alt+L or Alt+T
To stop a running program press Alt+O or click or press Escape or press this button.
To restart a paused program, continuing from where it left off, press Alt+N or click this button.
To restart a program from the beginning, reset the CPU by pressing Alt+E or click this button.
To re-open the RAM display window, press Alt+M or click this button.

Assembly Code

 The code you type is called assembly code. This human-readable code is translated into machine code by the Assembler. The machine code (binary) is understood by the CPU. To assemble a program, press Alt+A or click this button.
You can see an animation of the assembler process by checking this box.
When you run or setp a program, if necessary, the code is assembled.

Assembler Phases

There is short delay while the assembbler goes through all the stages of assembling the program. The steps are

  1. Save the source code.
  2. Convert the source code into tokens (this simulator uses human readable tokens for educational value rather than efficiency).
  3. Parse the source code and (if necessary) generate error messages. If there are no errors, generate the machine codes. This process could be coded more efficiently. If the tokens representing machine op codes like MOV and JMP were numerical, the assembler could look up the machine code equivalents in an array instead of ploughing through many if-then-else statements. Once again, this has been done to demonstrate the process of assembling code for educational reasons.
  4. Calculate jumps, the distances of the jump/branch instructions.

Viewing Machine Code

The machine code stored in RAM can be viewed in three modes by selecting the appropriate radio button.

Hexadecimal - This display corresponds exactly to the binary executed by the CPU.

ASCII - This display is convenient if your program is processing text. The text is readable but the machine codes are not.

Source Code - This display shows how the assembly code commands are placed in memory.

Tutorial Examples

The tutorial examples provide a step by step introduction to the commands and techniques of low level programming. Each program has one or more learning tasks associated with it. Some of the tasks are simple. Some are real brain teasers.


Learning Tasks

The Tasks

Here are all the learning tasks grouped together with pointers to the example programs and explanatory notes.

Simple Arithmetic

Example - 01first.asm - Arithmetic

  1. Write a program that subtracts using SUB
  2. Write a program that multiplies using MUL
  3. Write a program that divides using DIV
  4. Write a program that divides by zero. Make a note to avoid doing this in real life.

Using Hexadecimal

Example - 02tlight.asm - Traffic Lights

  5. Use the help page on Hexadecimal and Binary numbers. Work out what hexadecimal numbers will activate the correct traffic lights. Modify the program to step the lights through a realistic sequence.

ASCII Codes

Example - 03move.asm

  6. Look up the ASCII codes of H, E, L, L and O and copy these values to memory locations C0, C1, C2, C3 and C4. This is a simple and somewhat crude way to display text on a memory mapped display.

Counting and Jump Commands

Example - 04incjmp.asm

  7. Rewrite the example program to count backwards using DEC BL.
  8. Rewrite the example program to count in threes using ADD BL,3.
  9. Rewrite the program to count 1 2 4 8 16 using MUL BL,2
  10. Here is a more difficult task. Count 0 1 1 2 3 5 8 13 21 34 55 98 overflow. Here each number is the sum of the previous two. You will need to use two registers and two RAM locations for temporary storage of numbers. If you have never programmed before, this is a real brain teaser. Remember that the result will overflow when it goes above 127.
    This number sequence was first described by Leonardo Fibonacci of Pisa (1170_1230)

Character Input Output

Example - 05keybin.asm

  11. Easy! Input characters and display each character at the top left position of the VDU by copying them all to address [C0].
  12. Harder Use BL to point to address [C0] and increment BL after each key press in order to see the text as you type it.
  13. Harder! Store all the text you type in RAM when you type it in. When you press Enter, display the stored text on the VDU display.
  14. Difficult Type in text and store it. When Enter is pressed, display it on the VDU screen in reverse order. Using the stack makes this task easier

Procedures

Example - 06proc.asm

  15. Re-do the traffic lights program and use this procedure to set up realistic time delays. 02tlight.asm
  16. Re-do the text input and display program with procedures. Use one procedure to input the text and one to display it.

Text IO and Procedures

Example - 07textio.asm

  17. Write a program using three procedures. The first should read text from the keyboard and store it in RAM. The second should convert any upper case characters in the stored text to lower case. The third should display the text on the VDU screen.

Data Tables

Example - 08table.asm

  18. Improve the traffic lights data table so there is an overlap with both sets of lights on red.
  19. Use a data table to navigate the snake through the maze. This is on port 04. Send FF to the snake to reset it. Up, down left and right are controlled by the left four bits. The right four bits control the distance moved.
  20. Write a program to spin the stepper motor. Activate bits 1, 2, 4 and 8 in sequence to energise the electromagnets in turn. The motor can be half stepped by turning on pairs of magnets followed by a single magnet followed by a pair and so on.
  21. Use a data table to make the motor perform a complex sequence of forward and reverse moves. This is the type of control needed in robotic systems, printers and plotters. For this exercise, it does not matter exactly what the motor does.

Parameters

Example - 09param.asm

  22. Write a procedure that doubles a number. Pass the single parameter into the procedure using a register. Use the same register to return the result.
  23. Write a procedure to invert all the bits in a byte. All the zeros should become ones. All the ones should become zeros. Pass the value to be processed into the procedure using a RAM location. Return the result in the same RAM location.
  24. Write a procedure that works out Factorial N. This example shows one method for working out factorial N. Factorial 5 is 5 * 4 * 3 * 2 * 1 = 120. Your procedure should work properly for factorial 1, 2, 3, 4 or 5. Factorial 6 would cause an overflow. Use the stack to pass parameters and return the result. Calculate the result. Using a look up table is cheating!
  25. Write a procedure that works out Factorial N. Use the stack for parameter passing. Write a recursive procedure. Use this definition of Factorial.
    Factorial ( 0 ) is defined as 1.
    Factorial ( N ) is defined as N * Factorial (N - 1).
    To work out Factorial (N), the procedure first tests to see if N is zero and if not then re-uses itself to work out N * Factorial (N - 1). This problem is hard to understand in any programming language. In assembly code it is harder still.

Software Interrupts

Example - 10swint.asm

  26. The simulated keyboard generates INT 03 every time a key is pressed. Write an interrupt 03 handler to process the key presses. Use IN 07 to fetch the pressed key into the AL register. The original IBM PC allocated 16 bytes for key press storage. The 16 locations are used in a circular buffer fashion. Try to implement this.

  27. Build on task 26 by puting characters onto the next free screen location. See if you can get correct behaviour in response to the Enter key being pressed (fairly easy) and if the Back Space key being pressed (harder).

Hardware Interrupts

Example - 11hwint.asm

  28. Write a program that controls the heater and thermostat whilst at the same time counting from 0 to 9 repeatedly, displaying the result on one of the seven segment displays. If you want a harder challenge, count from 0 to 99 repeatedly using both displays. Use the simulated hardware interrupt to control the heater and thermostat.
  29. A fiendish problem. Solve the Tower of Hanoi problem whilst steering the snake through the maze. Use the text characters A, B, C Etc. to represent the disks. Use three of the four rows on the simulated screen to represent the pillars.

    I am not aware of anyone having solved the tower of Hanoi (including me), let alone controlling the snake at the same time.

  30. Use the keyboard on Port 07. Write an interrupt handler (INT 03) to process the key presses. You must also process INT 02 (the hardware timer) but it need not perform any task. For a more advanced task, implement a 16 byte circular buffer. Write code to place the buffered text on the VDU screen when you press Enter. For an even harder task, implement code to process the Backspace key to delete text characters in the buffer.


Example - 01first.asm - Arithmetic

Most of these examples include a learning task. Study the example and if you can complete the task/s, it is likely that your understanding is good.

Example - 01first.asm

; ===== WORK OUT 2 PLUS 2 ======================================
    CLO		; Close unwanted windows.
    MOV AL,2	; Copy a 2 into the AL register.
    MOV BL,2	; Copy a 2 into the BL register.
    ADD AL,BL	; Add AL to BL. Answer goes into AL.
    END		; Program ends
; ===== Program Ends ===========================================

    YOUR TASK
    =========
    Use SUB, DIV and MUL to subtract, divide and multiply.
    What happens if you divide by zero?
    Make use of CL and DL as well as AL and BL.

Type this code into the simulator editor OR copy and paste the code OR load the example from disk.

Step through the program by pressing Alt+P repeatedly.

While you are stepping, watch the CPU registers. You should see a '2' appear in the AL register followed by a '2' in the BL register. AL should be added to BL and a '4' should appear in AL. The altered registers are highlighted yellow.

Watch the register labelled IP (Instruction Pointer). This register keeps track of where the processor has got to in the program. If you look at the RAM display, one RAM location is labelled with a red blob. This corresponds to the Instruction Pointer. Note how the red blob (IP) moves when you step the program.

When doing the learning exercises, add to and modify your own copy of the example.

What you need to know

Comments

Any text after a semicolon is not part of the program and is ignored by the simulator. These comments are used for explanations of what the program is doing. Good programmers make extensive use of comments. Good comments should not just repeat the code. Good comments should explain why things are begin done.

CLO

The CLO command is unique to this simulator. It closes any window that is not needed while a program is running. This command makes it easier to write nice demonstration programs. It also avoids having to close several windows manually.

MOV

The MOV command is short for Move. In this example numbers are being copied into registers where arithmetic can be done. MOV copies data from one location to another. The data in the original location is left intact by the MOV command. Move was shortened to Mov because, in olden times, computer memory was fiendishly expensive. Every command was shortened as much as possible, much like the mobile phone texting language used today.

ADD

Arithmetic

The add command comes in two versions. Here are two examples

ADD AL,BL - Add BL to AL and store the result into AL

ADD AL,5 - Add 5 to AL and store the result into AL

Look at the on-line help to find out about SUB, MUL and DIV. Remeber that you can access on-line help by pressing the F1 key.

Registers

Registers are storage locations where 8 bit binary numbers are stored. The central processing unit in this simulator has four general purpose registers called AL, BL, CL and DL. These registers are interchangeable and can, with a few exceptions, be used for any purpose.

Newer central processing unit (CPU) chips have 16, 32 or even 64 bit registers. These work in the same way but more data can be moved in one step so there is a speed advantage.

Wider registers can store larger integer (whole) numbers. This simplifies many programming tasks. The other three registers SP, IP and SR are described later.

Hexadecimal Numbers

In the command MOV AL,2 the 2 is a hexadecimal number. The hexadecimal number system is used in low level programming because there is a very convenient conversion between binary and hex. Study the Hexadecimal and Binary number systems.

END

The last command in all programs should be END. Any text after the END keyword is ignored.

Your Tasks

Use all the registers AL, BL, CL and DL and experiment with ADD, SUB, MUL and DIV.

Find out what happens if you try to divide by zero.


Example - 99nasty.asm - Nasty

This example shows how you can create totally unreadable code.

Try not to do this.

This program actually works. Copy it and paste it into the simulator and try it!

Click the List-File tab to see the code laid out better and to see the addresses where the code is stored.

To get back to the editor window click the Source-Code tab.

Example - 99nasty.asm

; ----- Here is how NOT to write a program -----
_: Mov BL,C0 Mov AL,3C Q: Mov [BL],AL CMP AL,7B
JZ Z INC AL INC BL JMP Q Z: MOV CL,40 MOV AL,20
MOV BL,C0 Y: MOV [BL],AL INC BL DEC CL JNZ Y JMP
_ END ; Look at the list file. It comes out OK!
; Press Escape to stop the program running.
; ----------------------------------------------

Here it is tidied up

; ----- A Program to display ASCII characters -----------------
; ----- Here it is tidied up. This version is annotated. ------
; ----- This makes it possible to understand. -----------------
; ----- The labels have been given more readable names too. ---

Start:
    Mov BL,C0	; Make BL point to video RAM
    Mov AL,3C	; 3C is the ASCII code of the 'less than' symbol
Here:
    Mov [BL],AL	; Copy the ASCII code in AL to the RAM location that BL is pointing to.
    CMP AL,7B	; Compare AL with '{'
    JZ Clear	; If AL contained '{' jump to Clear:
    INC AL		; Put the next ASCII code into AL
    INC BL		; Make BL point to the next video RAM location
    JMP Here	; Jump back to Here
Clear:
    MOV CL,40	; We are going to repeat 40 (hex) times
    MOV AL,20	; The ASCII code of the space character
    MOV BL,C0 	; The address of the start of video RAM
Loop:
    MOV [BL],AL	; Copy the ASCII space in AL to the video RAM that BL is pointing to.
    INC BL		; Make BL point to the next video RAM location
    DEC CL		; CL is counting down towards zero
    JNZ Loop	; If CL is not zero jump back to Loop
    JMP Start	; CL was zero so jump back to the Start and do it all again.

    END
; -------------------------------------------------------------

Your Task

Write all your future programs ...

  • with good layout
  • with meaningful label names
  • with useful comments that EXPLAIN the code
  • avoiding comments that state the totally obvoius and just repeat the code

Bad Comment - just repeats the code

INC BL ; Add one to BL

Useful Comment - explains why the step is needed

INC BL ; Make BL point to the next video RAM location


Example - 02tlight.asm - Traffic Lights

Example - 02tlight.asm

; ===== CONTROL THE TRAFFIC LIGHTS =============================

    CLO		; Close unwanted windows.
Start:
            ; Turn off all the traffic lights.
    MOV AL,0	; Copy 00000000 into the AL register.
    OUT 01		; Send AL to Port One (The traffic lights).
            ; Turn on all the traffic lights.
    MOV AL,FC	; Copy 11111100 into the AL register.
    OUT 01		; Send AL to Port One (The traffic lights).
    JMP Start	; Jump back to the start.
    END		; Program ends.

; ===== Program Ends ==========================================

    YOUR TASK
    =========
    Use the help page on Hexadecimal and ASCII codes.
    Work out what hexadecimal numbers will activate the
    correct traffic lights. Modify the program to step
    the lights through a realistic sequence.

To run the program press the Step button repeatedly or press the Run button.

To stop the program, press Stop. When the program is running, click the RAM-Source or RAM-Hex or RAM-ASCII tabs. These give alternative views of the contents of random access memory (RAM).

Also click the List File tab to see the machine code generated by the simulator and the addresses where the codes are stored.

Ports

The traffic lights are connected to port one. Imagine this as a socket on the back of the processor box. Data sent to port one goes to the traffic lights and controls them.

There are six lamps to control. Red, Amber and Green for a pair of lights. This can be achieved with a single byte of data where two bits are unused.

By setting the correct bits to One, the correct lamps come on.

Fill in the rest of this table to work out the Hexadecimal values you need. Of course you need to know the sequence of lights in your country.

Red | Amber | Green | Red | Amber | Green | Unused | Unused | Hexadecimal
1 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 84

What you need to know

Labels and Jumps

Labels mark positions that are used by Jump commands. All the commands in this program are repeated for ever or until Stop is pressed. Label names must start with a letter or _ character. Label names must not start with a digit. The line

JMP Start

causes the program to jump back and re-do the earlier commands.

Destination labels end in a colon. For example

Start:

Controlling the Lights

If you look carefully at the traffic lights display, you can see which bit controls each light bulb. Work out the pattern of noughts and ones needed to turn on a sensible set of bulbs. Use the Hexadecimal and Binary numbers table to work out the hexadecimal equivalent. Move this hexadecimal number into AL.

OUT 01

This command copies the contents of the AL register to Output Port One. The traffic lights are connected to port one. A binary one causes a bulb to switch on. A nought causes it to turn off.


Example - 03move.asm - Data Moves

Example - 03move.asm

; ---------------------------------------------------------------

; A program to demonstrate MOV commands. Mov is short for move.

; ---------------------------------------------------------------
    CLO		; Close unwanted windows.
; ===== IMMEDIATE MOVES =====
    MOV	AL,15	; Copy 15 HEX into the AL register
    MOV	BL,40	; Copy 40 HEX into the BL register
    MOV	CL,50	; Copy 50 HEX into the CL register
    MOV	DL,60	; Copy 60 HEX into the DL register
Foo:
    INC AL		; Increment AL for no particular reason.

; ===== INDIRECT MOVES =====
    MOV	[A0],AL	; Copy value in AL to RAM location [40]
    MOV	BL,[40]	; Copy value in RAM location [A0] into BL

; ===== REGISTER INDIRECT MOVES =====
    MOV	[CL],AL ; Copy the value in AL to the RAM
            ; location that CL points to.
    MOV	BL,[CL] ; Copy the RAM location that CL points
            ; to into the BL register.

    JMP Foo		; PRESS ESCAPE TO STOP THE PROGRAM

    END
; ---------------------------------------------------------------
    TASK
    ====
    Look up the ASCII codes of the letters in H,E,L,L,O and move
    these ASCII codes to RAM addresses [C0], [C1], [C2], [C3]
    and [C4]. Run the program and watch how the text appears on
    the simulated VDU display. This is very much the same as what
    happens in the IBM PC running MS DOS. The program you write
    should work but if you continue to study low level programming,
    you will find much more efficient and flexible ways of solving
    this problem.

Step through the program and watch the register values changing. In particular, look at the RAM-Hex display and note the way that values in RAM change. Addresses [50] and [A0] are altered. You can copy the example program from the help page and paste it into the source code editor.

Addresing Modes

There are several ADDRESSING MODES available with move commands.

Immediate Addressing

A hexadecimal number is copied into a register. Examples...

MOV AL,15 ; Copy 15 HEX into the AL register
MOV BL,40 ; Copy 40 HEX into the BL register
MOV CL,50 ; Copy 50 HEX into the CL register
MOV DL,60 ; Copy 60 HEX into the DL register

Indirect Addressing

A value is moved to or from RAM. The ram address is given as a number like [22] in square brackets. Examples...

MOV [A0],AL ; Copy value in AL to RAM location [40]
MOV BL,[40] ; Copy value in RAM location [A0] into BL

Register Indirect Addressing

Copy a value from RAM to a register or copy a value from a register to RAM. The RAM address is contained in a second register enclosed in square brackets like this [CL]. Examples ...

MOV [CL],AL ; Copy the value in AL to the RAM location that CL points to.
MOV BL,[CL] ; Copy the RAM location that CL points to into the BL register.

Register Moves

Not available in this simulation.

A register move looks like this

MOV AL,BL

To do this using simulator commands, use

PUSH BL
POP AL

Push and Pop are explained later.

Calculated Addresses

Not available in this simulator.

Copy a value from RAM to a register or copy a value from a register to RAM. The RAM address is contained in square brackets and is calculated. This is done to simplify access to record structures. For example a surname might be stored 12 bytes from the start of the record. This technique is shown in the examples below.

MOV [CL + 5],AL ; Copy the value in AL to the RAM location that CL + 5 points to.
MOV BL,[CL + 12] ; Copy the RAM location that CL + 12 points to into the BL register.

Implied Addresses

Not available in this simulator.

In this case, memory locations are named. Address [50] might be called 'puppy'. This means that moves can be programmed like this.

MOV AL,puppy ; Copy the value in RAM at position puppy into the AL register.
MOV puppy,BL ; Copy BL into the RAM location that puppy refers to.


Example - 04IncJmp.asm - Counting

Example - 04IncJmp.asm

; ===== Counting ===================================

    MOV	BL,40	; Initial value stored in BL

Rep:			; Jump back to this label
    INC	BL	; Add ONE to BL
    JMP	Rep	; Jump back to Rep

    END		; Program Ends

; ===== Program Ends ===============================

    TASK
    =====

    Rewrite the program to count backwards using DEC BL.

    Rewrite the program to count in threes using ADD BL,3.

    Rewrite the program to count 1 2 4 8 16 using MUL BL,2

    Here is a more difficult task.
    Count 0 1 1 2 3 5 8 13 21 34 55 98 overflow.
    Here each number is the sum of the previous two.
    You will need to use registers or RAM locations
    for temporary storage of the numbers.
    If you have never programmed before, this is a real brain teaser.
    Remember that the result will overflow when it goes above 127.

    This number sequence was first described by
    Leonardo Fibonacci of Pisa (1170_1230)

The program counts up in steps of one until the total is too big to be stored in a single byte. At this point the calculation overflows. Watch the values in the registers. In particular, watch IP and SR. These are explained below.

Although this program is very simple, some new ideas are introduced.

MOV BL,40

This line initialises BL to 40.

Rep:

Rep: is a label. Labels are used with Jump commands. It is possible for programs to jump backwards or forwards. Because of the way numbers are stored, the largest jumps are -128 backwards and + 127 forwards. Labels must begin with a letter or the _ character. Labels may contain letters, digits and the _ character. Destination labels must end with a Colon:

INC BL

This command adds one to BL. Watch the BL register. It will count up from 40 in hexadecimal so after 49 comes 4A, 4B, 4C, 4D, 4E, 4F, 50, 51 and so on.

Overflow

When BL reaches 7F hex or 127 in decimal numbers the next number ought to be 128 but because of the way numbers are stored in binary, the next number is minus 128. This effect is called an OVERFLOW.

Status Register (SR)

The status register labelled SR contains four flag bits that give information about the state of the CPU. There are three flags that indicate whether a calculation overflowed, gave a negative result or gave a zero result. Calculations set these flags

  • S The sign flag indicates a negative result.
  • O The overflow flag indicates overflows.
  • Z The zero flag indicates a zero result.
  • I Interrupts enabled. STI turns this on. CLI turns this off.

These flags are described in more detail later.

JMP Rep

This command causes the central processing unit (CPU) to jump back and repeat earlier commands or jump forward and skip some commands.

Instruction Pointer (IP)

The instruction pointer labelled IP contains the address of the instruction being executed. This is indicated by a red highlighted RAM position in the simulator. Each CPU command causes the IP to be increased by 1, 2 or 3 depending on the size of the command. In the RAM displays, the instruction pointer is highlighted red with yellow text.

    NOP		; Increase IP by 1
    INC BL		; Increase IP by 2
    ADD AL,BL	; Increase IP by 3
    JMP Rep		; Add or subtract a value from IP to
            ; jump to a new part of the program.

Fetch Execute Cycle

Fetch the instruction. IP points to it. This is called the operator.
If necessary, fetch data. IP + 1 points to it. This is the first operand.
If necessary, fetch data. IP + 2 points to it. This is the second operand.
Execute the command. This may involve more fetching or putting of data.
Increase IP to point to the next command or calculate IP for Jump commands.
Repeat this cycle.

Every machine cycle has one operator or instruction. There could be zero, one or two operands depending on the instruction. OP Codes are the machine codes that correspond to the operators and operands.


Example - 05keyb-in.asm - Keyboard Input

Example - 05keyb-in.asm

; --------------------------------------------------------------
;  Input key presses from the keyboard until Enter is pressed.
; --------------------------------------------------------------
    CLO		; Close unwanted windows.
Rep:
    IN	00	; Wait for key press - Store it in AL.
    CMP	AL,0D	; Was it the Enter key? (ASCII 0D)
    JNZ	Rep	; No - jump back.  Yes - end.

END
; --------------------------------------------------------------
TASK

11)	Easy!  Display each character at the top left position of the
    VDU by copying them all to address [C0].

12)	Harder  Use BL to point to address [C0] and increment BL after
    each key press in order to see the text as you type it.

13)	Harder!  Store all the text you type in RAM when you type it in.
    When you press Enter, display the stored text on the VDU display.

14)	Difficult  Type in text and store it.  When Enter is pressed,
    display it on the VDU screen in reverse order.  Using the stack
    makes this task easier.

You can copy this example program from the help page and paste it into the source code editor.

IN 00

Input from port zero. In this simulator, port zero is wired to the keyboard hardware. The simulator waits for a key press and copies the ASCII code of the key press into the AL register. This is not very realistic but is easy to program. There is a more realistic keyboard on port 07 and interrupt 03 but this is for more advanced programmers.

CMP AL,0D

Compare the AL register with the ASCII code of the Enter key. The ASCII code of the Enter key is 0Dhex.

CMP AL,BL works as follows. The processor calculates AL - BL. If the result is zero, the 'Z' flag in the status register SR is set. If the result is negative, the 'S' flag is set. If the result is positive, no flags are set. The 'Z' flag is set if AL and BL are equal. The 'S' flag is set if BL is greater then AL. No flag is set if AL is greater than BL.

JNZ Rep

JNZ stands for Jump Not Zero. Jump if the 'Z' flag is not set. The program will jump forwards or back to the address that Rep marks.

A related command is JZ. This stands for Jump Zero. Jump if the zero flag is set. In this program, the CMP command sets the flags. Arithmetic commands also set the status flags.

MOV [C0],AL

This will copy AL to address [C0]. The visual display unit works with addresses [C0] to [FF]. This gives a display with 4 rows and 16 columns. Address [C0] is the top left corner of the screen.

MOV [BL],AL

This copies AL to the address that BL points to. BL can be made to point to the VDU screen at [C0] by using MOV BL,C0. BL can be made to point to each screen position in turn by using INC BL. This is needed for task 2.


Example - 06proc.asm - Procedures

Example - 06proc.asm

; ---------------------------------------------------------------

;  A general purpose time delay procedure.

;  The delay is controlled by the value in AL.

;  When the procedure terminates, the CPU registers are
;  restored to the same values that were present before
;  the procedure was called. Push, Pop, Pushf and Popf
;  are used to achieve this.  In this example one procedure

;  is re-used three times.  This re-use is one of the main
;  advantages of using procedures.

;------ The Main Program ----------------------------------------
Start:
    MOV	AL,8	; A short delay.
    CALL	30	; Call the procedure at address [30]

    MOV	AL,10	; A middle sized delay.
    CALL	30	; Call the procedure at address [30]

    MOV	AL,20	; A Longer delay.
    CALL	30	; Call the procedure at address [30]

JMP	Start	; Jump back to the start.

; ----- Time Delay Procedure Stored At Address [30] -------------
    ORG	30	; Generate machine code from address [30]

    PUSH	AL	; Save AL on the stack.
    PUSHF		; Save the CPU flags on the stack.
Rep:
    DEC	AL	; Subtract one from AL.
    JNZ	REP	; Jump back to Rep if AL was not Zero.

    POPF		; Restore the CPU flags from the stack.
    POP	AL	; Restore AL from the stack.

    RET		; Return from the procedure.
; ---------------------------------------------------------------
    END
; ---------------------------------------------------------------

TASK

15)	Re-do the traffic lights program and use this procedure
    to set up realistic time delays.  02tlight.asm

16)	Re-do the text input and display program with procedures.
    Use one procedure to input the text and one to display it.

; ---------------------------------------------------------------

You can copy this example program from the help page and paste it into the source code editor.

MOV AL,8

A value is placed into the AL register before calling the time delay procedure. This value determines the length of the delay.

CALL 30

Call the procedure at address [30]. This alters the instruction pointer IP to [30] and the program continues to run from that address. When the CPU reaches the RET command it returns to the address that it came from. This return address is saved on the stack.

Stack

This is a region in memory where values are saved and restored. The stack uses the Last In First Out rule. LIFO. The CALL command saves the return address on the stack. The RET command gets the saved value from the stack and jumps to that address by setting IP.

ORG 30

Origin at address [30]. ORG specifies at what RAM address machine code should be generated. The time delay procedure is stored at address [30].

PUSH AL

Save the value of AL onto the stack. The CPU stack pointer SP points to the next free stack location. The push command saves a value at this position. SP is then moved back one place to the next free position. In this simulator, the stack grows towards address Zero. A stack overflow occurs if the stack tries to fill more than the available memory. A stack underflow occurs if you try to pop an empty stack.

PUSHF

Save the CPU flags in the status register SR onto the stack. This ensures that the flags can be put back as they were when the procedure completes. The stack pointer is moved back one place. See the Push command. NOTE: Items must be popped in the reverse order they were pushed.

DEC AL

Subtract one from AL. This command sets the Z flag if the answer was Zero or the S flag if the answer was negative.

JNZ REP

Jump Not Zero to the address that Rep marks. Jump if the Z flag is not set.

POPF

Restore the CPU flags from the stack. Increase the stack pointer by one.

POP AL

Restore the AL register from the stack. This is done by first moving the stack pointer SP forward one place and copying the value at that stack position into the AL register. A stack underflow occurs when an attempt is made to pop more items off the stack than were present. NOTE: Items must be popped in the reverse order they were pushed.

RET

Return from the procedure to the address that was saved on the stack by the CALL command. Procedures can re-use themselves. This is called recursion. It is a powerful technique and dangerous if you don't understand what is happening! Accidental or uncontrolled recursion causes the stack to grow until it overwrites the program or overflows.


Example - 07textio.asm - Text I/O Procedures

Example - 07textio.asm

; --------------------------------------------------------------
; A program to read in a string of text and store it in RAM.
; The end of text will be labelled with ASCII code zero/null.
; --------------------------------------------------------------
; THE MAIN PROGRAM
    MOV	BL,70	; [70] is the address where the text will
            ; be stored. The procedure uses this.

    CALL	10	; The procedure at [10] reads in text and
            ; places it starting from the address
            ; in BL.

            ; BL should still contain [70] here.

    CALL	40	; This procedure does nothing until you
            ; write it.  It should display the text.

    HALT		; DON'T USE END HERE BY MISTAKE.
; --------------------------------------------------------------
; A PROCEDURE TO READ IN THE TEXT
    ORG	10	; Code starts from address [10]

    PUSH	AL	; Save AL onto the stack
    PUSH	BL	; Save BL onto the stack
    PUSHF		; Save the CPU flags onto the stack

Rep:
    IN	00	; Input from port 00 (keyboard)
    CMP	AL,0D	; Was key press the Enter key?
    JZ	Stop	; If yes then jump to Stop
    MOV	[BL],AL	; Copy keypress to RAM at position [BL]
    INC	BL	; BL points to the next location.
    JMP	Rep	; Jump back to get the next character

Stop:
    MOV	AL,0	; This is the NULL end marker
    MOV	[BL],AL	; Copy NULL character to this position.

    POPF		; Restore flags from the stack
    POP	BL	; Restore BL from the stack
    POP	AL	; Restore AL from the stack

    RET		; Return from the procedure.
; --------------------------------------------------------------
; A PROCEDURE TO DISPLAY TEXT ON THE SIMULATED SCREEN
    ORG	40	; Code starts from address [10]
            ; **** YOU MUST FILL THIS GAP ****
    RET		; At present this procedure does
            ; nothing other than return.

; --------------------------------------------------------------
    END		; It is correct to use END at the end.
; --------------------------------------------------------------

TASK

17)	Write a program using three procedures.  The first should
    read text from the keyboard and store it in RAM.  The second
    should convert any upper case characters in the stored text
    to lower case.  The third should display the text on the
    VDU screen.

; --------------------------------------------------------------

You can copy this example program from the help page and paste it into the source code editor.

Passing Parameters

MOV BL,70

The BL register contains 70. This value is needed by the text input procedure. It is the address where the text will be stored in RAM. This is an example of passing a parameter using a register. All you are doing is getting a number from one part of a program to another.

INC BL

This command adds one to BL. The effect is to make BL point to the next memory location ready for the next text character to be stored.

CALL 10

Call the procedure at address [10]. This is achieved in practice by setting the CPU instruction pointer IP to [10].

RET

At the end of the procedure, the RET command resets the CPU instruction pointer IP back to the instruction after the CALL instruction to the procedure. This address was stored on the stack by the CALL instruction.

HALT

Don't confuse HALT and END. The END command causes the assembler to stop scanning for more instructions in the program. The HALT command generates machine code 00 which causes the CPU to halt. There can be several HALT commands in a program but only one END command.

ORG 10

Origin [10]. The assembler program starts generating machine code from address [10].

PUSH AL and POP AL

Save the value of AL onto the stack. This is an area of RAM starting at address BF. The stack grows towards zero. The RAM displays show the stack pointer as a blue highlight with yellow text. Push and Pop are used so that procedures and interrupts can tidy up after themselves. The procedure or interrupt can alter CPU registers but it restores them to their old values before returning.

PUSHF and POPF

PUSHF saves the CPU flags onto the stack. POPF restores the CPU flags to their original value. This enables procedures and interrupts to do useful work without unexpected side affects on the rest of the program.

IN 00

Input from port zero. This port is connected to the keyboard. The key press is stored into the AL register.

CMP AL,0D

Compare the AL register with the hexadecimal number 0D. 0D is the ASCII code of the Enter key. This line is asking "Was the enter key pressed?" CMP works by subtracting 0D from AL. If they were equal then the subtraction gives an answer of zero. This causes the CPU zero or 'Z' flag to be set.

JZ Stop

Jump to the Stop label if the CPU 'Z' flag was set. This is a conditional jump.

MOV [BL],AL

Move the key press stored in AL into the RAM location that [BL] points to. INC BL is then used to make BL point to the next RAM location.

JMP Rep

Jump back to the Rep label. This is an unconditional jump. It always jumps and the CPU flags are ignored.

RET

Return from the procedure to the address stored on the stack. This is done by setting the instruction pointer IP in the CPU.


Example - 08table.asm - Data Tables

Example - 08table.asm

; ----- EXAMPLE 8 ------- DATA TABLES --------------------------

    JMP	Start	; Skip past the data table.

    DB	84	; Data table begins.
    DB	C8	; These values control the traffic lights
    DB	31	; This sequence is simplified.
    DB	58	; Last entry is also used as end marker

Start:
    MOV	BL,02	; 02 is start address of data table
Rep:
    MOV	AL,[BL]	; Copy data from table to AL
    OUT	01	; Output from AL register to port 01

    CMP	AL,58	; Last item in data table ???
    JZ	Start	; If yes then jump to Start
    INC	BL	; In no then point BL to the next entry
    JMP	Rep	; Jump back to do next table entry

    END
; --------------------------------------------------------------

TASK

18)	Improve the traffic lights data table so there is an
    overlap with both sets of lights on red.

19)	Use a data table to navigate the snake through the maze.
    This is on port 04.  Send FF to the snake to reset it.
    Up, down left and right are controlled by the left four bits.
    The right four bits control the distance moved.

20)	Write a program to spin the stepper motor. Activate bits
    1, 2, 4 and 8 in sequence to energise the electromagnets
    in turn. The motor can be half stepped by turning on pairs
    of magnets followed by a single magnet followed by a pair
    and so on.

21)	Use a data table to make the motor perform a complex sequence
    of forward and reverse moves.  This is the type of control
    needed in robotic systems, printers and plotters.  For this
    exercise, it does not matter exactly what the motor does.

; --------------------------------------------------------------

You can copy this example program from the help page and paste it into the source code editor.

DB 84

DB stands for Define Byte/s. In this case 84hex is stored into RAM at address [02]. Addresses [00] and [01] are occupied by the JMP Start machine codes.

84 hex is 1000 0100 in binary. This is the pattern or noughts and ones needed to turn on the left red light and the right green light.

MOV BL,02

Move 02 into the BL register. [O2] is the RAM address of the start of the data table. BL is used as a pointer to the data table.

MOV AL,[BL]

[BL] points to the data table. This line copies a value from the data table into the AL register.

OUT 01

Send the contents of the AL register to port 01. Port 01 is connected to the traffic lights.

CMP AL,58

58 is the last entry in the data table. If AL contains 58, it is necessary to reset BL to point back to the start of the table ready to repeat the sequence. If AL is equal to 58, the 'Z' flag in the CPU will be set.

JZ Start

Jump back to start if the 'Z' flag in the CPU is set.

INC BL

Add one to BL to make it point to the next entry in the data table.


Example - 09param.asm - Parameters

Example - 09param.asm

; ----- EXAMPLE 9 ------- Passing Parameters -------------------

; ----- Use Registers to pass parameters into a procedure ------

    JMP 	Start	; Skip over bytes used for data storage

    DB	0	; Reserve a byte of RAM at address [02]
    DB	0	; Reserve a byte of RAM at address [03]
Start:
    MOV	AL,5
    MOV	BL,4
    CALL	30	; A procedure to add AL to BL
            ; Result returned in AL.

; ----- Use RAM locations to pass parameters into a procedure --

    MOV	AL,3
    MOV	[02],AL	; Store 3 into address [02]
    MOV	BL,1
    MOV	[03],BL	; Store 1 into address [03]
    CALL	40

; ----- Use the Stack to pass parameters into a procedure ------
    MOV	AL,7
    PUSH	AL
    MOV	BL,2
    PUSH	BL
    CALL	60
    POP	BL
    POP	AL	; This one contains the answer

    JMP	Start	; Go back and do it again.

; ----- A procedure to add two numbers -------------------------

;	Parameters passed into procedure using AL and BL
;	Result returned in AL
;	This method is simple but is no good if there are a
;	lot of parameters to be passed.

    ORG	30	; Code starts at address [30]

    ADD	AL,BL	; Do the addition.  Result goes into AL

    RET		; Return from the procedure

; ----- A procedure to add two numbers -------------------------
;	Parameters passed into procedure using RAM locations.
;	Result returned in RAM location

;	This method is more complex and there is no limit on
;	the number of parameters passed unless RAM runs out.

    ORG	40	; Code starts at address [40]

    PUSH	CL	; Save registers and flags on the stack
    PUSH	DL
    PUSHF

    MOV	CL,[02]	; Fetch a parameter from RAM
    MOV	DL,[03]	; Fetch a parameter from RAM
    ADD	CL,DL	; Do the addition
    MOV	[02],CL	; Store the result in RAM

    POPF		; Restore original register

    POP	DL	; and flag values
    POP	CL

    RET

; ----- A procedure to add two numbers -------------------------
; 	The numbers to be added are on the stack.
;	POP parameters off the stack
;	Do the addition
;	Push answer back onto the stack
;	The majority of procedure calls in real life make use
;	of the stack for parameter passing.  It is very common
;	for the address of a complex data structure in RAM to
;	be passed to a procedure using the stack.

    ORG	60	; Code starts at address [60]

    POP	DL	; Return address
    POP	BL	; A parameter
    POP	AL	; A parameter

    ADD	AL,BL

    PUSH	AL	; Answer ; The number of pushes must
    PUSH	AL	; Answer ; match the number of pops.
    PUSH	DL	; Put the stack back as it was before

    RET
; --------------------------------------------------------------
    END

Task

22)	Write a procedure that doubles a number.  Pass the single
    parameter into the procedure using a register.  Use the
    same register to return the result.

23)	Write a procedure to invert all the bits in a byte.  All
    the zeros should become ones.  All the ones should become
    zeros.  Pass the value to be processed into the procedure
    using a RAM location.  Return the result in the same RAM
    location.

24)	Write a procedure that works out Factorial N.  This example
    shows one method for working out factorial N.
    Factorial 5 is 5 * 4 * 3 * 2 * 1 = 120.  Your procedure
    should work properly for factorial 1, 2, 3, 4 or 5.
    Factorial 6 would cause an overflow.  Use the stack to pass
    parameters and return the result.  Calculate the result.
    Using a look up table is cheating!

25)	Write a procedure that works out Factorial N.  Use the
    stack for parameter passing.  Write a recursive
    procedure.  Use this definition of Factorial.

    Factorial ( 0 )  is defined as 1.
    Factorial ( N ) is defined as N * Factorial (N - 1).

    To work out Factorial (N), the procedure first tests to see
    if N is zero and if not then re-uses itself to work out
    N * Factorial (N - 1).  This problem is hard to understand
    in any programming language.  In assembly code it is
    harder still.

You can copy this example program from the help page and paste it into the source code editor.

Passing Parameters

Parameters can be passed in three ways.

  1. CPU registers can be used - Fast but little data can be passed. In some programming languages the "Register" keyword is used to achieve this.
  2. RAM locations can be used - Slower and recursion may not be possible. In some programming languages the "Static" keyword is used to achieve this. This technique is useful if very large amounts of data are help in RAM. Passing a pointer to the data is more efficient than making a copy of the data on the stack.
  3. The stack can be used - Harder to understand and code but a lot of data can be passed and recursion is possible. Compilers generally use this method by default unless otherwise directed.

The example program uses all three methods to add two numbers together. The example tasks involve all three methods.


Example - 10swint.asm - Software Interrupts

Example - 10swint.asm

; --------------------------------------------------------------
; An example of software interrupts.
; --------------------------------------------------------------
    JMP	Start	; Jump past table of interrupt vectors
    DB	51	; Vector at 02 pointing to address 51
    DB	71	; Vector at 03 pointing to address 71
Start:
    INT	02	; Do interrupt 02
    INT	03	; Do interrupt 03
    JMP	Start
; --------------------------------------------------------------

    ORG	50
    DB	E0	; Data byte - could be a whole table here
            ; Interrupt code starts here
    MOV	AL,[50]	; Copy bits from RAM into AL
    NOT	AL	; Invert the bits in AL
    MOV	[50],AL	; Copy inverted bits back to RAM
    OUT	01	; Send data to traffic lights
    IRET
; --------------------------------------------------------------
    ORG	70
    DB	0	; Data byte  - could be a table here

; Interrupt code starts here
    MOV	AL,[70]	; Copy bits from RAM into AL
    NOT	AL	; Invert the bits in AL
    AND	AL,FE	; Force right most bit to zero
    MOV	[70],AL	; Copy inverted bits back to RAM
    OUT	02	; Send data to seven segment display
    IRET
; --------------------------------------------------------------
    END
; --------------------------------------------------------------

TASK

26)	Write a new interrupt 02 that fetches a key press from the
    keyboard and stores it into RAM.  The IBM PC allocates 16
    bytes for key press storage.  The 16 locations are used in
    a circular fashion.

27)	Create a new interrupt that puts characters onto the next
    free screen location.  See if you can get correct behaviour
    in response to the Enter key being pressed (fairly easy)
    and if the Back Space key is pressed (harder).

You can copy this example program from the help page and paste it into the source code editor.

Interrupts and Procedures

Interrupts are short code fragments that provide useful services that can be used by other programs. Typical routines handle key presses, mouse movements and button presses, screen writing, disk reading and writing and so on.

An interrupt is like a procedure but it is called in a different way. Procedures are called by jumping to the start address of the procedure. This address is known only to the program that owns the procedure. Interrupts are called by looking up the address of the interrupt code in a table of interrupt vectors. The contents of this table is published and widely known. MS DOS makes heavy use of interrupts for all its disk, screen, mouse, network, keyboard and other services.

By writing your own code and making the interrupt vector point to the code you wrote, the behaviour of interrupts can be completely altered. Your interrupt code might add some useful behaviour and then jump back to the original code to complete the work. This is called TRAPPING the interrupt.

Software interrupts are triggered, on demand, by programs.

Hardware interrupts are triggered by electronic signals to the CPU from hardware devices.

Interrupt Vector Table

In the IBM compatible computer, addresses 0 to 1024 decimal are used for storing interrupt vectors. The entries in this table of vectors point to all the code fragments that control MS DOS screen, disk, mouse, keyboard and other services. The simulator vectors sit between addresses 0 and 15 decimal. It is convenient to start a simulator program with a jump command that occupies two bytes. This means that the first free address for an interrupt vector is [02]. This is used by the hardware timer if the interrupt flag is set.

Have another look at the example program. 10swint.asm

Calling an Interrupt

This is quite complex. The command INT 02 causes the CPU to retrieve the contents of RAM location 02. After saving the return address onto the stack, the instruction pointer IP is set to this address.

The interrupt code is then executed. When complete the IRET command causes the return from the interrupt. The CPU instruction pointer IP is set to the address that was saved onto the stack earlier.

Trapping an Interrupt

If you wan to trap interrupt 02, change the address stored at address 02 to point to code that you have written. Your code will then handle the interrupt. When complete, your code can use IRET to return from the interrupt or it can jump to the address that was originally in address 02. This causes the original interrupt code to be executed as well. In this way, you can replace or modify the behaviour of an interrupt.


Example - 11whint.asm - Hardware Interrupts

Example - 11hwint.asm - Hardware Interrupts

Example - 11hwint.asm

; --------------------------------------------------------------
; An example of using hardware interrupts.
; This program spins the stepper motor continuously and
; steps the traffic lights on each hardware interrupt.

; Uncheck the "Show only one peripheral at a time" box
; to enable both displays to appear simultaneously.

; --------------------------------------------------------------
    JMP	Start	; Jump past table of interrupt vectors
    DB	50	; Vector at 02 pointing to address 50

Start:
    STI		; Set I flag. Enable hardware interrupts
    MOV	AL,11	;
Rep:
    OUT	05	; Stepper motor
    ROR	AL	; Rotate bits in AL right
    JMP	Rep
    JMP	Start
; --------------------------------------------------------------
    ORG	50

    PUSH	al	; Save AL onto the stack.
    PUSH	bl	; Save BL onto the stack.
    PUSHF		; Save flags onto the stack.

    JMP	PastData

    DB	84	; Red		Green
    DB	c8	; Red+Amber	Amber
    DB	30	; Green		Red
    DB	58	; Amber		Red+Amber
    DB	57	; Used to track progress through table
PastData:
    MOV	BL,[5B]	; BL now points to the data table
    MOV	AL,[BL]	; Data from table goes into AL
    OUT	01	; Send AL data to traffic lights
    CMP	AL,58	; Last entry in the table
    JZ	Reset	; If last entry then reset pointer

    INC	BL	; BL points to next table entry
    MOV	[5B],BL	; Save pointer in RAM
    JMP	Stop
Reset:
    MOV	BL,57	; Pointer to data table start address
    MOV	[5B],BL	; Save pointer into RAM location 54
Stop:
    POPF		; Restore flags to their previous value
    POP	bl	; Restore BL to its previous value
    POP	al	; Restore AL to its previous value

    IRET
; --------------------------------------------------------------

END
; --------------------------------------------------------------

TASK

28)	Write a program that controls the heater and thermostat
    whilst at the same time counting from 0 to 9 repeatedly,
    displaying the result on one of the seven segment displays.
    If you want a harder challenge, count from 0 to 99 repeatedly
    using both displays.  Use the simulated hardware interrupt to
    control the heater and thermostat.

29)	A fiendish problem.  Solve the Tower of Hanoi problem whilst
    steering the snake through the maze.  Use the text characters
    A, B, C Etc. to represent the disks.  Use three of the four
    rows on the simulated screen to represent the pillars.

30)	Use the keyboard on Port 07. Write an interrupt handler
    (INT 03) to process the key presses. You must also process
    INT 02 (the hardware timer) but it need not perform any task.
    For a more advanced task, implement a 16 byte circular buffer.
    Write code to place the buffered text on the VDU screen when
    you press Enter. For an even harder task, implement code to
    process the Backspace key to delete text characters in the buffer.

You can copy this example program from the help page and paste it into the source code editor.

Hardware Interrupts

Hardware Interrupts are short code fragments that provide useful services that can be triggered by items of hardware. When a printer runs out of paper, it sends a signal to the CPU. The CPU interrupts normal processing and processes the interrupt. In this case code would run to display a "Paper Out" message on the screen. When this processing is complete, normal processing resumes.

This simulator has a timer that triggers INT 02 at regular time intervals that you can pre-set in the Configuration Tab. You must put an interrupt vector at address 02 that points to your interrupt code. Look at the example.

STI and CLI

Hardware interrupts are ignored unless the 'I' flag in the status register is set. To set the 'I' flag, use the set 'I' command, STI. To clear the 'I' flag, use the clear 'I' command CLI.

Hardware interrupts can be trapped in the same way that software interrupts can.

Hardware interrupts are triggered, as needed by disk drives, printers, key presses, mouse movements and other hardware events.

This scheme makes processing more efficient. Without interrupts, the CPU would have to poll the hardware devices at regular time intervals to see if any processing was needed. This would happen whether or not processing was necessary. Interrupts can be assigned priorities such that a disk drive might take priority over a printer. It is up to the programmer to optimise all this for efficient processing. In the IBM compatible PC, low number interrupts have a higher priority than the higher numbers.

Calling an Interrupt

This is quite complex. The command INT 02 whether triggered by hardware or software, causes the CPU to retrieve the contents of RAM location 02. After saving the return address onto the stack, the instruction pointer IP is set to the address that came from RAM.

The interrupt code is then executed. When complete the IRET command causes the return from the interrupt. The CPU instruction pointer IP is set to the address that was saved onto the stack earlier.

Hardware interrupts differ slightly from software interrupts. A software interrupt is called with a command like INT 02 and the return address is the next instruction after this. IP + 2 is pushed onto the stack. Hardware interrupts are not triggered by an instruction in a program so the return address does not have to be set past the calling instruction. IP is pushed onto the stack.

Trapping an Interrupt

This is the same as trapping software interrupts described on the previous page.


Shortcut Keys

Alt Keys

Control Keys

Function Keys
A
Assemble Button
A
Edit Select All
F1
Help
B
 Log Assembler Activity
B
F2
C
Configuration Tab
C
Edit Copy
F3
D
D
F4
E
Edit Menu
E
F5
F
File Menu
F
Edit Find
F6
G
Log File Tab
G
F7
H
Help Menu
H
F8
I
I
F9
 Run
J
List File Tab
J
F10
K
Tokens Tab
K
F11
L
Slower Button
L
F12
M
Show Ram Button
M
N
Continue Button
N
O
Stop Button
O
File Open
P
Step Button
P
Q
Q
R
Run Button
R
Edit Replace
S
Reset Button
S
File Save
T
Faster Button
T
U
Source Code Tab
U
V
View Menu
V
Edit Paste
W
 Write Run Log
W
X
Examples Menu
X
Edit Cut
Y
Y
Z
Z


ASCII Codes

American Standard Code for Information Interchange

The ASCII code has 128 standard characters and a further 128 characters that vary from machine to machine and country to country.

The first 128 ASCII characters are shown here.

Dec |  | 00 | 01 | 02 | 03 | 04 | 05 | 06 | 07 | 08 | 09 | 10 | 11 | 12 | 13 | 14 | 15
 | Hex | 00 | 01 | 02 | 03 | 04 | 05 | 06 | 07 | 08 | 09 | 0A | 0B | 0C | 0D | 0E | 0F
00 | 00 | Nul |  |  |  |  |  |  | Bel | Bak | Tab | LF |  |  | CR |  |
16 | 10 |  |  |  |  |  |  |  |  |  |  | EOF | ESC |  |  |  |
32 | 20 | Spa | ! | " | # | $ | % | & | ' | ( | ) | * | + | , | - | . | /
48 | 30 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | : | ; | < | = | > | ?
64 | 40 | @ | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O
80 | 50 | P | Q | R | S | T | U | V | W | X | Y | Z | [ | \ | ] | ^ | _
96 | 60 | ` | a | b | c | d | e | f | g | h | i | j | k | l | m | n | o
112 | 70 | p | q | r | s | t | u | v | w | x | y | z | { | | | } | ~ | Nul

The codes from 128 to 255 are not shown here.

Codes with special meanings to DOS, Printers, Teletype Machines and ANSI screens.

Decimal |  |
0 | Nul | NULL character. ( End of text string marker. )
7 | Bel | Bell or beep character.
8 | Bak | Backspace character.
9 | Tab | TAB character.
10 | LF | Line Feed (start a new line).
13 | CR | Carriage Return code.
26 | EOF | DOS End of text file code.
27 | Esc | Escape code. It has special effects on older printers and ANSI screens. ANSI = American National Standards Institute.
32 | Spa | Space Character.
255 | Nul | NULL character.

Unicode

ASCII is being replaced by the 16 bit Unicode with 65536 characters that represent every text character in every country in the world including those used historically. Most new operating systems software packages support Unicode.


Glossary

Glossary

386 | CPU chips in IBM compatible computers are typically numbered 086, 186, 286, 386, 486, 586, Pentium Etc. 086 chips are now regarded as old fashioned and slow. To run Windows, a 32 bit 386 chip was the minimum recommended.
8 Bit CPU | The CPU has registers and connections to the outside world that are 8 bits wide. 16 bit and 32 bit CPUs are now more common, more powerful and more expensive. 64 bit CPUs exist but are not common (2003)
80x86 | The family of Intel chips numbered 8086, 80186, 80286, 80386, 80486 and Pentium.
Accelerator Key | Improves your productivity. For example Alt+F4 closes the current window and is quicker to press than the equivalent mouse or menu actions.
Analogue | Electronic systems that deal with continuously varying signals. Radio, TV and HiFi systems are all analogue. CD Players are digital but the digital signals must be converted to analogue before being sent to the HiFi system.
ANSI | American National Standards Institute
Architecture | CPU designs are more complex than typical building designs. Computer architecture is equivalent to building architecture. To make best use of a computer, it is useful to know something about the computer design or architecture.
ASCII | The American Standard Code for Information Interchange. This is an eight bit code. There are 128 characters which are standard. There are a further 128 characters that vary depending on the country and the graphics symbols required by printers. American ASCII is being replaced by International Unicode.
ASM | The usual file extension for assembly code programs
Assembler
Assembly code 		Human readable commands like MOV AL,33 correspond closely to CPU machine codes. The assembler program translates the human readable codes into machine codes readable by the CPU
Author | C Neil Bauers can be E Mailed on the internet at nbauers@samphire.demon.co.uk
Backup copy | Copies of files kept in case of disaster. These should be kept in a secure place away from the computer system they belong to. Important files should be backed up in more than one place. Sod's law applies to back up files. The file you really need is the one you have failed to back up.
Base Address | The start address of an object stored in memory. For example : The original IBM PC VGA screen base address is B800:0000 followed by 4000 more bytes.
Binary | Base two numbers used by digital systems. Count with two symbols [ 0 1 ] Binary numbers are composed of noughts and ones. Electronically this is achieved by circuits that are switched off or on.
Bit Masks | Patterns of noughts and ones used with AND, OR and XOR to extract or inserts bits into bytes.
Bits | Binary digits. Single digits that are nought or one.
Byte | Eight Bits. The data in a byte can have many different meanings depending on the context. A byte can represent a CPU command, an ASCII character, a decimal number, a graphics pattern or anything you have programmed it to represent.
Carriage Return | ASCII code 13 used to move the printer carriage or head to the left of the page. The screen cursor performs in the equivalent way. See also - Line Feed
Case Sensitive | Upper and lower case are taken to be different. This simulator is not case sensitive.
Chip | Shorthand for microchip or integrated circuit. The CPU is often referred to as the CPU Chip.
Click | Usually the left mouse button being pressed when the mouse is pointing at a screen object.
Clock | The CPU clock steps the computer and CPU at regular time intervals keeping all parts of the computer in step. Typical clock speeds range between 1 to 500 Megahertz. 200 MHz was typical for a PC in 1997.
Comments | These begin with ';' and are used to explain what the program is doing. Good comments explain why things are being done. Bad comments simply repeat what is obvious by looking at the code.
Conditional Jumps | These jumps either take place or not depending on the flags in the status register. See JS, JNS, JO, JNO, JZ, JNZ, JMP.
Control Key | This is used to give keys special meanings. For example the combination of the control key with the F4 function key will close a window in some software packages.
Control Systems | Industrial and domestic equipment is frequently controlled by a small microcomputer called a microcontroller. The control system is programmed once for life so a TV remote controller can not be re-programmed as a washing machine controller.
CPU | Central Processing Unit. The part of the computer that does the computations. Usually this is a single microchip.
Cursor | A flashing symbol that indicates position within text. Alternatively the mouse cursor indicates the mouse position. Special purpose cursors are used in some software.
Data tables | These store numbers, text or pointers to other data objects. It is easier to look after data in a table than data scattered throughout a program. It is good style to use data tables.
Decimal Base 10 numbers. | Count and do arithmetic with ten symbols. [ 0 1 2 3 4 5 6 7 8 9 ]
Digital Electronic | Systems that use binary. Computers use binary numbers and are digital. HiFi systems do not use binary and are not digital. (A HiFi remote control system is digital) See analogue.
Directory or Folder | File systems are organised into directories in much the same way that filing cabinets are organised into draws and folders. Your files should be stored in a directory that you have created. This keeps your files from getting muddled up with all the other files on the computer.
Divide by zero | This will cause an error. Any number divided by zero is infinitely big. This can not be calculated.
End Of File | ASCII code 26 is used to indicate the end of MS DOS text files.
Escape ASCII code 27 | This character is often interpreted in a special way by programs, VDUs and printers.
Executable Code | Non human readable program code executed by the CPU.
Explorer | See File Manager
Extension | The MS DOS file extension is zero or more characters after the dot in the file name. Word processor files often have .DOC on the end. Assembly code files end in .ASM
F1 Key | Commonly this accesses the on line help.
File | Data stored on disk or tape. When the data is loaded from the file into RAM, it could consist of a program or data used by the program.
File Manager or Explorer | A windows program that enables you to manage your files. Copying, renaming and deleting files and directories are typical file management tasks.
Flags | The Interrupt, Sign, Zero and Overflow flags in the status register indicate the outcome of the previous calculation. See S Flag, O flag and Z flag.
Floppy disk | Used to store files. 3.5 inch disks have a hard rectangular plastic casing to protect the thin floppy disk inside. Older disks are actually floppy. The case is bendy cardboard.
Folder | See Directory
Function keys | F1, F2 ... F10. These keys have special purposes depending on the software in use. F1 usually activates help. F10 usually activates the menu.
General Purpose Registers | AL, BL, CL and DL are used to store data and perform calculations.
Gigahertz | 1000 Megahertz. CPU Clock speeds are now measured in gigahertz.
Graphics | Images, pictures and geometrical shapes are examples of graphics. Windows displays everything as graphics. This gives good looking displays but a lot of processing is needed to achieve it.
Hard disk | A disk that can not normally be removed from the computer. Most computer files are stored on the hard disk. There should also be backup copies stored elsewhere in case the hard disk fails.
Hexadecimal | Base 16 numbers. Count and do arithmetic with 16 symbols. [ 0 1 2 3 4 5 6 7 8 9 A B C D E F ] Hexadecimal and Binary are easily converted which is why hexadecimal is used.
Hot Keys | Ctrl+S and Ctrl+O are examples of hot keys. These give quick access to menu options. Ctrl+S gives the File Save command. Ctrl+O gives the File Open command.
I Flag | The I or interrupt flag in the status register indicates if the CPU will accept or ignore hardware interrupts. The commands CLI and STI clear and set this flag. Hardware interrupts are used to signal events like "Key pressed", "Disk Ready".or "Printer out of paper." A hardware timer can generate an interrupt at regular time intervals.
Immediate | The instruction MOV AL,25 is an example of an immediate instruction. See also : Register, Indirect, Register indirect and MOV.
Indirect
Indirection 		This is where data in RAM is referred to with a pointer. For example MOV AL,[20] moves the data from RAM location 20 into the AL register. [20] is a pointer to the RAM location. The technique is called indirection. See MOV, Immediate, Register, Register indirect
Instruction Pointer | IP points to the instruction being executed. When the instruction is complete, the IP is moved onto the next instruction. In the RAM displays, the instruction pointer is highlighted red with yellow text.
Instruction Set | The set of instructions that are recognised by a CPU. Typical instructions are Move, Add and Subtract.
interrupt code
interrupt handler
Interrupt routine 		A program fragment designed to be activated at any time that an interrupt occurs. The fragment is stored at an address pointed to by an interrupt vector. Interrupts can be triggered by hardware. For example a key press or the printer running out of paper cause a hardware interrupt. The CPU switches to the code that handles the interrupt. When finished, the CPU continues with its earlier task.
Interrupt Vector | A pointer stored in a table. The pointer points at the interrupt handler. See INT.
IO | Short for Input Output. See IN and OUT
Least significant bit LSB. The right hand bit in a byte which is worth 0 or 1.
MSB. The left hand bit in a byte which is worth 0 or 128.
Least and Most significant bits.
LIFO | See Stack.
Line Feed | ASCII code 10 used to start a new line on the printed page or screen. See also - Carriage Return.
List File | This is generated by the simulator assembler. It contains the program written by the programmer. It also contains the machine codes generated by the assembler.
Low level | Low level programming is done using the CPU machine code or mnemonics the are close to the machine codes.
LSB LSB. The right hand bit in a byte which is worth 0 or 1.
MSB. The left hand bit in a byte which is worth 0 or 128.
Least and Most significant bits.
Machine codes Machine codes are executed by the CPU See Assembly codes.
Human readable commands look like this MOV AL,55
The hexadecimal equivalent looks like this D0 00 55
The binary machine code looks like this 110100000000000001010101
A Megabyte | 224 bytes to be precise or a million bytes approximately
Megahertz | MHz. Million clock cycles per second. A 33 MHz clock means that the CPU performs 33 million steps per second. These sorts of speeds are needed to fill screens with high resolution graphics quickly.
Memory Mapped | Memory mapped hardware is controlled by writing data into memory locations occupied by that hardware device. This simulator has a memory mapped screen so each screen position corresponds to a memory location.
Microchip | Complex electronic circuits miniaturised onto a single wafer or chip of silicon
Microcontroller | Usually a single chip microcircuit containing a CPU, RAM and ROM. Microcontrollers are used in TV remote controllers, washing machines, digital clocks, microwave ovens, industrial plant controllers, car engine management systems and computer games.
Microprocessor | A single chip CPU.
Mnemonic | A memorable and human readable item like MOV that corresponds to a non memorable item like 11010000 that means the same thing.
Most significant bit MSB LSB. The right hand bit in a byte which is worth 0 or 1.
MSB. The left hand bit in a byte which is worth 0 or 128.

Most Significant Bit. The left hand bit in a byte. It has a value of 128 decimal or 80Hex if the byte is unsigned (positive numbers only). It has a value of -128 if the byte is signed (positive and negative numbers). The MSB has a value that depends on how wide in bits the data storage location is.
Multiplexing | Combining two or more data flows onto a single carrying medium. For example a thousand telephone calls can be carried on a single cable. De-multiplexing separates the channels and routes them to their correct destinations.
NULL | ASCII code zero used to mark the end of text strings.
O Flag | The O or overflow Flag in the status register indicates if the previous calculation overflowed its register.
Off Line | The network is disconected. However resources, can be made available locally (off-line) even when the network is not available. When the network is re-connected, the data files are synchronised so everyone gets the most up-to-date information.
On Line | The network is connected. Computer resources are connected and available and can be accessed with a negligible or short time delay. On line resources usually involve interaction with the user.
OP Code | A binary code that the CPU can interpret as a command. These correspond to commands like MOV and ADD.
Operand Essential data that comes after the op code.
MOV | AL, | 55
Op-Code | Operand | Operand
Overflow Flag | This is set if the result of the previous calculation was too big to fit the register.
Parameters | Data passed into procedures of functions. Parameters can be passed using registers (very fast), RAM locations (good for big data items) or the Stack (useful if recursion is needed).
Peripherals | Hardware plugged into the computer. Anything from a keyboard or mouse to a power station or chemical works.
Pointers | In the command MOV AL,[25] the 25 is a pointer to the RAM location with address 25. See indirection.
Ports | Input Output Ports. Peripherals are connected to ports. The IN and OUT machine instructions are used to communicate with the peripherals.
Procedures | Small, modular, self contained, easily tested, code fragments that can be used many times during the execution of a program. See CALL and RET in the instruction set.
Process | A program that is running or loaded ready to run. Processes can be running, ready to run or waiting. Waiting processes are usually queueing up for disk or printer access. A waiting process might be waiting for its share of CPU time.
Programs | Instructions executed by a computer to perform tasks.
RAM | Random access memory. Electronic memory that stores bytes. Normal RAM forgets what it was storing when switched off.
Recursion | A powerful technique where a procedure or function re-uses itself to achieve a task.
Register | A location in the CPU where data is stored. This simulator has four general purpose registers called AL, BL, CL and DL. It has special purpose registers called IP, SR and SP.
Register | In the instruction CMP AL,BL registers are being compared. See also : Immediate, Indirect, Register indirect.
Register indirect | In the instruction MOV AL,[BL] the BL register contains a pointer to a RAM location. The data in this RAM location is moved into AL. This is a register indirect move. See also : Immediate, Indirect and Register.
Repetition | This is achieved by using jump commands to make the program jump back and repeat instructions.
Reset CPU | Reset the CPU to its switch on state. Clear the general purpose registers to zero. Set IP to zero. Set the flags to Zero. Set the stack pointer to BF. The stack grows downwards from address FB.
Return address | The address stored on the stack that the program returns to when a procedure or interrupt is complete.
Run | Run a program. Programs are collections of stored instructions that are usually inactive. To run a program, it must be copied from disk into RAM and the CPU is given the address of the first instruction in the program so it can run it. A running program is often called a process.
S Flag | The S or sign flag in the status register indicates if the previous calculation gave a negative result.
Save a file | Copy processed data from RAM onto disk.
Seven segment | displays are used in digital clocks, watches, calculators and so on. Numbers are built up by illuminating combinations of the seven segments.
Scheduler | The scheduler is a process that manages all the other processes in a computer. It aims to make best use of the hardware resources and to minimise delays to processes and users.
Sign bit | The leftmost bit in a binary number that is used to indicate if the number is positive or negative.
Sign Flag | This is set if a calculation gives a negative result.
Signed Numbers | Numbers where the left most bit is the sign bit.
Simulator | Computer software that models reality in some way. Virtual reality aims to make the simulation so realistic that it seems real. Most simulations are designed to be useful rather than realistic.
Source Code | The human readable program code typed into the computer. See executable code.
SP | The stack pointer register. In the RAM displays, the stack pointer is highlighted blue with yellow text.
SR | The status register. This contains flags that are set as a result of the most recent calculation. A zero result will set the Z (zero) flag. A negative result will set the S (sign) flag. A result too big to fit in a register will set the O flag (overflow). If the I flag is clear (not set) interrupts will be ignored.
Stack | An area of memory used for temporary storage according to the LIFO rule. Last in First out. The stack is used to save register contents for later restoration, pass parameters into procedures and return results, reverse the order in which data is stored, save addresses so procedures can return to the right place and there are other uses including doing postfix arithmetic.
Stack Pointer | Points to the next free location on the stack. In the RAM displays, the stack pointer is highlighted blue with yellow text. The stack is memory organised as LIFO last in first out. It is used to store return addresses, the CPU state, parameters passed to procedures, results returned from procedures, arithmetic data being processed and data whose order is to be reversed.
Status Flags
Status Register 		The status Register contains status flags that indicate the outcome of the previous calculation. The flags are Sign, Zero and Overflow. See SR.
Stepper motor | A special motor that rotates in small controlled angular movements. It is used commonly in printers, plotters and medical instruments and disk drives.
Task Switching | Use Alt Tab to task switch manually. Operating systems also task switch automatically. For example when word processing, the clock display continues to work because from time to time the operating system switches tasks to keep both going.
Thermostat | A temperature controlled switch. On when too cold. Off when too hot.
Token List | When programs are translated into machine code, one of the first steps is to convert the source code of the program into tokens. These are not usually human readable. The tokens are designed to occupy minimal memory. This simulator converts source code to tokens but does not bother to code them to save memory. This is because the programs are too small use much memory.
Twos complement | Binary numbers where the left most bit determines whether the number is positive or negative.
Unicode | A 16 bit character code with 65536 text characters for all the languages in the world including most dead (disused) languages. This code is replacing ASCII.
Unsigned numbers | Numbers without a sign bit. These are always positive.
USERINFO.REG | Simulator registration information is contained in this file. It is a text file and has nothing to do with the Windows registry. The same file format was used under Windows 3 which did not have a registry.
VDU | Visual display unit. Computer output is commonly displayed on the VDU. There are several VDU display technologies.
Write | A simple Windows word processor. Data is saved to disk in a format unique to the Write program.
Z Flag | The Z or zero flag is set it the previous calculation result was zero.


Binary and Hexadecimal

Converting Between Binary and Hex

The CPU works using binary. Electronically this is done with electronic switches that are either on or off. This is represented on paper by noughts and ones. A single BIT or binary digit requires one wire or switch within the CPU. Usually data is handled in BYTES or multiples of bytes. A Byte is a group of eight bits. A byte looks like this

01001011

This is inconvenient to read, say and write down so programmers use hexadecimal to represent bytes. Converting between binary and hexadecimal is not difficult. First split the byte into two nybbles (half a byte) as follows

0100 1011

Then use the following table

BINARY | HEXADECIMAL | DECIMAL
0 0 0 0 | 0 | 0
0 0 0 1 | 1 | 1
0 0 1 0 | 2 | 2
0 0 1 1 | 3 | 3
0 1 0 0 | 4 | 4
0 1 0 1 | 5 | 5
0 1 1 0 | 6 | 6
0 1 1 1 | 7 | 7
1 0 0 0 | 8 | 8
1 0 0 1 | 9 | 9
1 0 1 0 | A | 10
1 0 1 1 | B | 11
1 1 0 0 | C | 12
1 1 0 1 | D | 13
1 1 1 0 | E | 14
1 1 1 1 | F | 15

EXAMPLE

Split the byte into two halves

01001011 becomes 0100 1011

Using the table above

0100 is 4
1011 is B

The answer ...

0100 1011 is 4B in Hexadecimal.

To convert the other way take a hexadecimal such as E7.

Look up E in the table. It is 1110.
Look up 7 in the table. It is 0111.

E7 is 1110 0111.


Instruction Set Summary

AL, BL, CL and DL are eight bit, general purpose registers where data is stored.

Square brackets indicate RAM locations. For example [15] means RAM location 15.

Data can be moved from a register into into RAM and also from RAM into a register.

Registers can be used as pointers to RAM. [BL] is the RAM location that BL points to.

All numbers are in base 16 (Hexadecimal).

Move Instructions. Flags NOT set.
Assembler Machine Code
Explanation
MOV AL,15 D0 00 15
AL
 =
15
 Copy 15 into AL
MOV BL,[15] D1 01 15
BL
 =
[15]
 Copy RAM[15] into AL
MOV [15],CL D2 15 02
[15]
 =
CL
 Copy CL into RAM[15]
MOV DL,[AL] D3 03 00
DL
 =
[AL]
 Copy RAM[AL] into DL
MOV [CL],AL D4 02 00
[CL]
 =
AL
 Copy AL into RAM[CL]

Direct Arithmetic and Logic. Flags are set.
Assembler Machine Code
ADD AL,BL A0 00 01
AL
 =
AL + BL
SUB BL,CL A1 01 02
BL
 =
BL - CL
MUL CL,DL A2 02 03
CL
 =
CL * DL
DIV DL,AL A3 03 00
DL
 =
DL / AL
INC DL A4 03
DL
 =
DL + 1
DEC AL A5 00
AL
 =
AL - 1
AND AL,BL AA 00 01
AL
 =
AL AND BL
OR CL,BL AB 03 02
CL
 =
CL OR BL
XOR AL,BL AC 00 01
AL
 =
AL XOR BL
NOT BL AD 01
BL
 =
NOT BL
ROL AL 9A 00
Rotate bits left. LSB = MSB
ROR | BL | 9B 01 | Rotate bits right. MSB = LSB
SHL CL 9C 02
Shift bits left. Discard MSB.
SHR DL 9D 03
Shift bits right. Discaed LSB.

Immediate Arithmetic and Logic. Flags are set.
Assembler Machine Code
ADD AL,12 B0 00 12
AL
 = AL + 12
SUB BL,15 B1 01 15
BL
 = BL - 15
MUL CL,03 B2 02 03
CL
 = CL * 3
DIV DL,02 B6 03 02
DL
 = DL / 2
AND AL,10 BA 00 10
AL
 = AL AND 10
OR CL,F0 BB 02 F0
CL
 = CL OR F0
XOR AL,AA BC 00 AA
AL
 = AL XOR AA

Compare Instructions. Flags are set.
Assembler Machine Code
Explanation
CMP AL,BL DA 00 01
Set 'Z' flag if AL = BL.
Set 'S' flag if AL < BL.
CMP BL,13 DB 01 13
Set 'Z' flag if BL = 13.
Set 'S' flag if BL < 13.
CMP CL,[20] DC 02 20 Set 'Z' flag if CL = [20].
Set 'S' flag if CL < [20].

Branch Instructions. Flags NOT set.

Depending on the type of jump, different machine codes can be generated.
Jump instructions cause the instruction pointer (IP) to be altered. The largest
possible jumps are +127 bytes and -128 bytes.

The CPU flags control these jumps. The 'Z' flag is set if the most recent
calculation gave a Zero result. The 'S' flag is set if the most recent calculation
gave a negative result. The 'O' flag is set if the most recent calculation gave
a result too big to fit in the register.
Assembler | Machine Code | Explanation
JMP HERE C0 12
C0 FE 		Increase IP by 12
Decrease IP by 2 (twos complement)
JZ THERE C1 09
C1 9C 		Increase IP by 9 if the 'Z' flag is set.
Decrease IP by 100 if the 'Z' flag is set.
JNZ A_Place C2 04
C2 F0 		Increase IP by 4 if the 'Z' flag is NOT set.
Decrease IP by 16 if the 'Z' flag is NOT set.
JS STOP C3 09
C3 E1 		Increase IP by 9 if the 'S' flag is set.
Decrease IP by 31 if the 'S' flag is set.
JNS START C4 04
C4 E0 		Increase IP by 4 if the 'S' flag is NOT set.
Decrease IP by 32 if the 'S' flag is NOT set.
JO REPEAT C5 09
C5 DF 		Increase IP by 9 if the 'O' flag is set.
Decrease IP by 33 if the 'O' flag is set.
JNO AGAIN C6 04
C6 FB 		Increase IP by 4 if the 'O' flag is NOT set.
Decrease IP by 5 if the 'O' flag is NOT set.

Procedures and Interrupts. Flags NOT set.

CALL, RET, INT and IRET are available only in the registered version.
Assembler | Machine Code | Explanation
CALL 30 CA 30 Save IP on the stack and jump to the
procedure at address 30.
RET | CB | Restore IP from the stack and jump to it.
INT 02 CC 02 Save IP on the stack and jump to the address
(interrupt vector) retrieved from RAM[02].
IRET | CD | Restore IP from the stack and jump to it.

Stack Manipulation Instructions. Flags NOT set.
Assembler | Machine Code | Explanation
PUSH | BL | E0 01 | BL is saved onto the stack.
POP | CL | E1 02 | CL is restored from the stack.
PUSHF | EA | SR flags are saved onto the stack.
POPF | EB | SR flags are restored from the stack.

Input Output Instructions. Flags NOT set.
Assembler | Machine Code | Explanation
IN | 07 | F0 07 | Data input from I/O port 07 to AL.
OUT | 01 | F1 01 | Data output to I/O port 07 from AL.

Miscellaneous Instructions. CLI and STI set I flag.

Assembler | Machine Code | Explanation
CLO | FE | Close visible peripheral windows.
HALT | 00 | Halt the processor.
NOP | FF | Do nothing for one clock cycle.
STI | FC | Set the interrupt flag in the Status Register.
CLI | FD | Clear the interrupt flag in the Status Register.
ORG 40 Code origin Assembler directive: Generate code starting
from address 40.
DB "Hello" Define byte Assembler directive: Store the ASCII codes
of 'Hello' into RAM.
DB | 84 | Define byte | Assembler directive: Store 84 into RAM.


Detailed Instruction Set

The Full Instruction Set

Arithmetic Logic
Jump Instructions
Move Instructions
Compare Instructions
Stack Instructions
Procedures And Interrupts
Inputs and Outputs
Other Instructions

General Information

CPU Registers

There are four general purpose registers called AL, BL, CL and DL.

There are three special purpose registers. These are

  • IP is the instruction pointer.
  • SP is the stack pointer.
  • SR is the status register. This contains the I, S, O and Z flags.

Flags

Flags give information about the outcome of computations performed by the CPU. Single bits in the status register are used as flags. This simulator has flags to indicate the following.

  • S The sign flag is set if a calculation gives a negative result.
  • O The overflow flag is set if a result is too big to fit in 8 bits.
  • Z The zero flag is set if a calculation gives a zero result.
  • I is the hardware interrupts enabled flag.

Most real life CPUs have more than four flags.

Registers and Machine Codes

The registers and their equivalent machine code numbers are shown below.

 Register names AL  BL  CL  DL
 Machine codes  00  01  02  03

Example : To add one to the CL register use the instruction

Assembly Code        INC        CL
Machine Code Hex     A4         02
Machine code Binary  10100100   00000010

A4 is the machine instruction for the INC command.

02 refers to the CL register.

The assembler is not case sensitive. mov is the same as MOV and Mov.

Within the simulator, hexadecimal numbers may not have more than two hexadecimal digits.

Hexadecimal numbers

15, 3C and FF are examples of hexadecimal numbers. When using the assembler, all numbers should be entered in hexadecimal. The CPU window displays the registers in binary, hexadecimal and decimal. Look at the Hexadecimal and Binary page for more detail.

Negative numbers

FE is a negative number. Look at the Negative Numbers table for details of twos complement numbers.

In a byte, the left most bit is used as a sign bit. This has a value of minus 128 decimal.

Bytes can hold signed numbers in the range -128 to +127.

Bytes can hold unsigned numbers in the range 0 to 255.

Indirection

When referring to data in RAM, square brackets are used. For example [15] refers to the data at address 15hex in RAM.

The same applies to registers. [BL] refers to the data in RAM at the address held in BL. This is important and frequently causes confusion.

These are indirect references. Instead of using the number or the value in the register directly, these values refer to RAM locations. These are also called pointers.

Comparing with 80x86 Chips

At the mnemonic level, the simulator instructions look very like 80x86 assembly code mnemonics. Sufficient instructions are implemented to permit realistic programming but the full instruction set has not been implemented. All the simulated instructions apply to the low eight bits of the 80x86 CPU. The rest of the CPU has not been simulated.

In the registered version, CALL, RET, INT, IRET and simulated hardware interrupts are available so procedures and interrupts can be written.

Most of the instructions behave as an 80x86 programmer would expect. The MUL and DIV (multiplication and division) commands are simpler than the 80x86 equivalents. The disadvantage of the simulator approach is that overflow is much more probable. The simulator versions of ADD and SUB are realistic.

The 8086 DIV instruction calculates both DIV and MOD in the same instruction. The simulator has MOD as a separate instruction.

The machine codes are quite unlike the 80x86 machine codes. They are simpler, less compact but designed to make the machine code as simple as possible.

With 80x86 machine code, a mnemonic like MOV AL,15 is encoded in two bytes. MOV AL, is encoded into one byte and the 15 goes into another. This means that a lot of different machine OP CODES are needed for all the different combinations of MOV commands and registers.

This simulator needs three bytes. MOV is encoded as a byte sized OP CODE. AL is encoded as a byte containing 00. The 15 goes into a byte as before. This is not very efficient but is very simple.


Arithmetic and Logic

Arithmetic Instructions - Flags are set.

The Commands

Arithmetic | Logic | Bitwise
Add - Addition | AND - Logical AND - 1 AND 1 gives 1. Any other input gives 0. | ROL - Rotate bits left. Bit at left end moved to right end.
Sub - Subtraction | OR - Logical OR - 0 OR 0 gives 0. Any other input gives 1. | ROR - Rotate bits right. Bit at right end moved to left end.
Mul - Multiplication | XOR - Logical exclusive OR - Equal inputs give 0. Non equal inputs give 1. | SHL - Shift bits left and discard leftmost bit.
Div - Division | NOT - Logical NOT - Invert the input. 0 gives 1. 1 gives 0. | SHR - Shift bits right and discard rightmost bit.
Mod - Remainder after division |  |
Inc - Increment (add one) |  |
Dec - Decrement (subtract one) |  |

COMMANDS | DIRECT EXAMPLES
OP | Assembler | Machine Code | Explanation
ADD | ADD AL,BL | A0 00 01 | Add BL to AL
SUB | SUB CL,DL | A1 02 03 | Subtract DL from CL
MUL | MUL AL,CL | A2 00 02 | Multiply AL by CL
DIV | DIV BL,DL | A3 01 03 | Divide BL by DL
MOD | MOD DL,BL | A6 03 01 | Remainder after dividing DL by BL
INC | INC AL | A4 00 | Add one to AL
DEC | DEC BL | A5 01 | Deduct one from BL
AND | AND CL,AL | AA 02 00 | CL becomes CL AND AL
OR | OR CL,DL | AB 02 03 | CL becomes CL OR DL
XOR | XOR BL,AL | AC 01 00 | BL becomes BL XOR AL
NOT | NOT CL | AD 02 | Invert the bits in CL
ROL | ROL DL | 9A 03 | Bits in DL rotated one place left
ROR | ROR AL | 9B 00 | Bits in AL rotated one place right
SHL | SHL BL | 9C 01 | Bits in BL shifted one place left
SHR | SHR CL | 9D 02 | Bits in CL shifted one place right

COMMANDS | IMMEDIATE EXAMPLES
OP | Assembler | Machine Code | Explanation
ADD | ADD AL,15 | B0 00 15 | Add 15 to AL
SUB | SUB BL,05 | B1 01 05 | Subtract 5 from BL
MUL | MUL AL,10 | B2 00 10 | Multiply AL by 10
DIV | DIV BL,04 | B3 01 04 | Divide BL by 4
MOD | MOD DL,20 | B6 03 20 | Remainder after dividing DL by 20
AND | AND CL,55 | BA 02 55 | CL becomes CL AND 55 (01010101)
OR | OR CL,AA | BB 02 AA | CL becomes CL OR AA (10101010)
XOR | XOR BL,F0 | BC 01 F0 | BL becomes BL XOR F0

Examples

ADD CL,AL - Add CL to AL and put the answer into CL.

ADD AL,22 - Add 22 to AL and put the answer into AL.

The answer always goes into the first register in the command.

DEC BL - Subtract one from BL and put the answer into BL.

The other commands all work in the same way.

Flags

If a calculation gives a zero answer, set the Z zero flag.
If a calculation gives a negative answer, set the S sign flag.
If a calculation overflows, set the O overflow flag.

An overflow happens if the result of a calculation has more bits than will fit into the available register. With 8 bit registers, the largest numbers that fit are -128 to + 127.


Jump Instructions

Jump Instructions - Flags are NOT set.

These instructions do NOT set the Z, S or O flags but conditional jumps use the flags to determine whether or not to jump.

The CPU contains a status register - SR. This contains flags that are set or cleared depending on the most recent calculation performed by the processor. The CMP compare instruction performs a subtraction like the SUB command. It sets the flags but the result is not stored.

The Flags - ISOZ

  1. ZERO - The Z flag is set if the most recent calculation gave a zero result.
  2. SIGN - The S flag is set if the most recent calculation gave a negative result.
  3. OVERFLOW - The O flag is set if the most recent calculation gave a result too big to fit a register.
  4. INTERRUPT - The I flag is set in software using the STI command. If this flag is set, the CPU will respond to hardware interrupts. The CLI command clears the I flag and hardware interrupts are ignored. The I flag is off by default.

The programmer enters a command like JMP HERE. The assembler converts this into machine code by calculating how far to jump. This tedious and error prone taks (for humans) is automated. In an 8 bit register, the largest numbers that can be stored are -128 and +127. This limits the maximum distance a jump can go. Negative numbers cause the processor to jump backwards towards zero. Positive numbers cause the processor to jump forward towards 255. The jump distance is added to IP, the instruction pointer.

To understand jumps properly, you also need to understand negative numbers.

COMMANDS | EXAMPLES
OP | Assembler | Machine Code | Explanation
JMP | JMP HERE | C0 25 | Unconditional jump. Flags are ignored. Jump forward 25h RAM locations.
JMP | JMP BACK | C0 FE | Jump Unconditional jump. Flags are ignored. Jump back -2d RAM locations.
JZ | JZ STOP | C1 42 | Jump Zero. Jump if the zero flag (Z) is set. Jump forward +42h places if the (Z) flag is set.
JZ | JZ START | C1 F2 | Jump Zero. Jump if the zero flag (Z) is set. Jump back -14d places if the (Z) flag is set.
JNZ | JNZ FORWARD | C2 22 | Jump Not Zero. Jump if the zero flag (Z) is NOT set. Jump forward 22h places if the (Z) flag is NOT set.
JNZ | JNZ REP | C2 EE | Jump Not Zero. Jump if the zero flag (Z) is NOT set. Jump back -18d places if the (Z) flag is NOT set.
JS | JS Minus | C3 14 | Jump Sign. Jump if the sign flag (S) is set. Jump forward 14h places if the sign flag (S) is set.
JS | JS Minus2 | C3 FC | Jump Sign. Jump if the sign flag (S) is set. Jump back -4d places if the sign flag (S) is set.
JNS | JNS Plus | C4 33 | Jump Not Sign. Jump if the sign flag (S) is NOT set. Jump forward 33h places if the sign flag (S) is NOT set.
JNS | JNS Plus2 | C4 E2 | Jump Not Sign. Jump if the sign flag (S) is NOT set. Jump back -30d places if the sign flag (S) is NOT set.
JO | JO TooBig | C5 12 | Jump Overflow. Jump if the overflow flag (O) is set. Jump forward 12h places if the overflow flag (O) is set.
JO | JO ReDo | C5 DF | Jump Overflow. Jump if the overflow flag (O) is set. Jump back -33d places if the overflow flag (O) is set.
JNO | JNO OK | C6 33 | Jump Not Overflow. Jump if the overflow flag (O) is NOT set. Jump forward 33h places if the overflow flag (O) is NOT set.
JNO | JNO Back | C6 E0 | Jump Not Overflow. Jump if the overflow flag (O) is NOT set. Jump back -32d places if the overflow flag (O) is NOT set.

The full 8086 instruction set has many other jumps. There are more flags in the 8086 as well!

Legal Destination Labels

here: | A nice correct label.
here:: | Not allowed Only one colon is permitted.
1234: | Not allowed. Labels must begin with a letter or '_'.
_: | OK but not human friendly.
here | Destination labels must end in a colon.

Some of these rules are not strictly enforced in the simulator.


Move Instructions

Move Instructions - Flags are NOT set.

Move instructions are used to copy data between registers and between RAM and registers.

Addressing Mode | Assembler Example | Supported | Explanation
Immediate | mov al,10 | YES | Copy 10 into AL
Direct (register) | mov al,bl | NO | Copy BL into AL
Direct (memory) | mov al,[50] | YES | Copy data from RAM at address 50 into AL.
 | mov [40],cl | YES | Copy data from CL into RAM at address 40.
Indirect | mov al,[bl] | YES | BL is a pointer to a RAM location. Copy data from that RAM location into AL.
 | mov [cl],dl | YES | CL is a pointer to a RAM location. Copy data from DL into that RAM location.
Indexed | mov al,[20 + bl] | NO | A data table is held in RAM at address 20. BL indexes a data item within the data table. Copy from the data table at address 20+BL into AL.
 | mov [20 + bl],al | NO | A data table is held in RAM at address 20. BL indexes a data item within the data table. Copy from AL into the data table at address 20+BL.
Base Register | mov al,[bl+si] | NO | BL points to a data table in memory. SI indexes to a record inside the data table. BL is called the "base register". SI is called the "offset or index". Copy from RAM at address BL+SI into AL.
 | mov [bl+si],al | NO | BL points to a data table in memory. SI indexes to a record inside the data table. BL is called the "base register". SI is called the "offset". Copy from AL into RAM at address BL+SI.

Right to Left Convention

ADDRESSING MODES

Immediate

MOV AL,10

Copy a number into a register. This is the simplest move command and easy to understand.

Direct (register)

MOV AL,BL

Copy one register into another. This is easy to understand. The simulator does not support this command. If you have to copy from one register to another, use a RAM location or the stack to achieve the move.

Direct (memory)

MOV AL,[50] ; Copy from RAM into AL. Copy the data from address 50.
MOV [50],AL ; Copy from AL into RAM. Copy the data to address 50.

The square brackets indicate data in RAM. The number in the square brackets indicates the RAM address/location of the data.

Indirect

MOV AL,[BL] ; Copy from RAM into AL. Copy from the address that BL points to.
MOV [BL],AL ; Copy from AL into RAM. Copy to the address that BL points to.

Copy between a specified RAM location and a register. The square brackets indicate data in RAM. In this example BL points to RAM.

Indexed

MOV AL,[20 + BL] ; Copy from RAM into AL. The RAM address is located at 20+BL.
MOV [20 + BL],AL ; Copy from AL into RAM. The RAM address is located at 20+BL.

Here the BL register is used to "index" data held in a table. The table data starts at address 20.

Base Register

MOV AL,[BL+SI] ; Copy from RAM into AL. The RAM address is located at BL+SI.
MOV [BL+SI],AL ; Copy from AL into RAM. The RAM address is located at BL+SI.

BL is the "base register". It holds the start address of a data table. SI is the "source index". It is used to index a record in the data table.


Compare Instructions

The Compare CMP Command - Flags are Set.

When the simulator does a comparison using CMP, it does a subtraction of the two values it is comparing. The status register flags are set depending on the result of the subtraction. The flags are set but the answer is discarded.

(Z) | If the values are equal, the subtraction gives a zero result and the (Z) zero flag is set.
(S) | If the number being subtracted was greater than the other than a negative answer results so the (S) sign flag is set.
 | If the number being subtracted is smaller than the other, no flags are set.

Use JZ and JS or JNZ and JNS to test the result of a CMP command.

Direct Memory Comparison

Assembler | Machine Code | Explanation
CMP CL,[20] | DC 02 20 | Here the CL register is compared with RAM location 20. Work out CL - RAM[20]. DC is the machine instruction for direct memory comparison. 02 refers to the AL register. 20 points to RAM address 20.

Direct Register Comparison

Assembler | Machine Code | Explanation
CMP AL,BL | DA 00 01 | Here two registers are compared. Work out AL - BL DA is the machine instruction for register comparison. 00 refers to the AL register. 01 refers to the BL register.

Immediate Comparison

Assembler | Machine Code | Explanation
CMP AL,0D | DB 00 0D | Here the AL register is compared with 0D, (the ASCII code of the Enter key). Work out AL - 0D. DB is the machine instruction for register comparison. 00 refers to the AL register. 0D is the ASCII code of the Enter key.


Stack Instructions

Stack Instructions - Flags are NOT set.

After pushing items onto the stack, always pop them off in reverse order. This is because the stack works by the Last In First Out (LIFO) rule. The stack is an area of RAM used in this particular way. Any part of RAM could be used. In the simulator, the stack is located just below the Video RAM at address [BF]. The stack grows towards zero. It is easily possible to implement a stack that grows the other way.

Stack Examples

Assembler | Machine Code | Explanation
PUSH BL | E0 01 | Push BL onto the stack and subtract one from the stack pointer. E0 is the machine instruction for PUSH. 01 refers to the BL register.
POP BL | E1 01 | Add one to the stack pointer and pop BL from the stack. E1 is the machine instruction for POP. 01 refers to the BL register.
PUSHF | EA | Save the CPU status register (SR) onto the stack. This saves the CPU flags.
POPF | EB | Restore the CPU status register (SR) from the stack. This restores the CPU flags.

The stack is used to ...

  • save register contents for later restoration.
  • pass parameters into procedures and return results.
  • reverse the order in which data is stored.
  • save addresses so procedures and interrupts can return to the right place.
  • perform postfix arithmetic.
  • make recursion possible.

Stack Pointer

A CPU register (SP) that keeps track of (is a pointer to) the data on the stack. It is colour coded with a blue highlight in the simulator RAM display.

Push and Pop

Push - Add data to the stack at the stack pointer position and subtract one from the stack pointer.
Pop - Add one to the stack pointer and remove data from the stack at the stack pointer position.

LIFO

Last in First out. The stack operates strictly to this rule. When data is pushed onto the stack, it must later be popped in reverse order.

Stack Overflow

The stack is repeatedly pushed until it is full. The simulator does not detect this condition and the stack can overwite program code or data. Real life programs can fail in the same way.

Stack Underflow

The stack is repeatedly popped until it is empty. The next pop causes an underflow.


Procedures

Procedures and Interrupts

Procedures and Interrupts - Flags are NOT set.

These are available in the registered version. Please register.

It is essential to save the registers and flags used by any procedure or interrupt and restore them after the procedure or interrupt has finished its work. Use push and pushf to save. Use pop and popf to restore values.

Assembler | Machine Code | Explanation
CALL 30 | CA 30 | Call the procedure at address 30. The return address is pushed onto the stack and the Instruction Pointer (IP) is set to 30. CA is the machine instruction for CALL. 30 is the address of the start of the procedure being called.
RET | CB | Return from the procedure. Set the Instruction Pointer (IP) to the return address popped off the stack. CB is the machine instruction for Return.
INT 03 | CC 03 | The Instruction Pointer (IP) is set to the address of the interrupt vector retrieved from RAM address 03. The return address is pushed onto the stack. CC is the machine instruction for INT. 03 is the address of the interrupt vector used by the INT command.
IRET | CD | Return from the interrupt. Set the Instruction Pointer (IP) to the return address popped off the stack. CD is the machine instruction for IRET.


Input Output Instructions

Input and Output Instructions - Flags are NOT set.

The simulator has 16 ports numbered from 00 to 0F. These are connected to simulated, outside-world peripherals.

Assembler | Machine Code | Explanation
IN 07 | F0 07 | Input from Port 07. F0 is the machine instruction for Input. 07 is the port number.
OUT 01 | F1 01 | Output to Port 01. F1 is the machine instruction for Output. 01 is the port number.

Peripherals

Port | Description
00 | Input from port 00 for simulated keyboard input.
01 | Output to port 01 to control the traffic lights.
02 | Output to port 02 to control the seven segment displays.
03 | Output to port 03 to control the heater. Input from port 03 to sense the thermostat state.
04 | Output to port 04 to control the snake in the maze.
05 | Output to port 05 to control the stepper motor.
06 | Output to port 06 to control the lift.
07 | Output to port 07 to make the keyboard visible. Input from port 07 to read the keyboard ASCII code.
08 | Output to port 08 to make the numeric keypad visible. Input from port 08 to read from the numeric keypad.
09-0F | Unused


Other Instructions

Miscellaneous Instructions - CLI and STI control the (I) Flag

Assembler | Machine Code | Explanation
HALT | 00 | Stop the program. 00 is the machine instruction for HALT. The program will cease to run if it encounters a HALT instruction. Continuous running is cancelled by this command. You can have several halt commands in one program. There should be only one END and code after END is ignored.
NOP | FF | Do nothing for one clock cycle. FF is the machine instruction for NOP. The program will do nothing for one clock cycle. The program then continues as normal. NOP is used to introduce time delays to allow slow electronics to keep up with the CPU. These are also called WAIT STATES.
CLO | FE | Close all the peripheral windows. FE is the machine code for CLO. It applies to this simulator only, and is used to close peripheral windows. This makes it easier to write demonstration programs without the screen getting too cluttered.
ORG 30 | NONE | Code Origin. Generate code starting from this address. To generate code from a starting address other than zero use ORG. This is useful to place procedures, interrupts or data tables at particular addresses in memory. ORG is an assembler directive and no code is generated.
DB 84 | 84 | Define a byte. Store the byte (84) in the next free RAM location. Use DB to create data tables containing bytes of data. Use BD to define an Interrupt Vector.
DB "Hello" | 48, 65, 6C, 6C, 6F | Define a string. Store the ASCII codes of the text in quotes in the next free RAM locations. Use DB to store text strings. The stored ASCII codes do not include an end-of-string marker. Use DB 00 for this.
CLI | FD | Clear the I flag If the I flag is cleared, hardware interrupts are ignored. This is the default state for the simulator. Resetting the CPU will also clear the I flag. The timer that generates hardware interrupts will do nothing.
STI | FC | Set the I flag If the I flag is set, the simulator will generate INT 02 at regular time intervals. It is necessary to have an interrupt vector stored at address 02 that points to interrupt handler code stored elsewhere. The interval between timer interrupts can be set using the slider in the Configuration Tab. If interrupts occur faster than the processor can handle them, a simulated system crash will follow. Adjust the CPU clock speed and the timer interval to prevent this – or cause it if you want to see what happens.

It is possible to program the simulator using pure machine codes. Here is a simple example.

; ===== NORMAL CODE =====
    MOV AL,0
    INC AL
    END
; ===== NORMAL CODE =====

Here is the same program in pure machine code apart from the required END keyword. This should run exactly as the program above.

; ===== PURE MACHINE CODE =====
    DB D0 ; MOV
    DB 00 ; AL
    DB 00 ; 0
    DB A4 ; INC
    DB 00 ; AL
    END
; ===== PURE MACHINE CODE =====

This is an interesting exercise but rather defeats the whole point of using an assembler. If you have a dog, why bark yourself? Manually calculating jump distances might be a useful learning exercise, especially for negative jumps.


List File

The List File

In the list file, your original program is shown.
Numbers in square blackets such as [1C] are the addresses at which the machine codes were generated.
The machine codes are shown.

Here is a typical line.

    MOV CL,C0	; [10]	D0 02 C0		; Video ram base address

The command is to move C0 into the AL register.
The machine code was generated at address [10].
The machine codes are D0 00 C0.
The programmer's comment is reproduced.


Negative Numbers

Negative Numbers
Dec
Hex
Dec
Hex
Dec
Hex
Dec
Hex
Dec
Hex
Dec
Hex
Dec
Hex
Dec
Hex
-128
80
-127
81
-126
82
-125
83
-124
84
-123
85
-122
86
-121
87
-120
88
-119
89
-118
8A
-117
8B
-116
8C
-115
8D
-114
8E
-113
8F
-112
90
-111
91
-110
92
-109
93
-108
94
-107
95
-106
96
-105
97
-104
98
-103
99
-102
9A
-101
9B
-100
9C
-099
9D
-098
9E
-097
9F
-096
A0
-095
A1
-094
A2
-093
A3
-092
A4
-091
A5
-090
A6
-089
A7
-088
A8
-087
A9
-086
AA
-085
AB
-084
AC
-083
AD
-082
AE
-081
AF
-080
B0
-079
B1
-078
B2
-077
B3
-076
B4
-075
B5
-074
B6
-073
B7
-072
B8
-071
B9
-070
BA
-069
BB
-068
BC
-067
BD
-066
BE
-065
BF
-064
C0
-063
C1
-062
C2
-061
C3
-060
C4
-059
C5
-058
C6
-057
C7
-056
C8
-055
C9
-054
CA
-053
CB
-052
CC
-051
CD
-050
CE
-049
CF
-048
D0
-047
D1
-046
D2
-045
D3
-044
D4
-043
D5
-042
D6
-041
D7
-040
D8
-039
D9
-038
DA
-037
DB
-036
DC
-035
DD
-034
DE
-033
DF
-032
E0
-031
E1
-030
E2
-029
E3
-028
E4
-027
E5
-026
E6
-025
E7
-024
E8
-023
E9
-022
EA
-021
EB
-020
EC
-019
ED
-018
EE
-017
EF
-016
F0
-015
F1
-014
F2
-013
F3
-012
F4
-011
F5
-010
F6
-009
F7
-008
F8
-007
F9
-006
FA
-005
FB
-004
FC
-003
FD
-002
FE
-001
FF

Positive Numbers
Dec
Hex
Dec
Hex
Dec
Hex
Dec
Hex
Dec
Hex
Dec
Hex
Dec
Hex
Dec
Hex
+000
00
+001
01
+002
02
+003
03
+004
04
+005
05
+006
06
+007
07
+008
08
+009
09
+010
0A
+011
0B
+012
0C
+013
0D
+014
0E
+015
0F
+016
10
+017
11
+018
12
+019
13
+020
14
+021
15
+022
16
+023
17
+024
18
+025
18
+026
1A
+027
1B
+028
1C
+029
1D
+030
1E
+031
1F
+032
20
+033
21
+034
22
+035
23
+036
24
+037
25
+038
26
+039
27
+040
28
+041
29
+042
2A
+043
2B
+044
2C
+045
2D
+046
2E
+047
2F
+048
30
+049
31
+050
32
+051
33
+052
34
+053
35
+054
36
+055
37
+056
38
+057
39
+058
3A
+059
3B
+060
3C
+061
3D
+062
3E
+063
3F
+064
40
+065
41
+066
42
+067
43
+068
44
+069
45
+070
46
+071
47
+072
48
+073
49
+074
4A
+075
4B
+076
4C
+077
4D
+078
4E
+079
4F
+080
50
+081
51
+082
52
+083
53
+084
54
+085
55
+086
56
+087
57
+088
58
+089
59
+090
5A
+091
5B
+092
5C
+093
5D
+094
5E
+095
5F
+096
60
+097
61
+098
63
+099
63
+100
64
+101
65
+102
66
+103
67
+104
68
+105
69
+106
6A
+107
6B
+108
6C
+109
6D
+110
6E
+111
6F
+112
70
+113
71
+114
72
+115
73
+116
74
+117
75
+118
76
+119
77
+120
78
+121
79
+122
7A
+123
7B
+124
7C
+125
7D
+126
7E
+127
7F

Two's complement

The numbers work as follows.

The leftmost bit in an eight bit byte is the sign bit.

    1 0 1 0 1 0 1 0
    ^
    ^ The sign bit has a value of -128 decimal or -80 hexadecimal.

The other seven bits are treated as a normal positive number between 0 and 127. This is true whether the overall number is positive or negative. For example to store -1 the binary is

    1 1 1 1 1 1 1 1     - 128d + 127d = -1d
    ^
    ^ -128d

To store 127 decimal, the binary is

    0 1 1 1 1 1 1 1     0 + 127d = 127d
    ^
    ^ The sign bit is zero.

16 and 32 bit machines also use the leftmost bit as the sign bit. The negative numbers work in exactly the same way but much bigger niumbers can be stored. In a 16 bit machine, the sign bit is worth -32768. In a 32 bit machine, the sign bit is worth -2147483648 (2000 million approximately).


Pop-up Help

ADD AND CALL CLI CLO CMP DB DEC DIV END HALT IN INC INT

IRET JMP JNO JNS JNZ JO JS JZ MOD MOV MUL NOP NOT OR ORG

OUT POP POPF PUSH PUSHF RET ROL ROR SHL SHR STI SUB XOR

CPU General Purpose Registers

The CPU is where all the arithmetic and logic (decision making) takes place. The CPU has storage locations called registers. The CPU has flags which indicate zero, negative or overflowed calculations. More information is included in the description of the system architecture.

The CPU registers are called AL, BL, CL and DL.
The machine code names are 00, 01, 02 and 03.

Registers are used for storing binary numbers.

Once the numbers are in the registers, it is possible to perform arithmetic or logic. Sending the correct binary patterns to peripherals like the traffic lights, makes it possible to control them.

; semicolon begins a program comment.

Comments are used to document programs. They are helpful to new programmers joining a team and to existing people returning to a project having forgotten what it is about.

Good comments explain WHY things are being done. Poor comments simply repeat the code or state the totally obvious.

Ram Addresses

Examples [7F] [22] [AL] [CL]

[7F] the contents of RAM at location 7F

[CL] the contents of the RAM location that CL points to. CL contains a number that is used as the address.

The Instruction Set

Top

ADD - Add two values together

CPU flags are set
Assembler | Machine Code | Explanation
ADD BL,CL | A0 01 02 | Add CL to BL. Answer goes into BL
ADD AL,12 | B0 00 12 | Add 12 to AL. Answer goes into AL

Top

AND - Logical AND two values together

CPU flags are set
Assembler | Machine Code | Explanation
AND BL,CL | AA 01 02 | AND CL with BL. Answer goes into BL
AND AL,12 | BA 00 12 | AND 12 with AL. Answer goes into AL

The AND rule is that two ones give a one. All other inputs give nought. Look at this example...

       10101010
       00001111
       --------
ANSWER 00001010

The left four bits are masked to 0.

Top

CALL and RET

CPU flags are NOT set
Assembler | Machine Code | Explanation
CALL 50 CA 50 Call the procedure at address 50.
The CPU pushes the instruction pointer value IP + 2 onto the stack. Later the CPU returns to this address.
IP is then set to 50.
RET | CB | The CPU instruction pointer is set to 50. The CPU executes instructions from this address until it reaches the RET command. It then pops the value of IP off the stack and jumps to this address where execution resumes.

Top

CLI and STI

CPU (I) flag is set/cleared
Assembler | Machine Code | Explanation
STI | FC | STI sets the Interrupt flag.
CLI FD CLI clears the Interrupt flag 'I' in the status register. STI sets the interrupt flag 'I' in the status register. The machine code for CLI is FD. The machine code for STI is FC.
If (I) is set, the CPU will respond to interrupts. The simulator generates a hardware interrupt at regular time intervals that you can adjust.
If 'I' is set, there should be an interrupt vector at address [02]. The CPU will jump to the code that this vector points to whenever there is an interrupt.

Top

CLO

CPU flags are NOT set
Assembler Machine Code Explanation
CLO FE Close unwanted peripheral windows.
CLO is not an x86 command. It closes all unnecessary simulator windows which would otherwise have to be closed manually one by one.

Top

CMP

CPU flags are set
Assembler Machine Code Explanation
CMP AL,0D DB 00 0D Compare AL with 0D
If the values being compared are ...
EQUAL set the 'Z' flag.
AL less than 0D set the 'S' flag.
AL greater than 0D set no flags.
CMP AL,BL DA 00 01 Compare AL with BL
If the values being compared are ...
EQUAL set the 'Z' flag.
AL less than BL set the 'S' flag.
AL greater than BL set no flags.
CMP CL,[20] DC 02 20 Compare CL with 20
If the values being compared are ...
EQUAL set the 'Z' flag.
CL less than RAM[20] set the 'S' flag.
CL greater than RAM[20] set no flags.

Top

DB

CPU flags are NOT set
Assembler Machine Code Explanation
DB 22
DB 33
DB 44
DB 0 		22
33
44
00 		Define Byte
DB gives a method for loading values directly into RAM.
DB does not have a machine code.
The numbers or text after DB are loaded into RAM.
Use DB to set up data tables.
DB "Hello"

DB 0 		48
65
6C
6C
6F
00 		ASCII codes are loaded into RAM.

End of text is marked by NULL

Top

DEC and INC

CPU flags are set
Assembler | Machine Code | Explanation
INC BL | A4 01 | Add one to BL.
DEC AL | A5 00 | Subtract one from AL.

Top

DIV and MOD

CPU flags are set
Assembler Machine Code Explanation
DIV AL,5 B3 00 05 Divide AL by 5. Answer goes into AL.
DIV differs from the x86 DIV.
DIV AL,BL A3 00 01 Divide AL by BL. Answer goes into AL.
DIV differs from the x86 DIV.
MOD AL,5 B6 00 05 MOD AL by 5.
Remainder after division goes into AL.
MOD is not an x86 command.
MOD AL,BL A6 00 01 MOD AL by BL.
Remainder after division goes into AL.
MOD is not an x86 command.

The x86 DIV calculates div and mod in one command. The answers are put into different registers. This is not possible with the 8 bit simulator so div and mod are separated and simplified.

8 DIV 3 is 3 (with remainder 2). 8 MOD 3 is 2

Top

END

CPU flags are NOT set
Assembler Machine Code Explanation
END 00 END stops further program execution.
The simulator achieves this by stopping the CPU clock.
END is also an assembler directive.
All code after END is ignored by the assembler.
There should be only one END in a program.

Top

HALT

CPU flags are NOT set
Assembler Machine Code Explanation
HALT 00 HALT stops further program execution.
The simulator achieves this by stopping the CPU clock.
HALT is not an assembler directive. (See END)
There can be any number of HALT commands in a program.

Top

IN and OUT

CPU flags are NOT set
Assembler | Machine Code | Explanation
IN 07 | F0 07 | Input from port 07. The data is stored in the AL register.
OUT 03 | F1 03 | Output to port 03. The data comes from the AL register.

Top

INC and DEC

CPU flags are set
Assembler | Machine Code | Explanation
INC BL | A4 01 | Add one to BL.
DEC AL | A5 00 | Subtract one from AL.

Top

INT and IRET

CPU flags are NOT set
Assembler Machine Code Explanation
INT 02 CC 02 The return address (IP + 2) is pushed onto the stack.
The stack pointer (SP) is reduced by one.
RAM location 02 contains the address of the Interrupt Handler.
This address is "fetched" and IP is set to it.
IRET CD The return address is popped off the stack.
The stack pointer (SP) is increased by one.
IP is set to the return address popped off the stack.

Top

JMP

CPU flags are NOT set and the flags are ignored
Assembler Machine Code Explanation
JMP Forward C0 12 Set IP to a new value
Add 12 to IP
The assembler calculates the jump distance.
The biggest possible forward jump is +127.
JMP Back FE Set IP to a new value
Add -2 to IP
FE is -2. This is explained here.
The assembler calculates the jump distance.
The biggest possible backward jump is -128.

Top

JNO

CPU flags are NOT set. JNO uses the (O) flag.

The (O) flag is set if a calculation gives a result too big to fit in an 8 but register.
Assembler Machine Code Explanation
JNO Forward C6 12 Jump if the (O) flag is NOT set.
If the (O) flag is NOT set, jump forward 12 places.
If the (O) flag is NOT set, add 12 to (IP).
If the (O) flag is set, add 2 to (IP).
The assembler calculates the jump distance.
The biggest possible forward jump is +127.
JNO Back C6 FE Jump if the (O) flag is NOT set.
If the (O) flag is NOT set, jump back 2 places.
If the (O) flag is NOT set, add -2 to (IP).
If the (O) flag is set, add 2 to (IP).
The assembler calculates the jump distance.
The biggest possible backward jump is -128.
FE is -2. This is explained here.

Top

JNS

CPU flags are NOT set. JNS uses the (S) flag.

The (S) flag is set if a calculation gives a negative result.
Assembler Machine Code Explanation
JNS Forward C4 12 Jump if the (S) flag is NOT set.
If the (S) flag is NOT set, jump forward 12 places.
If the (S) flag is NOT set, add 12 to (IP).
If the (S) flag is set, add 2 to (IP).
The assembler calculates the jump distance.
The biggest possible forward jump is +127.
JNS Back C4 FE Jump if the (S) flag is NOT set.
If the (S) flag is NOT set, jump back 2 places.
If the (S) flag is NOT set, add -2 to (IP).
If the (S) flag is set, add 2 to (IP).
The assembler calculates the jump distance.
The biggest possible backward jump is -128.
FE is -2. This is explained here.

Top

JNZ

CPU flags are NOT set. JNZ uses the (Z) flag.

The (Z) flag is set if a calculation gives a zero result.
Assembler Machine Code Explanation
JNZ Forward C2 12 Jump if the (Z) flag is NOT set.
If the (Z) flag is NOT set, jump forward 12 places.
If the (Z) flag is NOT set, add 12 to (IP).
If the (Z) flag is set, add 2 to (IP).
The assembler calculates the jump distance.
The biggest possible forward jump is +127.
JNZ Back C2 FE Jump if the (Z) flag is NOT set.
If the (Z) flag is NOT set, jump back 2 places.
If the (Z) flag is NOT set, add -2 to (IP).
If the (Z) flag is set, add 2 to (IP).
The assembler calculates the jump distance.
The biggest possible backward jump is -128.
FE is -2. This is explained here.

Top

JO

CPU flags are NOT set. JO uses the (O) flag.

The (O) flag is set if a calculation gives a result too big to fit in an 8 but register.
Assembler Machine Code Explanation
JO Forward C5 12 Jump if the (O) flag is set.
If the (O) flag is set, jump forward 12 places.
If the (O) flag is set, add 12 to (IP).
If the (O) flag is NOT set, add 2 to (IP).
The assembler calculates the jump distance.
The biggest possible forward jump is +127.
JO Back C5 FE Jump if the (O) flag is set.
If the (O) flag is set, jump back 2 places.
If the (O) flag is set, add -2 to (IP).
If the (O) flag is NOT set, add 2 to (IP).
The assembler calculates the jump distance.
The biggest possible backward jump is -128.
FE is -2. This is explained here.

Top

JS

CPU flags are NOT set. JS uses the (S) flag.

The (S) flag is set if a calculation gives a negative result.
Assembler Machine Code Explanation
JS Forward C3 12 Jump if the (S) flag is set.
If the (S) flag is set, jump forward 12 places.
If the (S) flag is set, add 12 to (IP).
If the (S) flag is NOT set, add 2 to (IP).
The assembler calculates the jump distance.
The biggest possible forward jump is +127.
JS Back C3 FE Jump if the (S) flag is set.
If the (S) flag is set, jump back 2 places.
If the (S) flag is set, add -2 to (IP).
If the (S) flag is NOT set, add 2 to (IP).
The assembler calculates the jump distance.
The biggest possible backward jump is -128.
FE is -2. This is explained here.

Top

JZ

CPU flags are NOT set. JZ uses the (Z) flag.

The (Z) flag is set if a calculation gives a zero result.
Assembler Machine Code Explanation
JZ Forward C1 12 Jump if the (Z) flag is set.
If the (Z) flag is set, jump forward 12 places.
If the (Z) flag is set, add 12 to (IP).
If the (Z) flag is NOT set, add 2 to (IP).
The assembler calculates the jump distance.
The biggest possible forward jump is +127.
JZ Back C1 FE Jump if the (Z) flag is set.
If the (Z) flag is set, jump back 2 places.
If the (Z) flag is set, add -2 to (IP).
If the (Z) flag is NOT set, add 2 to (IP).
The assembler calculates the jump distance.
The biggest possible backward jump is -128.
FE is -2. This is explained here.

Top

DIV and MOD

CPU Flags are Set
Assembler Machine Code Explanation
DIV AL,5 B3 00 05 Divide AL by 5. Answer goes into AL.
DIV differs from the x86 DIV.
DIV AL,BL A3 00 01 Divide AL by BL. Answer goes into AL.
DIV differs from the x86 DIV.
MOD AL,5 B6 00 05 MOD AL by 5.
Remainder after division goes into AL.
MOD is not an x86 command.
MOD AL,BL A6 00 01 MOD AL by BL.
Remainder after division goes into AL.
MOD is not an x86 command.

The x86 DIV calculates div and mod in one command. The answers are put into different registers. This is not possible with the 8 bit simulator so div and mod are separated and simplified.

8 DIV 3 is 3 (with remainder 2). 8 MOD 3 is 2

Top

MOV

CPU flags are NOT set
Addressing Mode Assembler Example
Machine Code 		Supported Explanation
Immediate mov al,10

D0 00 10
YES
 Copy 10 into AL
Direct (register) mov al,bl
NO
 Copy BL into AL
Direct (memory) mov al,[50]

D1 00 50
YES
 Copy data from RAM at address 50 into AL. [50] is a pointer to data held in a RAM location.
mov [40],cl

D2 40 02
YES
 Copy data from CL into RAM at address 40. [40] is a pointer to data held in a RAM location.
Indirect mov al,[bl]

D3 00 01
YES
 BL is a pointer to a RAM location. Copy data from that RAM location into AL.
mov [cl],dl

D4 02 03
YES
 CL is a pointer to a RAM location. Copy data from DL into that RAM location.
Indexed mov al,[20 + bl]
NO
 A data table is held in RAM at address 20. BL indexes a data item within the data table. Copy from the data table at address 20+BL into AL.
mov [20 + bl],al
NO
 A data table is held in RAM at address 20. BL indexes a data item within the data table. Copy from AL into the data table at address 20+BL.
Base Register mov al,[bl+si]
NO
 BL points to a data table in memory. SI indexes to a record inside the data table. BL is called the "base register". SI is called the "offset or index". Copy from RAM at address BL+SI into AL.
mov [bl+si],al
NO
 BL points to a data table in memory. SI indexes to a record inside the data table. BL is called the "base register". SI is called the "offset". Copy from AL into RAM at address BL+SI.

Top

MUL

CPU Flags are Set
Assembler Machine Code Explanation
MUL AL,BL A2 00 01 Multiply AL by BL. The result goes into AL
MUL differs from the x86 MUL.
MUL CL,12 B2 02 12 Multiply CL by 12. The result goes into CL
MUL differs from the x86 MUL.

The x86 MUL places the result into more than one register. This is not possible with the 8 bit simulator so MUL has been simplified. A disadvantage is that an overflow is much more likely to occur.

Top

NOP

CPU Flags are NOT Set
Assembler Machine Code Explanation
NOP FF Do nothing.
Do nothing for one CPU clock cycle.
This is needed to keep the CPU synchronised with accurately timed electronic circuits.
The CPU might need to delay before the electronics are ready.

Top

NOT

CPU Flags are Set
Assembler | Machine Code | Explanation
NOT DL | AD 03 | Invert all the bits in DL.
If DL contained 01010101, after using NOT it will contain 10101010.

Top

OR

CPU Flags are Set
Assembler | Machine Code | Explanation
OR AL,12 | BB 00 12 | Or 12 with AL. Answer goes into AL
OR BL,CL | AB 01 02 | Or CL with BL. Answer goes into BL
The OR rule is that two noughts give a nought. All other inputs give one.
   10101010
OR 00001111
   --------
 = 10101111

Top

ORG

CPU Flags are NOT Set
Assembler | Machine Code | Explanation
ORG 50 | None | ORG is not a CPU instruction. It is an instruction to the assembler to tell it to generate code at a particular address. It is useful for writing procedures and interrupts. It can also be used to specify where in memory, data tables go.

Top

OUT and IN

CPU Flags are NOT Set
Assembler | Machine Code | Explanation
IN 07 | F0 07 | Input from port 07. The data is stored in the AL register.
OUT 03 | F1 03 | Output to port 03. The data comes from the AL register.

Top

PUSH, POP, PUSHF and POPF

CPU Flags are NOT Set
Assembler | Machine Code | Explanation
PUSH AL E0 00 Save AL onto the stack.
Deduct one from the Stack Pointer (SP)
POP BL E1 01 Add one to the stack pointer (SP).
Restore BL from the stack
PUSHF | EA | Push the CPU flags from the status register (SR) onto the stack. Deduct one from the Stack Pointer (SP)
POPF | EB | Add one to the stack pointer (SP). POP the CPU flags from the stack into the ststus register (SR).

PUSH saves a byte onto the stack. POP gets it back.The stack is an area of memory that obeys the LIFO rule - Last In First Out. When pushing items onto the stack, remember to pop them off again in exact reverse order. The stack can be used to

  1. hold the return address of a procedure call
  2. hold the return address of an interrupt call
  3. pass parameters into procedures
  4. get results back from procedures
  5. save and restore registers and flags
  6. reverse the order of data.

Top

RET and CALL

CPU Flags are NOT Set
Assembler | Machine Code | Explanation
CALL 50 CA 50 Call the procedure at address 50.
The CPU pushes the instruction pointer value IP + 2 onto the stack. Later the CPU returns to this address.
IP is then set to 50.
RET | CB | The CPU instruction pointer is set to 50. The CPU executes instructions from this address until it reaches the RET command. It then pops the value of IP off the stack and jumps to this address where execution resumes.

Top

ROL and ROR

CPU Flags are Set
Assembler Machine Code Explanation
ROL AL 9A 00 Rotate the bits in AL left one place.
The leftmost bit is moved to the right end of the byte.
Before ROL 10000110 - After ROL 00001101
ROR DL 9B 03 Rotate the bits in DL right one place.
The rightmost bit is moved to the left end of the byte.
Before ROR 10000110 - After ROR 01000011

Top

SHL and SHR

CPU Flags are Set
Assembler Machine Code Explanation
SHL AL 9C 00 Shift bits left one place.
The leftmost bit is discarded.
Before SHL 10000110 - After SHL 00001100
SHR DL 9D 03 Shift bits right one place.
The rightmost bit is discarded.
Before SHR 10000110 - After SHR 01000011

Top

STI and CLI

CPU Flags are NOT Set
Assembler | Machine Code | Explanation
STI | FC | STI sets the Interrupt flag.
CLI FD CLI clears the Interrupt flag 'I' in the status register. STI sets the interrupt flag 'I' in the status register. The machine code for CLI is FD. The machine code for STI is FC.
If (I) is set, the CPU will respond to interrupts. The simulator generates a hardware interrupt at regular time intervals that you can adjust.
If 'I' is set, there should be an interrupt vector at address [02]. The CPU will jump to the code that this vector points to whenever there is an interrupt.

Top

SUB

CPU Flags are Set
Assembler | Machine Code | Explanation
SUB AL,12 | B1 00 12 | Subtract 12 from AL. The answer goes into AL.
SUB BL,CL | A1 01 02 | Subtract CL from BL. The answer goes into BL.

Top

XOR

CPU Flags are Set
Assembler | Machine Code | Explanation
XOR AL,12 | BC 00 12 | 12 XOR AL. The answer goes into AL.
XOR BL,CL | AC 01 02 | CL XOR BL. The answer goes into BL.

XOR can be used to invert selected bits.

     00001111 This is a bit mask.
 XOR 01010101
     --------
     01011010

The left four bits are unaltered. The right four bits are inverted.

Top


Truth Tables and Logic

Boolean Operators - Flags are Set

A mathematician called Bool invented a branch of maths for processing true and false values instead of numbers. This is called Boolean Algebra. Simple Boolean algebra is consistent with common sense but if you need to process decisions involving many values that might be true or false according to complex rules, you need this branch of mathematics.

The Rules

Rule | One Line Explanation
AND | 1 AND 1 gives 1. Any other input gives 0.
NAND | (NOT AND) 1 AND 1 gives 0. Any other input gives 1.
OR | 0 OR 0 gives 0. Any other input gives 1.
NOR | (NOT OR) 0 OR 0 gives 1. Any other input gives 0.
XOR | Equal inputs give 0. Non equal inputs give 1.
NOT | Invert input bits. 0 becomes 1. 1 becomes 0.

Computers work using LOGIC. Displaying graphics such as the mouse cursor involves the XOR (Exclusive OR) command. Addition makes use of AND and XOR. These and a few of the other uses of logic are described below.

Truth Tables

The one line descriptions of the rules above are clearer if shown in Truth Tables. These tables show the output for all possible input conditions.

Logic Gates

Logic gates are the building blocks of microcomputers. Modern processors contain millions of gates. Each gate is built from a few transistors. The gates are used to store data, perform arithmetic and manipulate bits using the rules above. The XOR rule can be used to test bits for equality.

AND

Both inputs must be true for the output to be true. AND is used for addition and decision making.

 -----------
  A B Output
 -----------
  0 0    0
  0 1    0
  1 0    0
  1 1    1

OR

Both inputs must be false for the output to be false. OR is used in decision making. Both AND and OR are used for Bit Masking. Bit masking is used to pick individual bits out of a byte or to set particular bits in a byte. OR is used to set bits to one. AND is used to set bits to nought. AND is used to test if bits are one. OR is used to test if bits are nought.

 -----------
  A B Output
 -----------
  0 0    0
  0 1    1
  1 0    1
  1 1    1

XOR

If the bits in a graphical image are XORed with other bits a new image appears. If the XORing is repeated the image disappears again. This is how the mouse and text cursors get moved around the screen. XOR is combined with AND for use in addition. XOR detects if the inputs are equal or not.

 -----------
  A B Output
 -----------
  0 0    0
  0 1    1
  1 0    1
  1 1    0

NAND

NAND is really AND followed by NOT. Electronic circuits are commonly built from NAND gates (circuits). Computer programming languages and this simulator do not provide NAND. Use NOT AND instead.

 -----------
  A B Output
 -----------
  0 0    1
  0 1    1
  1 0    1
  1 1    0

NOR

NOR is really OR followed by NOT. Electronic circuits are commonly built from NOR gates (circuits). Computer programming languages and this simulator do not provide NOR. Use NOT OR instead.

 -----------
  A B Output
 -----------
  0 0    1
  0 1    0
  1 0    0
  1 1    0

NOT

NOT is used to invert bits or True/False values. All the rules above had two inputs and one output. NOT has a single input and output.

 -----------
  A  Output
 -----------
  0     1
  1     0

The Half Adder Truth Table

The half adder does binary addition on two bits.
The AND gate conputes the carry bit.
The XOR gate computes the sum bit.

0 + 0 = 0, carry 0
0 + 1 = 1, carry 0
1 + 0 = 1, carry 0
1 + 1 = 0, carry 1

 ------------------
  A B   SUM  CARRY
 ------------------
  0 0    0     0
  0 1    1     0
  1 0    1     0
  1 1    0     1


Using the Editor

Using the Editor

Editing the source code in the simulator is similar to most word processors and text editors such as the Windows Notepad.

Undo

You can undo an editing error. When you have an accident and delete or mess up something by mistake, you can press Ctrl+Z to UNDO the last thing you did. This can be very useful.

Cursor Movements

Move the text cursor. For small movements, use the Arrow Keys, Home, End, Page Up and Page Down. You can use the mouse too.

For larger movements, hold down the Ctrl key and use the Arrow Keys, Home, End, Page Up, and Page Down. You can use the mouse too.

Deleting

Delete previous character with the Backspace Key

Delete next character with the Delete Key

Highlighting

To highlight a block of text and hold down the Shift key and use the Arrow Keys, Home, End, Page Up and Page Down. You can drag the mouse with the left button pressed to do this too.

To highlight whole words, lines or documents, hold down Shift and Ctrl and then use the Arrow Keys, Home, End, Page Up and Page Down. Alternatively drag the mouse with the left button pressed.

Key | Explanation
Ctrl+C | Copy a highlighted block
Ctrl+X | Cut a highlighted block
Ctrl+V | Paste text copied or cut earlier
Delete | Delete a highlighted block
Ctrl+S | Save a file
Alt+F a | Save a file with a new name
Ctrl+O | Open a file
Alt+F x | Quit


Using the Peripherals

Virtual Peripherals

Using the Peripheral Devices

Keyboard
Port 07
INT 03
How to Use
This is one of the more complex devices. To make the keyboard visible, use OUT 07. Every time a key is pressed, a hardware interrupt, INT 03 is generated. By default, the CPU will ignore this interrupt. To process the interrupt, at the start of the program, use the STI command to set the interrupt flag (I) in the CPU status register (SR). Place an interrupt vector at RAM address 03. This should point to your interrupt handler code. The interrupt handler should use IN 07 to read the key press into the AL register.

Once STI has set the (I) flag in the status register (SR), interrupts from the hardware timer will also be generated. These must be processed too. The hardware timer generates INT 02. To process this interrupt, place an interrupt vector at RAM location 02. This should point to the timer interrupt handler code. The timer code can be as simple as IRET. This will cause an interrupt return without doing any other processing.
    jmp	start
    db	10	; Hardware Timer Interrupt Vector
    db	20	; Keyboard Interrupt Vector

; ===== Hardware Timer =======
    org	10
    nop		; Do something useful here
    nop
    nop
    nop
    nop
    iret
; ============================

; ===== Keyboard Handler =====
    org	20
    CLI		; Prevent re-entrant use
    push	al
    pushf

    in	07
    nop		; Process the key press here
    nop
    nop
    nop
    nop

    popf
    pop	al
    STI
    iret
; ============================

; ===== Idle Loop ============
start:
    STI		; Set (I) flag
    out	07	; Make keyboard visible
idle:
    nop		; Do something useful here
    nop
    nop
    nop
    nop
    jmp	idle
; ============================
    end
; ============================

Visual Display Unit
Memory Mapped 		How to Use

The Visual Display Unit (VDU) is memory mapped. This means that RAM locations correspond to positions on the screen. RAM location C0 maps to the top left corner of the VDU. The screen has 16 columns and four rows mapped to RAM locations C0 to FF. When you write ASCII codes to these RAM locations, the corresponting text characters appear and the VDU is made visible. This device, when combined with a keyboard, is sometimes called a dumb terminal. It has no graphics capabilities. Here is a code snippet to write text to the screen.

; ===== Memory Mapped VDU =====================================================
    MOV	AL,41	; ASCII code of 'A'
    MOV	[C0],AL	; RAM location mapped to the top left corner of the VDU
    MOV	AL,42	; ASCII code of 'B'
    MOV	[C1],AL	; RAM location mapped to the VDU
    MOV	AL,43	; ASCII code of 'C'
    MOV	[C2],AL	; RAM location mapped to the VDU

    END
; =============================================================================

Traffic Lights
Port 01 		How to Use

The traffic lights are connected to Port 01. If a byte of data is sent to this port, wherever there is a one, the corresponding traffic light comes on. In the image on the left, the binary data is 01010101. If you look closely you can see that the lights that are on, correspond to the ones in the data byte. 01010101 is 55 hexadecimal. Hex' numbers are explained here. Here is a code snippet to control the lights.

; ===========================================================================
; ===== 99Tlight.asm ========================================================
; ===== Traffic Lighte on Port 01 ===========================================
Start:
    MOV	AL,55	; 01010101
    OUT	01	; Send the data in AL to Port 01 (the traffic lights)

    MOV	AL,AA	; 10101010
    OUT	01	; Send the data in AL to Port 01 (the traffic lights)

    JMP	Start

    END
; ===========================================================================

Seven Segment Displays
Port 02 		How to Use

The seven segments displays are connected to Port 02. If a byte of data is sent to this port, wherever there is a one, the corresponding segment comes on. The rightmost bit controls which of the two groups of segments is active. This is a simple example of mulitplexing. If the least significant bit (LSB) is zero, the left segments will be active. If the least significant bit (LSB) is one, the right segments will be active. Here is a code snippet.

; ======================================================
; ===== 99sevseg.asm ===================================
; ===== Seven Segment Displays Port 02 =================
Start:
    MOV	AL,FA	; 1111 1010
    OUT	02	; Send the data in AL to Port 02

    MOV	AL,0	; 0000 0000
    OUT	02	; Send the data in AL to Port 02

    MOV	AL,FB	; 1111 1011
    OUT	02	; Send the data in AL to Port 02

    MOV	AL,1	; 0000 0001
    OUT	02	; Send the data in AL to Port 02

    JMP	Start

    END
; ======================================================

Heater and Thermostat
Port 03 		How to Use

The heater and thermostat system is connected to Port 03. Send 00 to port 3 to turn the heater off. Send 80 to port 03 to turn the heater on. Input from port 03 to test the thermostat state. The code snippet below is an incomplete solution to control the heater to keep the temperature steady at about 21 C. You can click the thermometer to set the temperature. This can save time when you are testing the system.

; ===== Heater and Thermostst on Port 03 ==========================
; ===== 99Heater.asm ==============================================
; ===== Heater and Thermostst on Port 03 ==========================
    MOV	AL,0	; Code to turn the heater off
    OUT	03	; Send code to the heater

    IN	03	; Input from Port 03
    AND	AL,1	; Mask off left seven bits
    JZ	Cold	; If the result is zero, turn the heater on
    HALT		; Quit

Cold:
    MOV	AL,80	; Code to turn the heater on
    OUT	03	; Send code to the heater

    END
; =================================================================

Snake and Maze
Port 04 		How to Use

The left four bits control the direction of the snake.

  • 80 Up
  • 40 Down
  • 20 Left
  • 10 Right

The right four bits control the distance moved.

For example, 4F means Down 15. 4 means down. F means 15.

This program is rather wasteful of RAM. If you want to traverse the entire maze and go back to the strart, you will run out of RAM. A good learning task is to use a data table. This reduces the size of the program greatly. Also, it is good style to separate code and data.

Here is a code sample - not using a data table.

; ================================================================
; ===== 99snake.asm ==============================================
; ===== Snake and Maze ===========================================

Start:
    MOV	AL,FF	; Special code to reset the snake.
    OUT	04	; Send AL to port 04 to control the snake.

    MOV	AL,4F	; 4 means DOWN.  F means 15.
    OUT	04	; Send 4F to the snake
    OUT	04	; Send 4F to the snake
    OUT	04	; Send 4F to the snake
    OUT	04	; Send 4F to the snake

    JMP	Start

    END
; ================================================================

Stepper Motor
Port 05 		How to Use

Here is a stepper motor. Normal motors run continuously and it is hard to control their movement. Stepper motors step through a precise angle when electromagnets are energised. Stepper motors are used for precise positional control in printers, plotters, robotic devices, disk drives and for any application where precise positional accuracy is required.

The motor is controlled by energising the four magnets in turn. It is possible to make the motor move in half steps by energising single and pairs of magnets. If the magnets are energised in the wrong sequence, the motor complains by a bleep from the computer speaker. Here is a code snippet to control the motor. Note that it would be better coding style to use a data table.

; ================================
; ===== 99Step.asm ===============
; ===== Stepper Motor ============
    mov	al,1	out	05
    mov	al,2	out	05
    mov	al,4	out	05
    mov	al,8	out	05
    mov	al,9	out	05
    mov	al,1	out	05
    mov	al,3	out	05
    mov	al,2	out	05
    mov	al,6	out	05
    mov	al,4	out	05
    mov	al,c	out	05
    mov	al,8	out	05
    mov	al,9	out	05
    mov	al,1	out	05

    end
; ================================

Lift/Elevator
Port 06 		How to Use

Input Signals

Bits 8 and 7 are unused. Bit 6 is wired to the top call button. Bit 5 is wired to the bottom call button. If these buttons are clicked with the mouse, the corresponding bits come on. Bit 4 senses the lift and goes high when the lift cage reaches the bottom of the shaft. Bit 3 senses the lift and goes high when the lift cage reaches the top of the shaft.

Outputs

Bit 2 turns on the lift motor and the cage goes down.

Bit 1 turns on the lift motor and the cage goes up.

Ways To Destroy the Lift

  1. Turn on bits 1 and 2 at the same time. This causes the motor to go up and down simulatneously!
  2. Crash the lift into the bottom of the shaft.
  3. Crash the lift into the top of the shaft.
  4. Run the simulation too slowly. Even if the code is logically correct, the lift crashes into the end of the shaft before the program has time to switch off the motor.

Hardware Timer
INT 02 		How to Use
The hardware timer generates INT 02 at regular time intervals. The time interval can be changed using the Configuration tab as shown in the image. The CPU will ignore INT 02 unless the (I) flag in the status register (SR) is set. Use STI to set the (I) flag. Use CLI to clear the (I) flag.

The code sample below processes INT 02 but does nothing useful.

If the CPU clock is too slow, a new INT 02 can occur before the previous one has been handled. This is not necessarily a problem as long as the CPU eventually catches up. To allow this to work, it is essential that the interrupt handler saves and restores any registers it uses. Use PUSH and PUSF to save registers. Use POPF and POP to restore registers. Remember to pop items in the reverse order that they were pushed. Code like this is "re-entrant".

If the CPU is too slow and does not catch up, the stack will gradually grow and eat up all the available RAM. Eventually the stack will overwrite the program causing a crash. It is a useful learning exercise to slow the CPU clock and watch this happen.
    jmp	start
    db	10	; Hardware Timer Interrupt Vector

; ===== Hardware Timer =======
    org	10
    nop		; Do something useful here
    nop
    nop
    nop
    nop
    iret
; ============================

; ===== Idle Loop ============
start:
    STI		; Set (I) flag
idle:
    nop		; Do something useful here
    nop
    nop
    nop
    nop
    jmp	idle
; ============================
    end
; ============================

Numeric Keypad
Port 08
INT 04 		How to Use
This is one of the more complex devices. To make the numeric keypad visible, use OUT 08. Every time a key is pressed, a hardware interrupt, INT 04 is generated. By default, the CPU will ignore this interrupt. To process the interrupt, at the start of the program, use the STI command to set the interrupt flag (I) in the CPU status register (SR). Place an interrupt vector at RAM address 04. This should point to your interrupt handler code. The interrupt handler should use IN 08 to read the key press into the AL register.

Once STI has set the (I) flag in the status register (SR), interrupts from the hardware timer will also be generated. These must be processed too. The hardware timer generates INT 02. To process this interrupt, place an interrupt vector at RAM location 02. This should point to the timer interrupt handler code. The timer code can be as simple as IRET. This will cause an interrupt return without doing any other processing.
    jmp	start
    db	10	; Hardware Timer Interrupt Vector
    db	00	; Keyboard Interrupt Vector (unused)
    db	20	; Numeric Keypad Interrupt Vector

; ===== Hardware Timer =======
    org	10
    nop		; Do something useful here
    nop
    nop
    nop
    nop
    iret
; ============================

; ===== Keyboard Handler =====
    org	20
    CLI		; Prevent re-entrant use
    push	al
    pushf

    in	08
    nop		; Process the key press here
    nop
    nop
    nop
    nop

    popf
    pop	al
    STI
    iret
; ============================

; ===== Idle Loop ============
start:
    STI		; Set (I) flag
    out	08	; Make keypad visible
idle:
    nop		; Do something useful here
    nop
    nop
    nop
    nop
    jmp	idle
; ============================
    end
; ============================