Homebrew Z80 Computer

[Alberto]

Hey all,

So for the last few weeks I have been constructing a home brew Z80 Computer from my own schematic (kind of a mash up of two schematics online that did what I wanted!). The build has 32K of ROM and 32K of RAM, with a simple 2 in 1, 2 in 4 out decoder for both the IO and memory, although at the moment the IO side is not fully connected up as I am going to use a serial interface with my Windows PC instead. I got the wiring for the serial side from Grant Searle's website where he uses the 6850 ACIA to communicate with a pc using a serial terminal. My problem is, his systems use 8K of ROM not 32K. In the Memory Map it says that ROM goes from hex address 0000 - 1FFF and RAM goes from 2000 - FFFF. Do I need to change something in the ROM hex file he provides to tell the processor that RAM actually starts at 8001?

This is the first computer I have ever hand wired so this is a learning process for me, it seems logical to me that there should be some sort of memory map stored somewhere in memory, else how does the system know where is it looking?

My only other idea is that ROM must always start at address 0000 if it is housing the main code, so that the interpreter or operating system is immediately booted.

Thanks for any help in advance!

Alberto

[Codex]

Z80 reset vector is 0000.  So you always need your start code there. 

CP/M systems including Grant's CP/M designs will boot from ROM at 0000, load some code into RAM like at D000 then disable the ROM and enable RAM in the same address space.  This allows the full 64K of address space for RAM.

Grants code does have RAM allocations at those lower address, so yes you do have to move them if you RAM starts at 8000.  It easy to do, I have done with grants code.  Only need to change a few things. He provides the source code for this reason.

>>.. . be some sort of memory map stored somewhere in memory. . .
There is no map of memory stored, it does not work that way.  You really need to read a book on Z80 architecture and understand it, Rod Zaks Programming the Z80 or something like this.   You need to read the code to work out how it works and where stuff is stored, the hardware is only half of it.   Its actually easy to read when you get the hang of it.

  Have fun, I been playing with z80s since the 80s, and have ported Grants code to a few of the Z80 systems I own and build.

[Codex]

Looks like Grant actually has a 32K with RAM starting at 8000.

QUOTE from his site:
Memory Map
0000-1FFF   8K ROM
8000-FFFF   RAM (32K) <== Modified for 32K RAM

[Alberto]

Thanks for the advice, it makes sense that you would have to start the code at 0000, easiest way to do it! I will take a look at that book, I think I came across it before but that was when I was putting together the hardware, so it didn't seem as helpful at the time.

The build has been really fun so far, I enjoyed wiring it all up and it's been a great experience learning how it all works. It's greatly expanded my knowledge already and continues to do so! As I said it's the first computer I have put together completely from scratch, so I'm encountering all of this for the first time. The Z80 seemed like a good choice because it's widely accepted as one of the simplest processors to use. I can't wait to get it running, I just want to run some code and probe it to see what's going on!

Thanks for the help, it's very much appreciated!

[tggzzz]

I got the wiring for the serial side from Grant Searle's website where he uses the 6850 ACIA to communicate with a pc using a serial terminal.

There can be subtle nasty timing problems when using 68* peripherals on Z80 busses. I can't remember the details since I last looked at them in ~1983, but hold times are probably involved.

[ali6x944]

man see this:
http://z80.info/

[Alberto]

man see this:
http://z80.info/

Discovered that site whilst I was putting together the hardware! It's awesome someone would take the time to put together that amount of information. Maybe it's just me being dumb, but I couldn't seem to find so much about programming on there! It's hard to see what your looking for when you don't know what it looks like :S

There can be subtle nasty timing problems when using 68* peripherals on Z80 busses. I can't remember the details since I last looked at them in ~1983, but hold times are probably involved.

This is the sort of thing I hope to discover when tinkering with the system, I'm only 17 at the moment (currently studying A Level's including Systems and Control, which is kind of like a mixture of electronics and mechanisms) and only really got into electronics about a year and a bit ago. The more I can learn the better! Is it something to do with the Z80 sending information when it's not requested or vica versa?

[tggzzz]

There can be subtle nasty timing problems when using 68* peripherals on Z80 busses. I can't remember the details since I last looked at them in ~1983, but hold times are probably involved.

This is the sort of thing I hope to discover when tinkering with the system, I'm only 17 at the moment (currently studying A Level's including Systems and Control, which is kind of like a mixture of electronics and mechanisms) and only really got into electronics about a year and a bit ago. The more I can learn the better! Is it something to do with the Z80 sending information when it's not requested or vica versa?

That's a good age to start with this sort of thing, and a good choice of project. You will stretch yourself, make many mistakes, and learn a lot.

