microcontrollers

ASSIGNMNTS

1. How is the accumulator different from the 8-bit general-purpose registers of the Z80 microprocessor?

2. Explain the function of the alternate registers.

3. What is a flag, and what is its function?

4. If the Z80 adds 87_H and 79_H, specify the contents of the accumulator and the status of the S, Z, and CY flags.

5. If the Z80 is an 8-bit microprocessor, why are the program counter and the stack pointer 16-bit registers?

6. If the Z80 has fetched the machine code located at the memory location 205F_H, specify the contents of the program counter.

7. The index register IX holds the address 2058_H• Specify the value of the dis­placement byte needed to make the effective address 2097_H•

8. The index register IY holds the address 2070_H• Specify the value of the dis­placement byte in 2’s complement needed to make the effective address 2050_H•

9. List the six types of operations the Z80 performs.

10. Define opcode and operand, and specify the opcode and the operand in the instruction LD A, B.

11. Explain the instruction LD A, B. Specify the data source and destination.

12. If the instruction LD A, B is stored in memory location 2005_H, what are the contents of the memory register?

13. Explain the instruction SUB H. List the operand implicit in the instruction.

14. Write mnemonics to load F8_H into register C, and show the Hex codes with the memory address starting at 1800_H•

15. Write -logical steps to load the following three Hex numbers (2F, 47, and 7 A) into Z80 registers B, C, and D, respectively. Add the numbers, and save the / sum in register H. •

16. Translate the steps in the previous question into Z80 assembly language.

17. Redraw the flowchart in Figure 6.5 by interchanging the answers of the de­cision block. For example, the program sequence will be altered if the an­swer is "Yes." (Hint: The flowchart can have two End statements.)

Draw a flowchart to represent the following problem. Load two numbers into Z80 registers, and subtract the second number from the first number. If the result generates a borrow, display FF_H at the output port of the system; otherwise, display the second number.

SUMMARY

This chapter introduced the Z80 programming model and provided an overview of the Z80 instruction set and the capability of the Z80 microprocessor. The im­portant concepts and topics discussed in this chapter can be summarized as follows:

· The Z80 microprocessor has six general-purpose 8-bit registers (B, C, D, E, H, and L) as a primary set. In addition, it includes the alternate set of these registers, all of which can be used to exchange information with the primary set. The registers Band C, D and E, and Hand L can be combined to perform some l6-bit operations.

· The ALU section of the Z80 includes accumulator A and the flag register to indicate six different data conditions. It also includes the alternate accumula­tor A’ and flag register F’, which can be used to exchange information with A and F, respectively.

· Four flags-Sign, Zero, Carry, and Parity/Overflow-can be used for decision making and tested in connection with Jump, Call, and Return instructions. Two flags-Half-Carry.and Add/Subtract-are used internally for BCD opera­tions and are unavailable for the programmer.

· The Z80 has four 16-bit registers-IX, IY, SP, and PC-used as memory pointers. Two index registers-IX and IY-can be used to point to memory location, and an address and the direction (backward or forward) can be specified with a displacement byte. The stack pointer (SP) is used to specify memory locations in a defined R/W memory segment called the stack. The program counter (PC) is used to sequence the program execution; it points to the next memory address from which the machine code is to be fetched.

· The Z80 includes two 8-bit special-purpose registers: Interrupt Vector (I) and Memory Refresh (R). The I register provides the high-order 8 bits of a 16-bit address to which the program is to be directed after an interrupt. The R regis­ter is a 7-bit counter and supplies an address for refreshing memory cells of a dynamic memory.

· The Z80 microprocessor operations are classified into six major groups: data copy (load), arithmetic, logic, bit manipulation, branch, and machine control.

· An instruction has two parts: opcode (operation to be performed) and oper­and (data to be operated on). The operand can be 8- or 16-bit data, an ad­dress, register, register pair, or it can be implicit.

· The method of specifying an operand is called the addressing mode.

· The instruction set is classified into four groups according to the word size: 1-, 2-, 3-, and 4-byte instructions.

· To write a simple assembly language program, the problem should be divided into small steps in terms of microprocessor operations, and these steps should be translated into Z80 mnemonics. Then, the Hex code is assembled by look­ing up the code in the instruction list; this is called either hand or manual assembly.

· To enter a program into the memory of a single-board microcomputer, Hex keys are used to enter the code, which is converted into binary code by the Key Monitor program of the system and stored in R/W memory. This binary code can then be read and executed by the microprocessor.

