microcontrollers

Flags and Decision Making

As described in Chapter 6, the Z80 architecture includes six flags, which are flip-flops that are set or reset after the execution of arithmetic and logic operations, with some exceptions. Four of the flags (S, Z, P/V, and CY) can be used by the programmer for decision making in conjunction with Jump and Call instructions; the remaining two (H, N) are used internally by the microprocessor for BCD arith­metic. The thorough understanding of flags is critical to writing assembly language programs.

In many ways the flags are like signs on an interstate highway that help drivers in decision making. A driver sees one or more signs at a time, but contin­ues along the highway ignoring the signs until the appropriate sign is found, and then he or she changes direction or takes an exit. Flags function similarly as signs of data conditions. After an operation, one or more flags are set (or reset) and can be used to change the direction of program sequence by using Jump instructions (discussed in the next section). The following illustrations from Example may clarify some of the critical issues.

1. In Example, Instruction 5 sets the Sign flag and resets the other flags. However, the Sign flag can be ignored because the numbers loaded into reg­isters are unsigned numbers. The Sign flag is relevant when the programmer is dealing with signed numbers.

2. Instruction 7 sets the Carry flag and resets the other flags. If the programmer is adding numbers and is interested in finding the total, the Carry flag must be used to test for a sum larger than an 8-bit number.

3. Another important observation that can be made after the execution of Instruc­tion 7 is that the flags set by Instruction 5 are altered by Instruction 7. Thus, if the programmer is interested in making a decision based on the Sign flag, it should be made before that flag is altered by another operation.

Signed Numbers and Flags

The microprocessor is incapable of understanding a + or – sign unless the sign is represented in the form of binary digits. Therefore, in 8-bit microprocessors, bit D₇ is reserved for the sign by the user when signed numbers are used in arith­metic operations. For a positive number, bit D₇ is 0, and for a negative number, D₇ is set to 1; the remaining seven bits represent the magnitude of a number. If a number is negative, it is represented in 2’s complement. In an 8-bit microprocessor, the largest positive number is 0111 1111 (7F_H = + 127₁₀), and the largest negative number is 1000 0000 (80_H = -128₁₀).

The Z80 microprocessor has two flags to indicate the status of the arithmetic results in signed numbers: Sign and Overflow. After an arithmetic (or logical) operation, if bit D7 = 1, the Sign flag is set, and if D7 = 0, the Sign flag is reset. However, this flag can be misleading when the result of an addition exceeds the magnitude 7F_H or that of the subtraction exceeds 80_H. These conditions are known as overflow and are indicated by the P/V flag.

The P/V flag is a dual-purpose flag; in logical operations it indicates parity, and in arithmetic operations it indicates an over flow. In arithmetic operations, if the sum of two positive numbers exceeds 7F, bit D₇ becomes 1, indicating a neg­ative number. However, the Z80 sets the P/V flag to indicate the error in the result. The critical point to remember is that the Z80 does not know whether the numbers are signed, unsigned, or just individual digits. The interpretation of the flags is the responsibility of the user.

Example

Add two signed numbers: + 29_H and + 76_H. Indicate the status of the flags S, P/V, and CY if the operation is performed by the Z80 microprocessor. Explain how. The flags are affected if the numbers are unsigned.

Solution

CY = 0 because the sum does not exceed FF_H,

S = 1 because D₇ = 1, and

P/V =1 because the sum exceeds 7F_H.

In this addition of two positive numbers, the sign flag erroneously indicates that the sum is negative; however, the overflow flag (P/V) suggests that the result has an overflow from bit D₆ and that the result is therefore inaccurate. The user must check the P/V flag and correct the sum.

If these numbers were unsigned numbers, the interpretation of the result would therefore be different; the user should ignore the S and P/V flags and check for the CY flag. In this example, the sum is 9F_H with no carry.

­Another common misunderstanding is that bit D₀ in the result 9F_H is 1; therefore, bit D₀ in the flag register must be 1, thus setting the CY flag. There is no relationship between bit D₀ of a result and bit D₀ of the flag register.

ARITHMETIC OPERATIONS

The Z80 microprocessor performs various arithmetic operations such as addition, subtraction, increment/decrement, and I’s and 2’s complement. Most of these op­erations are concerned, with 8-bit operands. The instruction set also includes some 16-bit operations that will be discussed in later chapters. (See Appendix A for a complete alphabetical listing of the Z80 instruction set and how flags are affected by the instructions.)

