Z80 Machine Code and Assembly Language

This is a pure bucket list item for me - let's face it, why else would I be bothering with an 8-bit microprocessor that was released in the mid 1970s?.

I'm going to see if I can finally get the ZX Spectrum to do things that I could only dream of achieving when I was a kid. I tried so many times to master the skills but never got past the most basic of instructions. I just wanted to put graphics on the screen and move them pixel-by-pixel, but Machine Code books of the day always seemed to spend chapters and chapters telling you about the Spectrum architecture and why 1 + 1 =0.

This is not a tutorial - and it isn't in any strict order. You'll find bits, pieces and snippets dotted all over the place; however, top-down will generally follow my progress.

(This, however, is a tutorial - 'How To Write ZX Spectrum Games' - and a very good one at that. Reproduced here with the kind permission of Jonathan Cauldwell)

This is why I'm doing this

30 years ago, this would have looked like gobbledegook to me.

Now, however, I know exactly what it does - heck, I could even tell you why '232 128' = 33000.

And it's this eureeka that's prompted me to delve further.

The resources helping me through this are the books: 'Mastering Machine Code on the ZX Spectrum' by Toni Baker, and '40 Best Machine Code Routines for the ZX Spectrum' by A.Hardman and A.Hewson; and the online articles: ZX Spectrum Machine Code Game in 30 Minutes, by Jon Kingsman; and How to Write Spectrum Games, by Jonathan Cauldwell (the last two of which are currently available from the Chuntey blog.

Hexadecimal

Note to self: Hexadecimal is a very effective way of counting to 255 using only two digits. As the table below shows, you count from 0 to 9 in the usual way, and then use the letters A-F for the double-digit numbers: 10,11,12,13,14 and 15. Once you need to get to 16, a 1 is carried over to the left-hand column and the right starts from 0 again.

01 = 1
0D = 13
10 = 16
20 = 32
2A = 42

In short:

In decimal, 16 = 16. (1x10)+(6x1)=16
In hexadecimal, 16 = 22. (1x16)+(6x1)=22

The Spectrum Screen

I'm guessing that if you're actually reading this, then you'll know the way in which the Spectrum configures its screen, i.e. banded layers rather than sequential, and groups of pixels first, followed by the attributes.

Here are the addresses that matter:

16384 - the start of the screen addresses
6144 - number of pixel addresses
22527 - last pixel address

22528 - start of attribute addresses
768 - number of attribute addresses
23295 - last attribute address

And here they are in practice:

255 poked to 16384 and 22527 (see the solid line top-left and bottom right right)	255 poked to 22528 and 23295 (attribute square top-left and bottom-right)

The Registers (temporary variables, to you and me)

High-Byte, Low-Byte - eh?

Before I get too far, I need to get to grips with this high-byte, low-byte stuff.

If I understand it right, whenever a register pair hex number (or any big number) is stored in the Spectrum memory it's stored in reverse order. So if the following value is placed into the BC register pair...

LD BC,16386

...it takes up three bytes in memory. So say it was placed at address 33000, and we 'peek' the addresses 33000, 33001 and 33002, we should see 1,2 and 64 stored there.

Then (High-Byte x 256) + Low-Byte should give us the number we originally stored in the BC register (64x256)+2 = 16386.

Hex or Dec in Assembly - it matters

Note to self: in assembly language, 4000 = 4000 and 4000h = 16384. The 'h' means treat the number as hexadecimal.

Adding to registers

Apparently, you can only add to two of the registers: HL and A.

So - ADD A,## or ADD HL,##

Adding more than a register can handle

Single registers can only hold numbers from 0-255, and paired registers only numbers from 0-65535. In the following code, the Accumulator is initially loaded with the value 155 and then 200 is added to it...

Note: Whenever a Machine Code (herefater referred to as 'MC') program is run using PRINT USR #####, any value in the BC regsiter is printed to the screen when, and if, the MC returns to basic after coming to the command RET (201).

As 155 + 200 comes to 355, the Accumulator is unable to store it and it simply loops round from 255 and displays 99 as the result. It's 99 and not 100 (as might be expected) as 0-255 is actually 256 numbers, and 350-256=99. However, what it does do is set the Carry Flag to 1 ...and that's about to come in handy.

Table of Z80 Machine Code instructions - (filled in as I go)