Most instructions are compatible with the 8080 instruction set, with a few exceptions. Notations used in the description of the instructions include

6.6 LIST OF SELECTED Z80 INSTRUCTIONS

The Z80 instruction set includes 158 instructions resulting in 694 machine codes. The following list is a representative sample of each group described in Section "’6.2. The purpose of the list is to show you the overall capability of the Z80 and some logical patterns in its instruction. You should not study these instructions in detail; instead, you should search for logical patterns. Once you recognize log­ical patterns, you will be able to recognize the function of an instruction even if you have not seen it before.

6. 5 ADDRESSING MODES

The addressing mode is a way of specifying an operand or pointing to a data location. The Z80 microprocessor has ten addressing modes, as shown in Table 6.1. The first three are explained here as illustrations, and the others will be explained in later chapters.

In Section 6.2.2, we listed various categories of data copy operations. Data can be loaded directly into registers (or memory), or they can be copied from registers and memory, including I/O ports. Here are the addressing modes of these data copy operations.

At this point, you are unfamiliar with the instruction types; therefore, you should avoid the details of the addressing modes given in Table 6.1. As we begin to use various instructions in following chapters, we will discuss the appropriate addressing modes. As you become more familiar with the instruction set, you will be able to choose an appropriate addressing mode for a given task.

6.4 FLOWCHARTING

A flowchart is a graphic representation of the logic and sequence of tasks to be performed. A flowchart should assist in clarifying one’s thinking process and communicate the programmer’s approach and logic in writing the program.

Flowcharting is an art; how much detail it should include requires a subjec­tive decision. At one level, the flowchart includes only the functions to be per­formed without any reference to a particular microprocessor; at another level, the functions of registers being used are specified in detail. However, it should not duplicate the instructions in the program in a graphic format; this would defeat the whole purpose of drawing the flowchart. It should simply represent a logical approach and sequence of steps in solving the problem.

The six symbols commonly used in flowcharting are shown in Figure 6.7. We have already used three symbols in Figure 6.5. The fourth symbol, shown by the diamond shape, represents the decision-making block. It is used when data conditions need to be checked and the program sequence has to be altered. This symbol is i1lustrated in Figure 6.8. The fifth symbol, a double-sided rectangle, represents a predetermined process such as a subroutine (discussed in Chapter 10). The last symbol, a circle with an arrow, is used to show continuation of the flowchart to a different column or to a different page.

Example 6.2

Draw a flowchart to represent the following problem. Load two Hex bytes into Z80 registers, and add the bytes. If the sum is larger than 8 bits, display O/H as the overload condition at port PORT7; otherwise, display the sum at the output port.

The problem can be divided into the following steps.

1. Load bytes into Z80 registers.

2. Add the bytes. .

3. Check the sum.

4. If the sum> FF_H, display 01_H at the output port.

5. If the sum < FF_H, display the sum at the output port.

The steps listed in Example 6.2 and the sequence can be represented by the flowchart shown in Figure 6.8. The first two blocks can be easily understood. The third block, shown by the diamond shape, is a decision-making block. In this block the result is checked by examining the CY flag, and the program execution is altered accordingly. If the CY flag is set, the result is larger than FF_H and the program execution goes to the next block. It loads 01 H and displays it at the output port. If the answer to the question in the decision block is "No," the sum is less than FF. The program sequence is then altered; it bypasses Block 4 and displays the sum at the output port.

An interesting question is: Can we interchange the answers "Yes" and "No" at the decision-making block? That is, can the program sequence be changed if CY is set? This is given as a problem at the end of the chapter: you may find that the resulting flowchart will have two end points.

6.3 HOW TO WRITE, ASSEMBLE, AND EXECUTE A SIMPLE ASSEMBLY LANGUAGE PROGRAM

An assembly language program is a sequence of instructions written in mnemon­ics to perform a specific task. These instructions are selected from the instruction set of the microprocessor being used. To write a program, we need to divide a given problem into small steps and translate these steps into the operations the Z80 can perform. For example, the Z80 does not have an instruction that can multiply two’ binary numbers, but it can add. Therefore, the multiplication prob­lem can be written as a series of additions.

After writing the instructions in mnemonics, you should translate them in to binary machine code; this process of translation is called assembling the code Quite often, this process involves intermediate steps, such as translating mnemonics into Hex code and then into binary code. The code assembly can be done manually, as described in this chapter, or using an assembler (a program that translates mnemonics into machine code), as described In the next chapter.