When it comes to university applications, CVs and job interviews, you will be able to demonstrate that you like this subject so much that you do "more than the minimum necessary" - that puts you ahead of 95% of people. Don't hide your mistakes, but use them as a way of demonstrating that you are always looking out for better ways to do things in the future - learning from your experience is a valuable attribute. You'll also have something to talk to the interviewers about - and sometimes it is good to find anything a candidate can talk about!

As to your last question, the problem isn't about info not requested, but is about the odd few ns here and there. As I say, I can't remember the detailed problem. You'll have to look at the timing details in the data sheets.

Very briefly, with digital logic typically:

• inputs expect the data to be stable before and after an edge - the setup and hold times which will be defined in the datasheet
• outputs are only stable a certain time after an edge - the maximum and minimum propagation times, which will be defined in the data sheet

Problems arise if the max propagation time plus setup time is shorter than the time between edges. Problems arise when the minimum propagation time is less than the hold time. Normally all devices from a single "family" (e,g, Z80 or 68*) are designed with a "similar internal structure", and will fit together just nicely. OTOH, different families have different "philosophies" and that can be the source of problems like this.

The best way is to draw on paper the timing diagrams for the key signals (typically a clock, then data, r/w, cs and similar). Start at the "master" device (the processor in this case), include all the logic between the processor and end at the "slave" device (ACIA). Show the minimum propagation delay, the maximum propagation delay and realise the signals can change anywhere between the two. If you think about it, the more devices in the chain, the wider that "gap" will become. Then look at the signals when the reach the ACIA, and see whether the setup and hold times are violated; if they are then you may have more or less frequent failures.

Later on you will use simulators for much more complex circuits, but starting by doing it "the hard way" has three benefits: you won't have to fight the simulator (yet!), you'll understand what the simulator is doing (later on), and you will have learned where problems are more (and less) likely to lie.

When it comes to building something, make sure you have good solid short ground connections between all the ICs (preferably a ground plane) and that you have a decoupling capacitor next to each IC with the shortest possible leads. Failure to do that has lead to many sleepless nights and disappointments!

[ali6x944]

man i have the same problem but with a NSC800N instead, plus  I'm a noob in these stuff man!
please help if u know any thing:
https://www.eevblog.com/forum/microcontrollers/help!-how-to-make-a-nsc800-computer/

[Alberto]

Awesome! I've looked at timing diagrams on datasheets before to see the order in which code in program's need to go, but I've never looked at it that in depth before. I shall get one drawn for the system! Understanding things more deeply seems to make troubleshooting a lot easier, I find the more I learn the more quickly I can get to the source of the problem with my projects.

With the propagation, setup and hold times. I understand what you are saying about when problems arise, but why do they arise with those particular timing issues. It seems counter intuitive that problems arise when the max propagation time + setup time is shorter than the time between edges, instead of longer (the same with minimum propagation time and hold time as well).

Also, I find it extremely confusing when selecting what values of capacitor to use. I have learnt about what capacitors do in physics but this does not get translated very well to the context of electronics in school. As I understand it they are there as a method of smoothing out the current and thus the voltage level's that are going into each chip. But how do you pick the correct value of capacitor?

 

[BloodyCactus]

this is an awesome reference;

Build your own z80 by Steve Ciarcia, this is freely available on the web, so its ok to link here.

https://www.modmypi.com/download/BuildYourOwnZ80.pdf

[Alberto]

Again I shall have to give that a read, a lot to go on!

I think I have seen that before as well, might be good for reference when I want to add stuff to my system later on!

[tggzzz]

With the propagation, setup and hold times. I understand what you are saying about when problems arise, but why do they arise with those particular timing issues. It seems counter intuitive that problems arise when the max propagation time + setup time is shorter than the time between edges, instead of longer (the same with minimum propagation time and hold time as well).

Yes, it is counterintuitive, for a very simple reason: it is wrong! My idiotic mistake has been caught by someone who thought and questioned what they did not understand.

With those attitudes, you will go far

Also, I find it extremely confusing when selecting what values of capacitor to use. I have learnt about what capacitors do in physics but this does not get translated very well to the context of electronics in school. As I understand it they are there as a method of smoothing out the current and thus the voltage level's that are going into each chip. But how do you pick the correct value of capacitor?

For this application it is not critical. You want a physically small capacitor to minimise its parasitic inductance, with a large value so it can supply lots of current for a short (ns) time.  Traditionally there is a 100nF decoupling capacitor for each IC plus a 100uF capacitor for the whole board where the power enters the board.

More important than the precise values is that you have a good ground plane. If a full ground plane is not possible, then approximate it by having a complete grid of ground connections from an IC to all of its neighbours.

[Codex]

As your using Grants design, the timing issues should not be an issue, if you just copying his Z80, 6850 circuit, you should be fine. 

In his CP/M design he used a Z80SIO, for UARTs, this is more common on Z80 designs, I always use either the Z80 SIO or DART, hence never have to bother with timing issues.