Addition and Subtraction

The addition and subtraction operations are performed in relation to contents of the accumulator. We focus here on three types of operands: register contents, 8-bit data, and memory contents.

General Characteristics

These arithmetic instructions:

1. Assume that the accumulator is one of the operands.

2. Modify all the flags according to the result of the operation.

3. Place the result in the accumulator.

4. Do not affect the contents of the operand register or memory.

Increment/Decrement Instructions

The following instructions are special types of arithmetic instructions; they incre­ment or decrement the contents of the operand by one. These instructions are generally used in counting and indexing.

General Characteristics

1. In these instructions, the operand can be any of the 8-bit registers r, memory, or register pairs rp. The result is stored back into the same operand register.

2. The instructions dealing with 8-bit registers affect all the flags except the Carry (CY) flag.

3. The instructions dealing with register pairs do not affect any flags. This is im­portant to remember when a register pair is used as a 16-bit counter.

I’s and 2’s Complement Instructions

The Z80 instruction set includes the following instructions that perform comple­ment operations with the contents of the accumulator. The addressing mode is implied; the accumulator is implied as the operand.

Example

Load two unsigned numbers F2_H and 68_H in registers B and C, respectively, and store A2_H in memory location 2065_H, using the HL register as a memory pointer. Subtract 68_H from F2_H complement the result, and add A2_H from memory. Store the final answer in memory location 2066_H. Show register contents and the status of S (Sign), Z (Zero), and CY (Carry) flags as each instruction is being executed.

Description

l. The first instruction loads register BC with the given bytes. This could be achieved by using two separate load instructions for each register, but loading a register Pair is slightly more efficient

2. The second instruction sets up HL as a memory pointer for location 2065_H, and the third instruction loads A2_H into the memory location indicated by HL.

3. To subtract C from B, it is necessary to copy the contents of B into the accu­mulator (instruction 4).

4. Instruction I through 4 are all data copy instructions; they do not affect flags. All the flags will remain in their initial conditions before the program is executed.

5. Instruction 5 performs the subtraction in 2’s complement and places 8A_H in the accumulator as shown below. The subtraction method using 2’s Comple­ment involves three steps: (1) Find 2’s complement of the subtrahend, (2) Add the 2’s complement to the minuend, and (3) Complement CY. (Refer to Appen­dix B if you are unfamiliar with the technique.)

The result of this subtraction sets the Sign flag and resets the Zero and Carry flags. However, the result is not a negative number. After an arithmetic oper­ation, if bit D₇ = 1, the Sign flag is set. In this subtraction, the Sign flag should be ignored because data bytes are not signed numbers

6. The instruction CPL inverts the contents of the accumulator 8A_H; the result is 75_H. This instruction does not affect any flags, so the flags set by the previous instruction are preserved.

1 0 0 0 1 0 1 0 (8A_H) → 0 1 1 1 0 1 0 1 (75_H)

7. Instruction 7 adds A2_H from the memory location pointed to by HL to the accumulator contents (75_H). The result is 117_H. The instruction places 17_H into the accumulator, sets the CY flag. and resets the S and Z flags.

8. Instruction 8 increments HL to point to the next location 2066_H, and the next instruction stores the result in the memory location 2066_H.

9. The HALT is a machine control instruction; it does not affect any registers or the flags. The final result is shown in the box.

Data Copy Between Accumulator and I/Os

In the Z80 instruction set, input and output devices are identified by 8-bit addresses, The set includes several instructions that can read data from an in put device (also known as input port) and write data into an output device (or output port). Two of these I/O instructions are described here:

General Characteristics

I. These I/O instructions do not affect flags. (Some Z80 l/O instructions do affect flags; they are discussed later.)

2. The I/O instructions have 8-bit operands; thus, the Z80 is capable of addressing 256 input and 256 output ports with addresses from 00 to FF_H.

3. The 8-bit I/O addresses are enclosed in parentheses similar to those of memory addresses.

Example

Read the switches connected to the input port 01_H . Display the read­ing at the LED output port 07_H and store it in memory location 2060_H.

Solution

Instructions are as follows:

Description

