The Accumulator is used during all our main calculations.
You will use it all the time when adding up (Accumulation).
A and F are combined in the stack operations - PUSH AF / POP AF will transfer the Accumulator and Flags as a 16 bit pair.

The Flags Register. Each bit defines a 'condition' we can test for.
We don't tend to use this directly, it's set by mathematical operations, and we respond to its contents via conditional jumps and calls.

The High Low pair.
This often stores memory locations, as there are a lot of special commands that use it to quickly read or write whatever memory locations.
It's also good at 16 bit maths, it's almost the Z80's 16 bit Accumulator, so if you want to add two numbers above 255, you'll probably need it.

These are often used as a Byte Count or loop counter.
Sometimes you'll use B and C together, for a count of up to 65535, or just B on its own for up to 255.

DE is often used as a Destination.
If you're reading from one place and writing to another, you'll probably use HL as the source, and DE as the destination.

Sometimes we want to get to memory by specifying a relative position. Index Registers allow us to do this.
For Wxample: If we have sprites, and each 4 bytes for X, Y, Width, Height. Just point IX to the start of the data for the sprite we want and read the rest out as IX+1, IX+2 etc. Don't worry about this, we'll explain it later.
IX is actually a pair of two registers called IXH and IXL. We can use them alone for whatever we want, but they are slower than other registers.

IY works the same as IX.
Note: IY is used by the operating system on the Spectrum and TI-83 calculator, so won't be available for your use on those systems.

This is the place in memory that the Z80 is running.
We don't change this directly, but the CALL, JP and RET commands all affect it.

This is the stack pointer.
It points to a big temporary store that we'll use for 'backing up' values we need to remember for a short while.

This is the Refresh register.
The system uses it to know when to refresh the memory, so don't change it, You could mess something up! But it can be used for getting simple 'random' numbers!
The R register goes from 0-127, the top bit is always 0.

This is the Interrupt vector register, it's only used by Interrupt Mode 2 (IM 2).
IM 1 is easier to work with than IM 2, so, on systems like the CPC and MSX, I is unused. This means you can use the I register as a 'temporary' store if you wish. On the Spectrum you may want to use IM 2, as IM 1 is not reprogrammable since the &0038 address IM 1 uses is read only ROM.

7

Sign

Positive / Negative

6

Zero

Zero Flag (0=zero)

5

4

Half Carry

Used by DAA

3

2

Parity / Overflow

Used for Overflow - if a sign changes because a register is too small
Also used as Parity for error checking for bit operations

1

Add / Subtract

Used by DAA

0

Carry

Carry / Borrow

Zero

Z Set

Non Zero

Z Clear

Carry

C Set

No Carry

C Clear

Parity Odd

P/V Clear

Parity Even

P/V Set

Positive Sign

S Clear

Minus Sign

S Set

RST0

Reset

RST1

RST2

RST3

RST4

RST5

RST6

RST7

IM1 Interrupt Handler

NMI

Non Maskable Interrupt

12

Immediate Decimal Value.

%10101010

Immediate Binary Value

# $

&FF

Immediate Hexadecimal Value

'A'

Immediate ASCII Value

-1000

Memory Address in Decimal

(#) ($)

(&1000)

Memory Address in Hexadecimal

Let's imagine we have 32 bits to store, this will take four bytes of RAM. But in what order should these four bytes be stored? It may be surprising to hear that there are two options.

'Big Endian' stores the highest byte first and the lowest byte last.
'Little Endian' stores the smallest byte first, and the largest byte last.

It's not really up to us what 'Endian' to use, as our CPU will have its 'Endian' built into its memory addressing.

The Z80 is a Little Endian CPU

While the syntax varies depending on your assembler, comments in assembly usually start with a semicolon (;). They can be on a line on their own, or at the end of a line of code. After the semicolon, the assembler will ignore the rest of the line, so adding a semicolon to a line of code will quickly disable it.

These are totally optional, they make no difference to the resulting program, but you will probably find them essential to help make the function of the code you're writing clearer, as when you're debugging it in a few weeks, or trying to reuse part of your old code many months later, you'll benefit from having spent the extra time to add at least a few comments to your code.

These are known as "Registers"... they are our 'short term storage'. It's much faster than RAM because it's inside the CPU but we have very few registers, so we have to use the slower normal memory a lot.

The 8 bit  Z80 has a lot more registers than the 6502, They have names like A B C D E H and L... certain pairs can be used together to make a '16 bit pair'.

For example: 8 bit H and L can be combined to make 16 bit HL

A signed number is a number that can be positive or negative.

An Unsigned 8 bit number can go from 0 to 255 but a signed number can go from -128 to +127.

The way signed numbers work in assembly is odd, and exploits a 'quirk' of the way the processor registers work.

A byte value in an 8 bit register can only go from 0 to 255. If we add a large number to a byte (for example adding 255 to 128) the byte will 'Overflow' going over up to 255, and wrapping back to 0. Therefore adding 255 to an 8 bit register is the same as subtracting 1!

So 255 is effectively -1, 254 is effectively -2 and so on.

The processor doesn't 'know' whether the 255 in a byte is -1 or 255 and it doesn't need to. We use special Condition statements for signed and unsigned numbers, and we code according to whether our byte is signed or not.

Don't worry if that sounds odd, it will make more sense later!

Converting a positive to a negative is easy. In code we flip all the bits via an XOR / EOR or other special command (like CPL), and add one to the result with an INC or ADDQ (or equivalent). This is known as Two's Complement.

For Example: Let's look at converting 1 to -1. Our register starts with a decimal value 1. After the bits are flipped and one is added this will result in a decimal value of 255 ($01 converted to $FF in hexadecimal).

On our calculator we take the maximum value plus 1 (256 for a byte, 65536 for a word) and subtract the number we want to negate.

For Example:

Z Flag Was the result Zero?
V Flag Did the result go too high to store correctly (oVerflow)?
C flag Did a calculation transfer data out of a register (Carry)?

This is what the flags are for!

All these 'Flags' are stored in a special 8 bit register 'F'

For Example: If we do a compare like "CMP #0", the Z flag will be set if the accumulator is zero. The S flag will be set if the accumulator is negative. We can use these later with conditions to branch to different parts of our code.

The Z80 'F' Register contains 8 bits: %SZ-H-PNC .

The main ones you will need to know about are Carry (C) and Zero (Z). Sign (S) is also useful in some cases, but you'll probably never actually need to know about P/V, H and N.

On the Z80 many commands do not change the flags. You need to check if the command you're using actually updates them.

For Example: "DEC B" will correctly update the zero flag, "DEC BC" will not, so with "DEC BC" you'll need to manually check if B and C are zero. This can be done with "LD A,B OR C".