To execute a program, the binary code should be entered and stored in the R/W memory of a microcomputer so that the microprocessor can read and execute the binary instructions written in memory. In a single-board microcomputer the instructions are, generally, entered using a Hex keyboard. This is one of the rea­sons why we translate mnemonics into Hex code as an intermediate step rather than into binary code directly. When the Hex code is entered, the keyboard pro­gram, residing in the microcomputer system, translates the Hex code into binary code. The steps required to write, assemble, and execute a program are illustrated in the next section.

6.3.1 illustrative Program: Adding Two Hexadecimal Numbers PROBLEM STATEMENT

Write instructions to load the two hexadecimal numbers 32_H and A2_H into registers B and C, respectively. Add the numbers, and display the sum at the LED output port PORT 1.

PROBLEM ANALYSIS

Even though this is a simple problem, it is necessary to divide the problem into small steps in order to examine the process of writing programs. The wording of the problem provides sufficient clues for the necessary steps. They are as follows:

1. Load the numbers into the registers.

2. Add the numbers.

3. Display the sum at the output port PORT1.

FLOWCHART

The steps listed in the problem analysis anti the sequence can be represented in a block diagram, called a flowchart. Figure 6.5 shows such a flowchart representing those steps. This is a simple flowchart, and the steps are self-explanatory. We will discuss flowcharting in the next section.

ASSEMBLY LANGUAGE PROGRAM

To write an assembly language program, we need to translate the blocks shown in the flowchart into Z80 operations and then into mnemonics. By examining the blocks in Figure 6.5, we can classify them into three types of Z80 operations: Block1and 3 are copy operations, Block 2 is an arithmetic operation, and Block

4 is a machine control operation. The translation of each block into mnemonics with comments is shown below.

FROM ASSEMBLY LANGUAGE TO HEX CODE

To convert the mnemonics into Hex code, we need to look up the code in the Z80 instruction set; this is called either manual or hand assembly. The Hex code is as follows:

STORING IN MEMORY AND CONVERTING FROM HEX CODE TO BINARY CODE

To store the program in R/W memory of a single-board microcomputer and display the output, we need to know the memory addresses and the output port address. Let us assume that R/W memory ranges from 2000_H to 20FF_H, and the system has an LED output port with the address 01_H. To enter the program, the following steps are necessary:

1. Reset the system by pushing the RESET key.

2. Using Hex keys, enter the first memory address at which the program should be stored. Let us assume it is 2000_H.

3. Enter each machine code by pushing Hex keys. For example, to enter the first machine code push 0, 6, and STORE keys. (The STORE key may be labelled differently in different systems.) When you push the STORE key, the program will store the machine code in memory location 2000_H and upgrade the memory address to 2001_H•

4. Repeat Step 3 until the last machine code 76_H•

5. Reset the system.

Now the question is: How does the Hex code get converted into binary code? The answer lies with the Monitor program stored in the Read-Only Memory (or EPROM) of the microcomputer system. An important function of the Monitor program is to check the keys and convert Hex code into binary code. The entire process of manual assembly is shown in Figure 6.6.

In this illustrative example, the program will be stored in memory as shown:

This program has nine machine codes and will require nine memory loca­tions to store the program. The critical concept to be emphasized here is that the microprocessor can understand and execute only the binary instructions (or data); everything else (mnemonics, Hex code, comments) are for the convenience of those who write and use the assembly language programs.

EXECUTING THE PROGRAM

To execute the program, we need to tell the microprocessor where the program begins by entering the memory address 2000_H• Then, we can push the Execute key (or the key with a similar label) to begin the execution. As soon as the Execute function key is pushed, Z80 loads 2000_H into the program counter, and the pro­gram control is transferred from the Monitor program to our program.

The microprocessor begins to read one machine code at a time, and when it fetches the complete instruction, it executes that instruction. For example, it will fetch the machine codes stored in memory locations 2000_H and 2001_H and execute the instruction LD B, 32_H; thus, it loads 32H in register B as shown above in the last column of Register Contents. Next, it loads A2_H into register C and copies A2_H from register C into the accumulator A. It should be emphasized that the contents of register C are not changed in the copying process. When the ADD instruction is executed, the contents of A are changed to D4_H, which is the sum of 32_H and A2_H• It continues to execute instructions until it fetches the HALT instruction.

6.3.2 Program Documentation or Writing Format

