Category Archives: Blog posts

RetroChallenge 2017/10 – and the beat goes on

Yesterday I checked the voltages with my DMV and everything looked OK. Today I checked with the ‘scope just to check for ripple and they all look pretty clean to me.


I also saw that there was a running clock but overnight I became increasing worried that it wasn’t a very good clock.

Here’s the circuit…

It doesn’t look too tricky.

Check with the scope.

A scope trace shows it’s a bit funny. I’m not sure quite what the Z80 needs but I thought it should have a better back edge than that.

More thought needed.

RetroChallenge 2017/10 – Let’s see what we’re up against

So, it starts.

In my last post I said that I intended to fix my newly acquired but already much loved Nascom-1.

Up until now I hadn’t even powered it on but the time has come.


So that’s it, random nonsense. The reset button makes the screen flicker but the nonsense doesn’t change.

The previous owner said that he had tried a new CPU, cleaning all of the tarnish of the chips and the 74LS139 and 74LS11 associated with the video RAM address decoding.

He’s clearly better at this than I am but I’m still going to try and get this old one going.

First things first

Out with the multimeter and check the power supply. There are three rails; 5V, -5V, 12V and -12V. Helpfully there are four LEDS on the PSU board and they are all lit up. Also, the meter confirms that all are present and correct.

The bits on the bus go up and down

Sadly actually most of them don’t. I fired up the oscilloscope and looked at the signals on the pins of the Z80 CPU. There is very little activity. There is a clock signal on pin 6. MREQ is toggling. There is little else. There is no activity on M1 that signals the start of an instruction. The data pins are all high as are the address pins.

Surely there should be activity on the address bus?

That’s it for Today. I will read up on bus access and try to see why the address lines aren’t changing.


And you’re back in the room – Retro Computer Festival 2017

I has been several months since I last posted anything here. In fact is was my wrap-up of the work I had done during the RetroChallenge 2017/4.

I certainly haven’t been idle on the retro computing front. In fact I have been busier than ever. I just haven’t been writing about it.

Retro Computer Festival 2017.

Most of my efforts have been preparing for and attending Retro Computing Festival 2017 at the Centre for Computing History in Cambridge.

My old friend Tristan and I volunteered to fill a table with old bits and bobs and at the time of booking we brainstormed ideas coming up with “something to do with ASCII art”.

For those of you not in the know, ASCII Art uses the characters of the 7-bit ASCII set to represent brightness levels of bitmap graphics.

We decided to use a web cam, an old machine and a daisy wheel printer to take photos of people visiting the museum and print out low resolution ASCII version of them.

Non of the old machines we had in mind will support a web cam. They don’t even support USB so we decided to use a Raspberry Pi to grab images from the camera, turn them into low resolution grey scale images and send them to a retro machine over serial using the X-Modem protocol.

We weren’t going retro with the image capture but we were from that point on.

My first thought for a suitable machine was to use the Exidy Sorcerer but a quick internet search suggested that there was a problem with its serial port that might make things difficult.

Next up was my beloved Sharp MZ700 but that developed a fault in the PSU and started blowing fuses. The Wang laptop was to slow in GW-Basic and too unlike a PC for Qbasic or Turbo C.

We finally settled upon Tris’s 386 Toshiba laptop with its funky amber plasma display.

The printer of choice turned out to be an Epson dot matrix.

Other stuff.

It took a lot of mucking about to put this project together  and as the date drew closer we were getting a bit worried that it wouldn’t be working properly on the day and so we thought it wise to take a few other bits and pieces.

I the photo above you can see the Toshiba on the left, my Exidy sorcerer on the right. We also took a BBC micro incase of emergencies (we didn’t need it), my Creed 7B teleprinter and a Ti-99/4A.

In the end, the ASCII art worked pretty well and people seemed happy with the results.

Now, what to do next year.




Retrochallenge 2017/4 – Interak CF card – Wrap up

Well Retrochallenge 2017/4 is coming to an end and it’s time to wrap up this season’s efforts.

I set myself the challenge of adding CF card support to my Interak-1 and basically, I didn’t make it.

However, since the last post I have made some progress; I have tried two new CF cards (thanks to Spencer at for that). These gave different results to the original and seemed to work better.