1. shows that the switch positions of the input port 01_H provide the reading 0 1 0 0 1111 (4F_H). The first instruction reads the switch positions and places the reading in the accumulator.

2. The OUT instruction sends the accumulator contents to the output port 07" and displays the corresponding LEDs

3. The last instruction stores the accumulator contents in memory location 2060_H.

DATA COPY (LOAD) OPERATIONS

In this section, we focus on three types of data copy operations: data copy related to microprocessor registers, memory, and I/Os. Instructions frequently used are illustrated below, and the Z80 block transfer instruction will be discussed later in the chapter. In addition, one machine control instructionــــHALTــــis introduced; this instruction is necessary to indicate the end of a program.

Data Copy (Load) Among Registers

In this group, we have three types of instructions: data copy from one register to another, loading 8-bit data into a register, and loading 16-bit data into a register pair.

General Characteristics

1. Copy (Load) instructions do not affect flags.

2. The operands of copy instructions specify a destination register first, followed by a source register; they are separated by a comma.

3. The data byte is copied without modifying the contents of a source register.

4. A 16-bit operand is stored in two consecutive memory locations in the reversed order: the low-order byte first, followed by the high-order byte.

5. The instructions related to the index registers IX and IY have two-byte Opcodes.

6. Data cannot be loaded directly into the flag register, program counter (PC), and alternate registers: the immediate addressing mode is not available for these registers.

Description

1. The first instruction LD A, 97_H is a 2-byte instruction; the opcode 3E_H and the operand 97_H are stored in the first two memory locations. This instruction loads: 97_H into the accumulator .

2. The second instruction is a 3-byte instruction that loads 16-bit data (2050_H) into the HL registers. The low-order byte (50_H) is stored first in memory location 2003_H, followed by the high-order byte (20_H).

3. The third instruction (IX, 2075H) is a 4-byte instruction; it has a 2- byte opcode (DD and 21). This instruction loads 16-bit data (2075_H) into the index register IX.

4. The remaining two instructions are 1-byte instructions; they copy data from one register to another as shown .It is important to note that the copy operations do not destroy the contents of the source registers. Fig­ure 8.1 shows that registers A and H retain their contents after the copy operations.

5. The last instruction (HALT) is a machine control instruction; it forces the machine into the Wait state

Introduction to Z80 Instructions and Programming Techniques

When a microcomputer is asked to execute a program stored in its memory, it reads one in­struction at a time and performs the task spec­ified by the instruction. Each instruction in the program is a command, in binary, to the micro­processor to perform an operation. In Chap­ter 6, we examined briefly the Z80 instruction set and its capability. In this chapter, we will introduce a few selected instructions and illus­trate them with examples. These instructions are selected from three groups: data copy, arith­metic, and branch operations.

A computer is at its best, relative to hu­man capability, when it is asked to repeat such. Simple tasks as adding or copying. The programming techniquesــــ such as looping, index­ing, and countingــــ necessary to perform such tasks are introduced and illustrated with two programs. This chapter also includes a brief dis­cussion of debugging programs.

Finally, a group of special Z80 instructions that perform multiple tasks are introduced with illustrative examples.

OBJECTIVES

· Explain the functions of data copy instruc­tions and how the contents of the source register and the destination registers are affected.

· List four types of data copy operations and explain the term addressing mode.

· Explain how a memory address is specified to copy data from and to a memory register.

· Explain how data are transferred from and to I/O devices.

· Explain the functions of arithmetic instruc­tions (ADD, SUB, INC, DEC) and how flags are affected by these instructions.

· Write a set of commands using data copy and arithmetic instructions to perform a given task.

· Explain the functions of unconditional and conditional jump instructions and how they are used for decision making.

· Draw a flowchart of a conditional loop to il­lustrate the indexing and counting tech­niques.

· List the seven blocks of a generalized flow­chart illustrating data acquisitions and data processing.

· Write a program to copy data from one block of memory to another block including the case of overlapping blocks.

· Write a program to perform arithmetic oper­ations on given data stored in memory.

· List the types of errors that frequently occur in writing assembly language programs and in hand assembling the code. Recognize the er­rors in a given program.

· List Z80 special instructions and explain how they provide more flexibility and improve ef­ficiency in writing Z80 programs.

· Modify the previously written programs us­ing the Z80 special instructions.