Program documentation is an important aspect of writing programs. The docu­mentation should be able to communicate what the program does and the logic underlying the program, so that it can be debugged and modified if necessary. For our illustrative program, a writing format based on assembler files (discussed in the next chapter) is shown here.

This writing format has five columns: Memory Address, Hex Code, Label, Instruction (Opcode and Operand), and Comments. Each column is described below in the context of a single-board computer.

Memory Addresses These are 16-bit addresses of the system’s R/W memory in which the binary code of the user program is stored. In the illustration, we as­sumed that the R/W memory in our system begins at the address 2000_H, and we chose to store the program starting at the location 2000_H; we could have chosen any other available memory block to store our program.

Hex Codes These are the hexadecimal codes of the Z80 mnemonics we looked up in the instruction set; they were entered in memory using the Hex keyboard of the single-board microcomputer system. The key monitor program of the sys­tem translates these Hex codes and stores the binary equivalents in the proper memory locations.

Labels They are used to identify a memory location. The program has one label:

START. This label is used for documentation; it indicates the beginning of the program. The labels are used to identify memory locations and will be especially useful for Jump instructions when we use assemblers to write programs (discussed in the next chapter).

Instructions These are the Z80 mnemonics representing the microprocessor op­erations. Each instruction is divided into two parts: opcode and operand.

Comments The comments are written as a part of the proper documentation of a program to explain or elaborate the purpose of the instruction used. They thus play a critical role in the user’s understanding of the logic behind a program. Because the i1lustrative program is very simple, the comments shown are either redundant or trivial, but in general comments should not merely describe the meaning of mnemonics.

6.2 OVERVIEW: Z80 INSTRUCTION SET

The instruction set of a microprocessor determines the capability of its opera­tions, the power of its data manipulation, and the ease of programming it. Al­though it is necessary to have an overall view of the instruction set, our intent here is merely to acquaint you with the overall operations and capability of the Z80 microprocessor. As you progress through the chapters of Part II, you will be exposed to various instructions in more detail along with their applications.

The Z80 microprocessor has 158 instruction types; it includes all the instruc­tions of the Intel 8080 microprocessor and all but two of the 8085. As discussed in Chapter 1, each instruction has two parts: one is the task to be performed (such as Load, Add, and Jump), called the operation code (opcode); and the second identifies the data to be operated on, called the operand. First, we will examine various formats of these instructions in terms of number of bytes and then their classification according to their function.

6.2.1 Instruction Format

An instruction is a command to the microprocessor to perform a given task on specified data. The size of Z80 instructions ranges from one to four bytes; thus, the number of memory registers (locations) required to write (or store) them var­ies. For example, to write a 3-byte instruction into memory requires three mem­ory locations. Most opcodes (operation codes) are specified in one byte; however, some specialized opcodes require two bytes. The operand (or data) can be spec­ified in the following ways: 8-bit data, 16-bit data, registers, register pairs, I/O addresses, and memory addresses. The Z80 instruction set can be classified into four groups according to the length of an instruction: l-byte to 4-byte instructions. Because the Z80 is an 8-bit microprocessor, the terms "byte" and "word" are used synonymously.

1-BYTE INSTRUCTIONS

In a 1-byte instruction, the Opcode and the operand are included in the same byte as shown in the following examples.

In this instruction, the opcode LD is specified by the first two bits (01), and the operand registers A and B are specified by the remaining six bits. (The accu­mulator A is represented by 111 and register B by 000.) These bits are associated with the internal microoperations of the microprocessor and are not relevant for learning the instruction set.

2-BYTE INSTRUCTIONS

In a 2-byte instruction, the first byte specifies the opcode and the second byte specifies the operand (with exceptions of some Z80 two-opcode instructions).

3-BYTEINSTRUCTIONS

In a 3-byte instruction, the first byte specifies the opcode, and the following two bytes specify the 16-bit address or data in a reversed order: low-order byte followed by the high-order byte. For example:

4-BYTE INSTRUCTIONS

The descriptions given above for 2- and 3-byte instructions are valid for the in­structions compatible with the 8080 instructions. The Z80 instruction set, how­ever, includes numerous special-purpose instructions that are not compatible with the 8080 instruction set. An 8-bit microprocessor can have a maximum of 256 bit combinations; thus, its instruction set is limited to 256 operation codes. The 8080 has already used 242 combinations for its 72 different instructions, leaving only 14 combinations unused. However, the Z80 microprocessor needs many more combinations to use its additional registers (two index register alternate registers, interrupt vector, and refresh). This problem was resolved by designing 2­byte opcodes: unused opcodes combined with instruction opcodes.Z80 4-byte instructions are generally associated with index registers, as shown in the following example.