You could write a very small program, just a few lines of assembly, then assemble and link it. Look at the listing file and the BIN or HEX output file and see if you manually dissemble it; this is a good way to learn how the Z80 works.  Something simple, like load a value in the accumulator then out to a port, then loop forever.  Use a meter to check the bits arrive on the port.   

[Alberto]

I was thinking about writing some assembly and putting that straight into RAM to test the computer. However, I don't understand what you mean by assemble and link it. Is this when the assembly code is converted into binary and then put together into one long string?

[tggzzz]

I was thinking about writing some assembly and putting that straight into RAM to test the computer. However, I don't understand what you mean by assemble and link it. Is this when the assembly code is converted into binary and then put together into one long string?

Assembly yes.

It is usual to split source code (assembly or otherwise) into multiple files, for convenience and separation of orthogonal parts of the code. Each file is assembled (or compiled) individually, and then the resulting binaries are combined by the linker to form a complete downloadable image. In general file A will refer to functions/data in B, but cannot know where they are located in memory. The linker has all the necessary files and information, and can "link" all the references with the functions/data.

[Alberto]

Ok, makes sense. To test the code I write can I send it serially over the UART straight into RAM? I understand that the Z80 will boot the ROM first, in the case of my system it will launch into a basic IDE (at least I think thats how you refer to it...). Is there a command in basic that points the CPU towards a specific address in memory, telling it to start reading from there?

Probing the ports might be a bit more of an issue for me when it comes to high speed stuff, I plan to implement a way of switching between a manual clock and a crystal so I can clock the CPU manually to see it going through the motions. However I don't have access to an oscilloscope, at school or at home. So when it's running at its full 4Mhz I don't know how I will probe the ports. I have an FPGA (DE0 Nano Development Board) that I have been learning Verilog with. Is there any way I can rig up a simple usb oscilloscope from that. I understand the speed of FPGA's can be an issue and you need the analog capability. But the board has a DAC, so this could be used to take the analog input. Surely as well you could analyse the digital signals with the IO. It would be great to literally just have something text based that shows the current state of the outputs and can hold at any time. Possibly could do that with a Microcontroller?

Anyway enough of my rambling...

Edit: Thought it might be good to link in the videos I made about the build! There here >> https://www.youtube.com/user/TehMaxwell

[tggzzz]

I debugged my first computer with LEDs a multimeter and switches. It was a 6800 based with 128 bytes of RAM and 16bytes of ROM.

Some devices have a minimum clock speed. Switching between manual and crystal clock is possible,but you have to ensure there are no runt pulses. That is surprisingly subtle.

[Alberto]

The programming a Z80 book is awesome! Easy to read and it makes sense! Assembly seems like a very elegant language, hardware has always been more my thing and this makes a lot of sense. I like the ability to move things around in memory and load things into specific registers, I imagine that is very powerful if in the right hands. I've never encountered a low level language before, so this has taught me a great deal.

Once part I am still confused about. Say for example I have an assembly assembler flashed onto my Z80 ROM and a serial link to a PC that I have written assembly code on, how do I send the assembly code across to the assembler? Also how does the assembler then know how to store the program in RAM? From how I understand chapter 10 in Zak's book it seems that the assembler compiles the code into machine language and then runs it. Does the ROM have data on it that tells the CPU where RAM starts, so that it can throw the program into RAM from that address?

[tggzzz]

How do load a program into memory? Simple, you use a program that receives the program, stores it in memory, and then jumps to its first instruction. This is, of course, as easy as lifting yourself up off the ground by your boot straps.

Hence the concepts of "bootstrapping the computer" using "bootloader".

Traditionally the first level bootloader was entered one instruction at a time using front panel switches. Nowadays a bootloader is often stored in flash memory or other form of ROM. That is the technique used by the Arduino.

[Brumby]

Traditionally the first level bootloader was entered one instruction at a time using front panel switches.

I had that pleasure on a DEC PDP/8 many moons ago.

Ah, the memories....

[pyromaniac4382]

I see you have already gone through the NOP run of the CPU. Great start!

As for the above questions, what I think is the easiest way to accomplish what you want to do is to first write code in assembly on your PC and then use a program on your PC called an assembler to turn this into machine code which is the string of 0's and 1's that the Z80 actually understands. We represent this machine code first in assembly language and sometimes in its boiled down hex representation. The boiled down hex representation is the result of what people call hand-assembling where you go line by line in your assembly code and translate your code into hexadecimal values using a lookup table. this is very similar to what the program does on your PC.

You then take this file and "burn" it into a ROM starting at address $0000. Now each time you power up your machine it will run this code.

