G80-S Runs Microsoft Basic 4.7b (sort of…)

As a followup to my post on interrupts, I decided to have a go at modifying Grant Searle’s I/O routines for his 7-chip z80 Computer. After quite a bit of work, I had the routines in his handler changed to conform with his code (at least I think), and function as intended (at least as far as I was able to test).

The next task was to try it with his modified version of the Nascom Rom.  And, after splicing the code, I compiled and tested…..and tested…..and tested…..

Well, the short of it is that it kind of works.  The video above says it all.  The serial routines seem to work fine up until BASIC starts up.  And at that point, my serial routines work fine, but there is some disconnect with Grant’s code that either doesn’t like my own code, or is simply amiss.

The video really does say it all.  If anyone has any ideas, or has ported Grants work over to using either the DART or SIO, I’d love to see your code.  Help a brother out… But seriously, watch the video.  It’s hilarious….

On the Subject or Intereupts

Although I have learned a lot by designing my own z80 computer, I have yet to learn much about interrupts. It’s just not something that I initially saw a strong need for.

However, since I have been looking at porting other people’s code over to my system I have come to realize just how important other people see interrupts to be. In fact, from what I can tell,  more often than not this is the case. At least with the code I have examined.

This means, that if I am to port some of the code I would like to use, I need to learn about interrupts.

The first thing of note is the hardware situation. On my first run of boards, what I’m calling the Beta Boards, the IEI line on the DART was left disconnected/floating. As it turns out, this is a no-no. This pin is the Interrupt Enable Input. Meaning it’s the enable on the SIO for interrupts. Without a High signal on this pin, there are no interrupts. So, I’ve fixed this issue on my new design by adding a resistor between IEI and VCC, and I’ve used a bodge resistor as a solution on my Beta Board.

The second thing to note is the different types of interrupt modes on the z80. There are three: Mode 0, Mode 1, and Mode 2. From what I can tell, Mode 1 is the most straight forward. In this Mode a low on INT will call the z80 to perform a RST 38H instruction. Which is essentially the same thing as a CALL 0038H. However, in order to return from this instruction the system requires a RETI instruction. So keep that in mind.

Mode 2 is interesting because it allows you to jump to a specific routine pointed to by a reset vector. In this Mode the upper 8-bits of the address is held in a register. And the lower 8-bits is placed onto the data bus by the peripheral. Trying to understand this Mode almost caused my head to explode. A little complex for our needs.

Mode 0, as I understand it, is a reset mode that is designed to be compatible with the 8080. Where in the peripherals place data on the data bus. I’m not going to presume to understand anything about this Mode.

So therefore we’ll be using IM 1 where polling is not usable. But wait, what if we need multiple devices? Well, luckily there is a way around this. Although I suppose it could be a little slow. When the z80 receives an interrupt the routine checks all the peripherals before deciding how to react. Good thing our system clock is at 6mhz. We may even need a little more speed. But in the end, if we have to, we can always use IM 2.

Here is an example of working code of Interrupt Mode 0.  I found interrupts a little difficult to understand at first.  But hopefully a very simple example of an interrupt routine will be enough to help the beginner.

IM 1 Example

G80-S Micro Schematic and Source

I’ve been meaning to upload the source and the schematic for the G80-S Micro for some time now.  I just haven’t gotten around to it.  However, I had some time to do so this evening.  So attached here is the schematic, and the source code.  It’s the v0.25b version of the software.  Use them well.

Also, a link to the Source has been placed on the product’s page in the store for the Beta boards.  So if you want to buy a board, you can download the software there.  If you don’t want to buy a board, but want to play with my design, the schematic is here and the source as well.  Have fun!

UPDATE: Roadrunner Author Lead

Great news. Evan from the VCF has emailed me concerning the possible identity of the individual responsible for the Roadrunner Monitor. His email was very brief, but I plan on following up with it.

I have contact information including an address and phone number. However, considering this would be a cold contact, I’ve elected to write the gentleman a letter to confirm his identity, and attempt to engage in conversation about the history of the code.