In this instruction, the opcode has two bytes, DD and 21. Now we can discuss various instructions according to their functional classification.

6.2.2 Z80 Instruction Set

The Z80 instruction set can be divided into six major categories as follows:

1. Data Copy (Transfer) or Load Operations

2. Arithmetic Operations

3. Logic Operations

4. Bit Manipulation

5. Branch Operations

6. Machine Control Operations

DATA COPY OR LOAD OPERATIONS

Copying data is one of the major functions the microprocessor needs to perform. The Z80 has numerous instructions that copy data from one location, called source, to another location, calIed destination, without modifying the contents of the source. In technical manuals, this function is quite often referred to as data transfer. However, since the term data transfer creates the impression that the contents of the source are destroyed, we prefer the term data copy. In this text, we have also used the terms Load, Read, and Write to describe data copy operations.

Figure 6.3 shows various categories of data copy operations. The Z80 has several instructions associated with each category, each of which, with its sub­divisions, is listed below with examples of instructions.

Data Copy Operations

1. From one register into another register

Copy the contents of register B into the accumulator.

LD, A, B; LD means Load

2. (a) Specific data byte into a register or a memory location.

Load registers B with the hexadecimal number 32. LD B, 32H

(b) Specific I6-bit data into a. regis­ter pair.

Load register pair HL with hexadeci­mal number 2050 . LD HL, 2050H

3. From a memory location into a reg­ister or vice versa.

Copy data from memory location 2080_H into the accumulator. LD A, (2080H)*

4. (a) From an input port into the accumulator.

Read data from input port 01_H and copy into the accumulator. IN A, (01H)*

(b) From the accumulator into an output port.

Write (send) the contents of the accu­mulator into port 07_H• OUT (07H), * A

5. From microprocessor registers into stack memory locations and vice versa.

Copy the contents of register pair BC into defined stack memory locations. PUSH BC

6. Exchange contents between regis­ters. (This is a slightly different op­eration from data copy; this is a data exchange.)

Exchange the contents of general pur­pose registers (BC, DE, HL) with alter­nate registers. EXX

General characteristics of these data copy instructions can be listed as follows:

1. In data copy operations, the contents of the source are copied into the desti­nation without affecting the contents of the source (except in Exchange instructions).

2. In an operand, the destination is specified first, followed by the source. For ex­ample, in the instruction LD A, B (copy the contents of B into A), the source is register B and the destination is the accumulator. This may appear backward be­cause the flow is generally assumed to be from left to right, the way we read text.

3. The memory and I/O addresses are enclosed in parentheses.

4. In some instructions, operand is implicit (for example, EXX).

5. Data copy instructions do not affect flags.

ARITHMETIC OPERATIONS

The Z80 instruction set includes four types of arithmetic operations:addition,subtraction,increment/decrement, and I’s and 2’s complement. In 8-bit arithmetic operations, the accumulator is generally assumed to be one of the operands (with the exception of increment/decrement instructions).

· Addition. Any 8-bit number, or the contents of a register, or the contents of a memory location can be added to the contents of the accumulator. The result of the addition is stored in the accumulator, and the flags are affected by the result No two other 8-bit registers can be added directly; for example, the contents of register B cannot be added directly to the contents of register C.

· Subtraction. Any 8-bit number, or the contents of a register, or the contents of a memory location can be subtracted from the contents of accumulator, the subtraction is performed in 2’s complement, and the result is stored in the accumulator. The result modifies the flags, and if the result is negative, it. is ex­pressed in 2’s complement. The following mnemonics indicate that the accu­mulator is implicitly assumed as one of the operands.

· Increment/Decrement. The 8-bit contents of a register (including the accumula­tor) or a memory location can be incremented or decremented by 1. Similarly, the l6-bit contents of a register pair (such as HL) can be incremented or decremented by 1. Unlike Add and Subtract, these operations can be performed in any of the registers. The instructions related to 8-bit contents affect flags (except Carry); on the other hand, instructions related to l6-bit contents do not affect any flags.

l’s and 2’s Complement. The contents of the accumulator can be complemented (I’s or 2’s complement), and the result is stored in the accumulator. Some flags are affected by the result. These instructions assume that the operand is the accumulator.