I still don’t understand why two different but equivalent I/O commands give different results. It has been suggested that timing is the issue here but I don’ know enough about Z80 hardware to try and add a wait-state when accessing the CF card.

The current state of play is that I think I can read the card but as I don’t have a way of writing to the card on a different machine, I can’t prove it :-(. I have a write routine written on the Interak but I don’t think it’s working.

On the plus side, I have built an adapter to add a CF card to my machine by adapting hardware intended for the splendid RC2014 machine. That’s not too shabby.

There is more work to be done here.


So long Retrochallenge, it’s been fun. See you in October!.

Retrochallenge 2017/4 – Interak CF card – Part 4

We are well into the second half of Retrochallenge now and it fair to say that I’m not where I wanted to be. However I am learning a great deal about Z80s and CF cards are their respective wily ways.

Things continue to be confusing.

A quick re-cap of my previous posts…

It started off with the status of the CF card never showing that the read transfer was ready. However, using the ROM monitor on the Interak rather than the program showed that it was. There were various trials and hair being pulled out but what it boils down to is this.

If I use…

    ld        BC, (0x0067)
    in        a, (C)

I get one value but if I use…

    ld        a, 0x00
    in        a, (0x67)

I get a different answer.

Note 0x67 is the CF card status port.

According to the Z80 manual from Zilog, in a, (C), puts B on to the top of the address bus, C on to the bottom and reads from the addressed I/O port. So that’s 0x0067.

Now, in a, 0x67, puts A on to the top of the bus (previously loaded with 0) and 0x67 on to the bottom and reads the addressed I/O port.

These two are functionally the same but give different results.

One suggestion that has been made though the VCfed forums is that it’s a timing issue as the in a, (C) version takes a little longer.

I have a few things to try. I have a couple of other CF cards on order and they should arrive soon. I’ll try them to see if there is some issue with the timing of this card. I’ll also look to see if I can get a wait state in to the IN operation.

More news when I have it.


Retrochallenge 2017/4 – Interak CF card – Part 3

Things are a little weird as I suggested in my previous post.

I have the CF card installed and if I use the ROM monitor in the Interak to access it through a series of Port commands, I can see what appears to be sensible data. If, however I use a piece of Z80 assembly language, I never see the CF card become ready.

I have tried my own code and two other variants found on the web.

Let me show you what I mean. This snippet came from Scott Baker’s website…

1069:         	WAITDRQ:
1069: F5      	        PUSH    AF
106A:         	WAITDRQLP:
106A: DB67    	        in 	A,(I7)
106C: E608    	        AND 	08H
106E: FE08    	        cp 	08H
1070: 20F8    	        JR	NZ, WAITDRQLP
1072: F1      	        POP 	AF
1073: C9      	        RET

To use this, I have set up the sector and all other parameters needed for a disk read. If I run this routine, it never finishes. breaking the code at 0x106C shows that the accumulator is either 0x40 or 0x41. Which means “Drive ready” or “Drive ready + error”.

However, if I use “P 67” at the monitor, I get “0x58” which means “Drive ready + Drive seek complete + Data request ready”.

I can run from 0x106A to 106C again and again I see 0x40 or 0x41 in the accumulator. If I use “P67” again, again I see 0x58.

Can anyone see the deliberate mistake because I can’t 🙁

Retrochallenge 2017/4 – Interak CF card – Part 2

In part 1 I was able to build a CF card adapter for the Interak. Mostly this involved using RC2014 parts.

Now it’s time to tell you about the testing and things are pretty weird.

A bit of background.

At the moment, my Interak-1 has no mass storage at all. No hard drive or floppy. Nor does it have a serial port that I can connect to my PC.

It only has cassette, screen and keyboard. This is making testing challenging.

In an earlier post, I described a USB keyboard adapter that I had built during last year’s Retrochallenge. This gives me a USB keyboard. At the end of the post I mentioned adding USB serial in so that I could use a serial terminal emulator to “squirt” data at the Interak as if it had been typed in.

I did that mod and this is the method I am using for testing because no one wants to type in a couple of hundred bytes of hex manually that may well crash.

It has no handshaking and so I have to be careful not to send too much at once but it’s working well.

First steps.

I am following in Scott Baker’s footsteps a bit here. Scott has added CF to the RC2014 and it’s his board design I am using. He describes the process of setting up the card and reading a sector as follows…

read register 7 until the busy bit (0×80) is unset
write 1 to register 1
write 0xEF to register 7
write 0×82 to register 1
write 0xEF to register 7
0xEF is the “set feature” command. Feature 1 enables 8-bit mode. Feature 0×82 disables any write caching. You should do this whenever the compactflash is reset or power cycled.
Read a sector
read register 7 until the busy bit (0×80) is unset and the ready bit (0×40) is set
write 1 to register 2, to set the sector count to one sector
write bits 0..7 of the block address to register 3
write bits 8..15 of the block address to register 4
write bits 16..23 of the block address to register 5
take bits 24..27 of the block address, or them with 0xE0, and write to register 6
write 0×20 to register 7. This is the “read sectors” command.
read port I7 until the busy bit (0×80) is unset and the DRQ bit (0×08) is set
read 512 bytes from register 0

By using the PORT command (P) of Zymon 2 (the Interak’s ROM monitor) I can carry out the above instructions and it seems to work well.

Just a note. Zymon is a little quirky and it’s not the easiest thing to follow. I can’t put blank lines in for clarity, they get ignored. Also, the P command reads from (no parameter) or writes to (one parameter) an I/O port. However, if I type, for example “P 67” to read the status byte on the CF card, Zymon puts the byte on the same line making it impossible to see whether or not I wrote to the port or read from it.

In this photo I set up the card ending with the line “P 67 EF”. I then do the read (up to line “P 67 20”). I get the status with “P 67”, the result is “58” – Drive ready + Drive seek complete + Data request read.

The, the following “P 60″s show data being read from the first sector of the drive.


Now the weird. I have tried doing this using a bit of assembler code and it doesn’t work.

I’ll put the full details in my next post.

Retrochallenge 2017/4 – Interak CF card reader revisited – Part 1

Retrochallenge is well under way now and so it’s time I made a start and got something blogged about. Although my posts here don’t show a lot of activity, I do some work on one or other of my retro systems most weeks throughout the year but Retrochallenge is a good reminder to blog about some of this activity in the hope it may be useful to someone else or help to promote interest in our hobby.

Catching up.

A little while ago I tried to get a CF card adapter to work on my splendid little Interak-1. That didn’t work properly but an email conversation with a friend of mine who also has an Interak suggested that my cables were too long and that I needed to get the CF card as close to the CPU as possible.

So, my first Retrochallenge project this time around is to re-visit that project and try and get it to work.

In the previous attempt I used a CF card adapter intended for the RC2014 (itself a Retrochallenge project). In order to get that to talk to the Interak I needed to make a bus adapter and to do that I modified an Interak prototype board.

As I said  above, the suspicion is that the CF card was too far away from the CPU.

Lets build a Mezzanine.

One way to get really close to the CPU is to slip a PCB between the CPU and its original socket and use this new PCB to link to the CF card adapter. This is the approach I’m using here.

I still want to use the CF adapter for the RC2014 and so I still need to convert from my Z80 CPU to the RC2014 bus. What better way to do that than to use an RC2014 CPU card?

Spencer Owen of RC2014 had a small number of prototype CPU cards in his Tindie store and bought one of those, soldered a wire-wrap socket to it, plugged that into a conventional socket and on into the socket my CPU originally sat in. (This is going on a bit, see the pictures).

Now the Z80 sits on the RC2014 CPU board and the Interak CPU board with the CF adapter over to the side.


Interak Compact Flash adapter – Part 1.

I have been making good progress with the Interak-1 and having a lot of fun on the way. I have made an adapter so that I can use a modern USB keyboard. I completed the VDU2K video board that was given to me with the machine so now I want to improve its storage.

My machine came with a twin port cassette card and a floppy disk controller.

I don’t think cassette is a goer these days. It was OK back in the day for home use but this machine deserves better. The floppy disk controller will be useful but I’m rather taken by Scott Baker‘s Compact Flash adapter for Spencer Owen’s RC2014 Z80 retro machine.

Spencer is an old friend of mine and his RC2014 has become very popular, with many kits being sold through his Tindie store. As with other good ideas, RC2014 has been a focal point for other people’s efforts and Scott Baker has contributed some great projects that build on the RC2014 is very cool ways. The Compact Flash adapter is one such project.

Scott has generously put his designs out there and made his PCB designs available through OSHpark.

The bits on the bus (go up and down)

Both the Interak-1 and the RC2014 are Z80, slot based machines with easy access to the bus. The first thing to sort out is to get the buses to match.

I was given two blank prototype cards with the Interak and so one of those will do fine.

There is a possibility that I will want to add more than one RC2014 board to my machine and so I didn’t want to just solder one of Scott’s PCBs to the proto card. At this point I bought an RC2014 5-slot backplane and planned to fit that to the proto board and link between the to buses.

In this photo you can see that I have soldered a pack of short links from the Interak bus connector. These will go on to have their loose ends swapped about and fitted into the RC2014 bus.

Here you see that I have pushed the flying leads into one of the backplane’s slots. At this point I was just setting things up and testing the connections.

OK in principle but I need A bit of Vero

The problem with the approach shown above is that the backplane is just a bit too big. I could cut the top and bottom off it, there isn’t anything important there, but that would spoil it. I’ll keep it for later. Maybe I’ll build an RC2014 ad I’ll need it then.

As there isn’t anything too complicated about the backplane, I substituted a piece of Vero stripboard instead.

That fitted much better.

The CF card adapter.

As I mentioned above, Scott Baker has published his PCB design on OSHpark for anyone to order. OSHpark has a minimum order quantity of three and I only wanted one but, someone else only wanted one it seems as a blank PCB appeared on ebay. Yea, here we go.

The circuit for this card is very simple and it would be very easy to lay it out on the proto card except for the fact that CF card sockets have tiny connectors and really don’t work with 0.1″, through-hole boards. A very good reason to use the RC2014 card.

Here we have the populated CF card adapter plugged into the stripboard backplane.

Next time I’ll try it out.



Interak VDU2K progress.

In my previous post I talked about a second VDU card that came with my Interak-1. This is a VDU2K and supports 64×25 characters in its 2K of video memory.

When I finished the card and plugged it in, it mostly worked but there were problems.

Clearly the monitor ROM was expecting half the resolution and put the prompt half way up the screen but it wasn’t clear whether or not there were other problems. I needed to try and clarify is there was a hardware issue too.

To cut a long story short, I have blown a ROM that tries to clear the screen and then output every character in the character set.

The photo shows that the character set looks fine but clearing the screen has failed. This particular photo is misleading as it shows the screen filled with a single character. That is unusual. I usually see a repeated pattern of two or three characters. I’ve tried a few versions of this test. I’ve put the character set in various places but it makes no difference. The result is always that the screen doesn’t clear properly but the character set is fine.

I think the problem is somewhere in the circuit that looks after memory reads.

Outputting the character set.

; Now. Just dump out the character set to the screen.
   ld		hl, SCR_START;
   ld 		b, 0x00
   ld		a, 0x00

   ld		(hl), a
   inc		hl
   inc		a
   djnz	loop

When I output a character set, I’m getting the CPU to write ascending values to successive memory locations. Just writes.

start:   ld		hl, SCR_START
         ld		de, SCR_START + 1
         ld		bc, SCR_WIDTH * SCR_HEIGHT - 1
         ld		(hl), 0x00

When I clear the screen I’m writing a 0 to the start of memory and then using the Z80 instruction LDIR to copy that throughout the scree’s memory. In order to do that, the Z80 must read the first location and copy it to the second. It then reads the second location and copies it to the third and so on.

The LDIR has to read memory and I think that’s the bit that’s going wrong.

Further reading.

When my friend Dave got this card, it seems that not all of the documentation was available. However, thanks to a chance discovery, I had been in contact with Dave Parkins of Greenbank Electronic the original designer and he generously found and emailed the design notes for the card!

As I was reading through these notes I came across this paragraph:-

In a current Interak 1 disk system all of the 64k of RAM should be enabled. All elements of the two DIL switches on the DRM-64 card should therefore be OFF.

My RAM card had been set to just use 48K. I switched in the remaining 16K and Bingo! we have a clear screen.

The new card seems to need the RAM beneath its own. I think it has something to do with the way the Interak avoid snow on the screen. However, we are up and running now.

As you can imagine, the monitor ROM doesn’t know about the extra screen real estate but it does work and so does the keyboard.

I was recently given some other binaries to try, including a monitor that can cope with 64 columns but it needs some attention as it was intended to run under CPM from disk.

Progress! I’m rather chuffed.