How you get this code onto the ROM chip is up to you, you can purchase a universal eeprom programmer and get a supported parallel ROM chip which is a sometimes expensive route depending on what you wanted to buy. You can take the cheaper more tedious route and put in each byte of the assembled code one by one into the ROM via a circuit you could rig up with switches on the data, address, and control lines which is where the idea of hand-assembling would be useful. Following the datasheet for the chip in question you can get away with writing the bytes you need into the addresses you want. You can also find a great many people online making their own custom eeprom burners using Arduinos and RaspberryPis and etc.

The code you will write and put in ROM is the real question though. I wouldn't start with an all-out assembler as this is quite a complex program for getting something off the ground. You may want to first stick to lighting an LED via an I/O port or something along those lines to validate that everything is exactly working as you expect it to. (basically what Codex was saying above.)

Next as tggzzz was saying, after validating that you have a way to get the code onto memory and that the Z80 is executing that code as you expect you can start to make a program called a boot loader. This can take many forms, but in your current line of thinking I believe that you could write a small assembly program to read the values coming in from the serial port on your PC via that 6850 you mentioned, and then store these values one by one in a place in RAM. Your boot loader program would need to jump to the start of this RAM location and run that program you just transferred. You would require writing code to handle the 6850's initialization and read/write functions as well as writing code to place the data read from the PC into a RAM location. This is probably the most ideal way to start to get your hands dirty in assembly as you will learn a lot about low-level hardware and software interaction. 

[Alberto]

All that stuff sounds interesting, I got a big DIP switch so that I can directly enter stuff straight into RAM, I thought it might be a cool idea to make a switchable setting so that you could change whether RAM or ROM was at memory address $0000, that way if you wanted to enter stuff straight into RAM you could.

The boot loader makes a lot of sense, I never thought about writing my own but that would be an awesome project to do once the computer was up and running! I plan to initially flash a ROM with Grant Searles Basic Assembler (I think that's what it is), so that I can see if everything is working properly and also play around with BASIC a bit. Which I have never done before!

In terms of an EPROM programmer I plan to use a design I found online using an arduino, as you mentioned (Here's a link >> http://www.ichbinzustaendig.de/dev/meeprommer-en) ! I think it needs modifying to the 27xx EPROM's that I am using, but this shouldn't be too difficult. The person who wrote it has written a java GUI to help with sending the files across, although I cannot get it to launch on my windows PC. There is also a command line written in python, again I can't get this too launch! I might try it on my Raspberry Pi to see if that helps!

My USB to Serial 5v TTL Cable arrived today, the driver installed correctly so when the 6850 chip arrives I will be ready to go. The video's you see are not actually up to date, as I have made a lot of progress since then! The computer is pretty much complete, I just need to make a few more connections and add in the required capacitors and then its ready to go! It's a bit of a wirey mess, but I just treat that as being a bit more authentic!

[C]

As others have stated
Timing is very important. A logic glitch can be very hard to find.
Next to this is load on output pins & getting good logic levels to input pins.
If you look at the NMOS Z80, you should see that the clock input pin is different for example.

When you try to use chips built for a different processor family you can have problems.
Look at a Z80 SIO for example, the system clock input and M1 input. A for a different cpu the timing will probably be different. In fact note that Zlog has a 4mhz SIO & a 6mhz SIO. Strong hint that a slower SIO will have problems doing everything properly connected where a faster SIO version is needed.
Next why do these pins exist?   
What other CPU's will look the same to a SIO?

The 6850 is a part for a different CPU line. Pin 14 the (E) signal is a signal from a 6800 0r 6809.
What all is this used for inside the chip?

When you use a chip outside it's specifications, you are entering the UNKNOWN on what will break, work or work part of the time.

Here is a simple test for your design
A good computer can send and receive data.
In the video you have parallel inputs and outputs on connectors

Can your Z80 computer say "HELLO" to a second copy of your Z80 computer as you have it now?
Connect the inputs of one computer to outputs of the other.
Note this is not the same as just connecting the outputs to the inputs on one computer. The second computer could be running at a different speed and/or doing other things.

[Alberto]

The whole chip family thing is something I never really considered before in terms of timing, the posts here have definitely taught me a lot about that! I may struggle to do that test as I don't have another built computer to link my original one up to :S. Also I don't currently have the parallel register chips wired up to the CPU. I decided that I would wire the data bus and any other necessary signals up to one of the horizontal headers, that way I could but in the Serial Communications chip, as well as have room for more expansion later on. Buffering both of those headers wouldn't have limited me as far as I can tell, but it seemed a bit unnecessary and I wanted to put the serial chip in as I liked the idea of communicating with another PC.

Really shooting right into the future here, but I thought I might ask about it anyway whilst it crossed my mind. Because I have an FPGA I wondered if it would be possible to replicate an early graphics processing chip for the Z80? Obviously as far as I know if you know what your doing and it fits in the number of gates your FPGA has then you can do anything, but has anyone actually done this before? I think the custom chip for the ZX spektrum has been done before, but are there any others?