Paul's DIY Terminal

I recently (May, 2020) dismantled and discarded most of a project that I put a lot of time into, back in the day. I’d kept it for about 40 years past its usefulness, so to make it easier to let go I took pictures first. Having them as a memento made it easier to part with this labor of love.

The only picture I have of the little B&W monitor I used is the one at the top of the page, taken many years ago. It connected with a coax cable to the the BNC connector on the front panel.

I started building this some time mid-way through my college years – it might have been the summer of ‘77. It got added to over several years – I know I was still using it in the summer of ‘81. After that I think I had access to better equipment through work. It was supposed to be a joint effort between my roommate and me, but somehow I rudely took over. I think we had some initial parts shipped to my place over a vacation, and I binged on it and came back to school with a working system. Sorry Dave!

We started with a display card that was designed as a dial-up terminal device. You could hook up a keyboard, and a modem, and dial in to remote computer systems. Our goal was to be able to access the campus computers from our dorm room. The board was an SCT-100, from a company called Xitex. It cost us $155.

The board was driven by a custom microprocessor chip of some sort, which lived on a big 40-pin socket. After using it as-is for a while, I realized we could use this thing as a general purpose computer display board by unplugging that chip and running our own wires to it from a different small computer. So I added a small computer system to drive the card, in order to give us better control over what it actually did. Besides, building a computer was fun! (I think we could unplug the computer and plug the chip back in to use the board as originally designed, if we needed to.) The new microprocessor was an Intel 8085, chosen almost entirely because I got the chip for free. The 8085 was essentially an 8080 with a few more instructions, as well as being easier to design with.

If you’re wondering, I think that in the end I ended up with nothing much more functional than the original Xitex board had been all by iself. But again – building a computer was fun!

Construction was all on solder prototyping boards. One later board was done with wire-wrap.

Storage was provided by a small set of UV-eraseable EPROM chips. I built my own programmer, and used EPROM erasers at work (basically just a “black light”) to clear them when I needed to.

The modem was capable of 300 baud. Later on I added some ports on the front panel to allow connecting a 1200 baud modem. Zoomin’!! The display was 16 lines of 64 characters. It was still better than the punch cards were using in the computer center.

This is the processor card. The 8085 is in the upper left, and the 8155 in the upper right provided a little bit of RAM (256 bytes!) and some I/O ports. I believe the empty socket in the center was where the umbilical for driving the big display board plugged in. I don’t recall what the switch in the upper right was for.

This was the storage card. I think the chips were 2Kb chips, so I guess I had 6Kbytes of storage for my code. The code was mostly code to act as a computer terminal – I think it emulated an ADM-3A, which was popular at the time. There was also a little “monitor” program you could use, which let you read/write memory, look at registers, program EPROMS, and start the terminal program. Even in 1980, I was programming in ‘C’. No assembly required, except for a bit of low-level glue.

This board held the uarts, for talking to the modem (and a planned, but never implemented, cassette tape storage unit). It’s also the EPROM programmer. Honestly, I don’t really remember how it worked. :-) The EPROM to be programmed went in the big “zero insertion force” socket. The switch may have applied a programming voltage to the chip. I see it has another 8155 chip – I guess that in addition to some more I/O ports for doing the programming, I must doubled have doubled my RAM!

The debug board was a later addition, after I learned how hard it is to debug code running directly on the hardware – no simulator, no software debugger. (My little “monitor” program could help, by allowing me to look at the contents of memory locations, but that’s not always enough.). The processor was simple enough that it could be single-stepped fairly easily, or put into a slow running mode. The blocks of LEDs along the top of the board showed the raw 16-bit address and 8-bits of data.

Later on I wanted more storage, so I wire-wrapped up a new board with more EPROM sockets. I don’t recall using it that much.

The keyboard came as a kit. It was pretty simple. The connection to the computer was parallel – i.e., 8 bits, or one character, at a time. Computer systems weren’t all capable of recognizing lower-case characters in those days, so the keyboard had a switch added to act as a caps-lock. The red button in the lower right was a “break” key. “Break” isn’t an actual character – the data line going from a terminal to the system it’s talking to normally floats “high”, and when characters are sent that line briefly goes low to send the bits of the character. The little “carrier” LED indicated whether the modem was connected properly to a remote system. The “break” signal is simply yanking that line low for longer than a character could ever take. It was usually used to tell the remote system to quit whatever it was currently doing.

Here’s the documentation for the commands (that I wanted to be) available from the firmware. The ‘L’ and ‘R’ commands, for dealing with tape storage, never happened.

These pictures show the system’s entire source code. It totaled something like 2200 bytes. Six pages of C code, and four of assembler, for runtime startup, I/O port and special instruction access, and data block layout. Since I don’t have original source files, just a few printouts and listings, I suspect this code is only an approximation of what I was really running.

Someone wrote to me, after seeing this page, and asked what compiler I used. I honestly don’t remember! I didn’t own any other computer at the time, so the compiler must have been hosted on the university system (TOPS-20, I think), or maybe on a UNIX system at the office.

C language code:

Assembler:

Hardware design happened in a small notebook. The graph paper pages were just big enough to lay out chip and wire placement for a single board.

The End (for now)