For the time being, all further details are on hold. However, once more information is obtained, I’ll be making another update. Until then, we will all have to wait in anticipation.

FYI, I think I’m just as excited about this as anyone!

Kaypro II ROM Dump – Surprise

This story just keeps developing.  I decided to restore the computer to it’s original state, since the modification appeared to be unfinished, and redundant.  I carefully pulled the ROM, very carefully bent the pin back into the place, and placed the rom into my programmer to preserve the code that was within.

Upon reading the code to memory, I was stunned.  I half way expected to see something along the lines of two separate versions of code.  However, what I saw was something entirely different.  What I saw was this:

This ROM was an aftermarket ROM developed by a gentleman by the name of Howard Saltzman, of Baltimore Maryland.  And was sold by Highland Microkit.  How cool!  But what was it?  I hadn’t the faintest idea.  So, I went to google…and came up empty handed.  Searching for “Howard Saltzman” and “Baltimore” didn’t return much.  And I spent a few hours trying different combinations.  That is until I searched for “Highland Microkit” and “Saltzman”.

I then came up with something odd.  A hit for a PDF file from a magazine called “Profiles.”  It was apparently a magazine geared towards the Kaypro in one way or another, but not excluding other computers entirely.  The particular magazine I found was this one here.  Or, if the link dies, you can download from Retro Depot here.  On Page 77 there is an add for a company called Highland Microkit, which advertises a rom called the “Roadrunner Custom Monitor”.  Well, sure enough if I scroll down to 0x01B0 it clearly identifies itself as the Roadrunner ROM v1.5.  But what does it do?  And why have I not seen this ROM listed on any websites which store backups of Kaypro images?

In either case, you can download the ROM Image right here.  It is saved as a text file, but it is actually a binary.  So you’ll need to rename it to “.bin”.  It’s the only way my server would allow it to upload, since it poses a “security risk” being a binary.

I’ve tried to track down Mr. Saltzman, and the closest I’ve come so far is that he attended an engineering college in Maryland, may have become a professor, and ultimately retired some time ago.  He is likely 61 years old from what I can gather on LinkedIn.  But I cannot find any contact information on him.  But if ANYONE knows who this man is, I’d LOVE to talk with him about this ROM.  Who knows, maybe I have the only surviving example out there.  And if that is the case, he very well may want a copy.

Details will be given as they are learned, but it would appear that we are learning quite a bit about this old work horse.  But lets see if we can track down Mr. Saltzman.

WinCUPL: Fields and Tables

Fields and Tables are some of the most useful types of code one can use in WinCUPL.  It essentially allows you to build a truth table, and have the PLD function as your software specifies.

The application of this type of code falls under combinational logic, and is quite different from the other types of applications that one may need to use.  But it is a valuable tool when building any type of logic equation that is to do some type of decoding.

The video below gives a brief example of how to use Fields and Tables as well as providing source for the examples used.

WinCUPL: New YouTube Series

I’ve decided to start a new series on my YouTube Channel, dealing with the programming of PLDs, specifically the Lattice/Atmel GAL16V8 and GAL22V10.  There isn’t a ton of information out there for programming these.  I think of it as a public service, providing this information to hobbyists.

These devices are truly amazing.  Giving the user the ability to use one device to simulate the function of around 10 Logic ICs.  And their availability is still plentiful, at least for the foreseeable future.

The reason there is likely not a lot of information out there about this type of software is that while these devices were in heavy use they were likely limited to those who could afford the technology to utilize them. I.e., the industrial and commercial sector.  The hobbyist likely could not afford the tools to program PLDs at the height of their use.

But that doesn’t mean we should let that intimidate us.  After all, these are logic devices.  And as such, use logic equations to determine their function.  That means that we simply need to know the syntax in order use these in our projects.

This series is going to at least cover the basics of simple logic, and registered logic.  We may progress into more complex designs.  But since these devices are limited by their internal fuse array, we may not be able to go too exotic.

Here is the Introduction video to the series.