TRS80 Model 4 Rebuild - Part 2

Having sorted out the serial interface connections I turned my attention to the floppy drive controller. 

Interestingly the machine had the spectrastrip connector between the main board and the floppy drive connectors replaced with SIL headers and an IDC cable when I received it.  Likely by a technician as TISCO (the service agents that worked for Porterfield Computers) back in the mid 1980's when the stock internal drives were being replaced with four half height units.

Mainboard floppy disk controller SIL header

In addition to the connector replacement was another modification to the floppy drive controller to switch the drive select lines on the internal connector between drives 0 (80 track) and 2 (40 track).  This allowed the machine to boot either 80 track or 40 track diskettes.  The drive select lines were wired to a switch mounted on the back of the cabinet.

Floppy drive controller with DS0/2 select switch

Back side of the floppy drive controller showing the connection to the DS0/2 switch

Closeup of the connections for the DS0/2 switch

The FDC in this machine is PCB#8858160.  The schematic is included in the Model 4 Technical Reference Manual.

Reversing the modification required the following changes:

Remove switch
Reconnect U1 Pin 4 -> J1 Pin 10 
Remove U18 Pin 6 -> J1 Pin 14

 

 

TRS80 Model 4 Rebuild - Part 1

While my Model 3 and one Model 4 are stock configuration machines, the one with the failed CPU from the previous post is definitely not.

I got it through the New Zealand Trade and Exchange newspaper in the late 90's and was staggered when I went over to pick it up because it was the machine that Bill Porter (the owner of Porterfield Computers... the Radio Shack agents) used for all his software development and I think subsequently sold to Basic Payrolls in Newmarket who did a lot of bureau payroll processing using TRS-80's in the late 80's.

I worked for Porterfield Computers as a holiday job in 1985/86 so had used the machine regularly.

It was very distinctive because the internal drives had been replaced with 2 x 80 track (Mitsubishi) and 2 x 40 track (Tandon TM-50).  

The machine was a US domestic model, imported before the 240v model was available and modified for 240v power.  

The power supplies are after market Astec units and there are a number of mods to the main board and floppy controller.

The machine had been sitting in pieces in the workshop for the last 4 years and I finally felt sufficiently guilty to sort it out.

Given that it is not intended to be stock configuration and inspired by Ian Mavric's "Building the Super Micro" article I replaced the floppy drives with two internal 3.5" 720kb units in the bottom bay which makes software transfer from a PC a bit easier.  I plan to connect one of the TM-50's externally so I can easily write disks for the other machines. A full height hard drive frame fills the top bay and I may install an "SD Card" and interface board the emulates a Radio Shack hard drive.

At some point in it's life this machine had lost the spectrastrip cable that connected the serial interface board with the main board.  As a 20 pin connector these are easy to replace with a 20 pin header and old IDE hard drive cables.

Serial interface board with spectrastrip header removed

Serial Interface board with spectrastrip connector replaced by 20 pin SIL header

Serial interface board with modified IDE hard drive cable for connection to the main board

Main board with spectrastrip header replaced by 20 pin SIL header

 

SBC6120 PDP8 Replica - Part 3

For me the thing that really really finishes the SBC6120 is the FP6120 front panel.

It takes a great PDP8 compatible single board computer and gives it the feel of a 1970's minicomputer.  Even if you never toggle in programs via the front panel, just watching it work makes you feel a lot closer to the inner workings of the machine.

When it came time to assemble the FP6120 I spent quite some time thinking how to get the best possible presentation and real PDP8 feel.

I concluded that:

  • Real PDP8's have don't have red lights on the front panel.
  • Real PDP8's have coloured switches.

and that the truely best presentation required the same.

The build instructions do suggest that the builder may want to use alternative LED's and that socketing the current limiting resistors might be a good idea.  More about this in the article about the FP6120 build.

This article is about painting switches.....

I was prompted to investigate switch printing when I saw the write up by Henk at www.pdp-11.nl on his SBC6120 build.

Following his lead I visited a number of automotive and specialty paint suppliers to try and find a suitable paint at a reasonable cost.  Stock colors were a poor match for the front panel decal and the offer of custom paint at NZ$70 per can wasn't very appealing.

At this point I remembered my brother-in-law is a keen plastic model airplane builder, has a spray kit and without much prompting offered to paint the switches. 

Switches after spraying

Close-up of switches after spraying

Masking to prevent overspray onto the switch bodies

 

A very impressive result for less then NZ$10 in paint and some qualified assistance.

For anyone looking to replicate this I used Humbrol Enamel colors 113 and 225.  If you don't have an on call painter it may be worth checking with a local model shop... they may know someone willing to do the job for beer, pizza, etc.

 

 

TRS80 Model 4 Fault

The TRS80 Model 4 had been languishing in the workshop for a few years and was finally due some attention.

Inspired by Ian Mavric's "Building the Super Micro" article I did a complete disassembly, cleaning and confirmed that the supression caps in the power supplies had been replaced before doing an initial test power up.

This was the result (sorry for the glare)....

 

While the characters would change with each power up the layout of the screen and behaviour was the same.  

The following steps helped me identify the problem and get the machine operational:

  1. Checked the power on pins 11 (VCC) and 29 (VSS) of the Z80 (U57).  This read 4.7 volts... a little lower than I expected but was consistent if I powered the main board from either power supply so I assumed it was OK.  At the lower end of the rated voltage range for the Z80 but probably OK.
  2. Used a frequency counter to check the clock on pin 6 of the Z80 (U57).  This was correct at 4 Mhz.
  3. Used a logic probe to look for activity on pins 27 (M1), 19 (/MREQ), 20 (/IORQ), 21 (/RD), 22 (/WR) of the Z80 (U57).  If the machine was running normally you would expect to see continuous pulses on these pins.  I saw no activity which suggested a problem with the Z80.
  4. Removed the Z80 (U57) and powered up the machine with no processor installed.  The result was the same display which further hinted that the problem might be the processor.
  5. Replaced the Z80 (U57) with a spare and was greeted with the Cass? prompt. 

It wouldn't be as much fun if the machines always worked.

 

 

SBC6120 PDP8 Replica - Part 2

Building an SBC6120/FP6120 kit requires a 2 pin stacking header to join J5 on the FP6120 with J10 on the SBC6120.

 
This header is not included on the partial kit of parts and I hadn't been able to find the right part from Digikey or Mouser.
 
I did however discover that stacking headers are commonly used in Arduino projects (http://www.adafruit.com/products/85), low cost, available in retail stores down here (not sure about the US... I heard that Radio Shack was selling Arduino so they may have them) and these can be easily modified to connect J5 and J10.
 
Here are a few photos that might help you out.  Hope the quality is good enough.
 

An Arduino 6 pin header before modification.

 

The 6 pin header with two of the pins removed (middle and end).  They pull out easily with pliers.

 

The 6 pin header cut in two along the middle pin and then the end pin also cut to size.  I gave them a tidy up with fine sandpaper after this was done.

 

 

Shows the same parts as above but  note the extra spacer on one of the headers.  This is the plastic section from the bottom of a standard DIL header.  Cut off two pins from the DIL header, pull out the standard pins keeping the plastic and slide it onto the bottom of the new header.   The header with the spacer is used on the SBC6120 and makes the header the same height as the 50 pin header in J4.  Probably not critical but it looks more finished.
 

 

 

The component side of the FP6120 and the header (the one without the spacer).

 

The solder side of the FP6120 and the header pins which will mate with the header installed in J10 on the SBC6120.

 

The component side of the SBC6120 and the header with the spacer.  

 

I found that the SBC6120 header was the same height as the 50 Pin header supplied with the kit.  When I mounted the SBC6120 on the FP6120 they mated perfectly.

If you are building up the SBC6120 and want to test it before completing the FP6120 and you don't have a header for J10 then don't install anything (saves unsoldering later).  Skipping the header won't cause any problem, just prevents a Break returning you to the control panel mode.  Not really important for testing.

 

SBC6120 PDP8 Replica - Part 1

I have always been a fan of DEC Minicomputers.  

Not because I have used them a lot (despite what the guys at work think I am a bit too young for that) but as a teenager in the 1980s playing with microcomputers I spent a lot of time dreaming about those machines in my collection of DEC product catalogs.

My father worked for the Physiology Department of the School of Medicine, University of Auckland from the early 1970's until he retired in 1995.  

The first computer I ever saw was the PDP8e that he had at work.  I don't recall any many of the specifics of the machine except that it was huge (what wasn't when you were under 10), had really cool blinking lights on the front panel and printed me a snoopy calendar when I visited on one of the department open days!

John P Quinn - Physiology Department, Medical School, University of Auckland circa 1975 with PDP8e

While I was studying at the University of Auckland in the late 1990's I visited the my father at work and spent a lot of time using the department machines while I was waiting for my ride home.  Even in the 1990's the PDP8e was still operational and lived in a little "computer room".  

From memory it had been expanded beyond what was shown in the photo.  It still had the TU56 tape drive but I vaughly recall disk storage as well.... likely an RK05J and an LA36 DECWriter printing terminal.  I am not sure what the machine did at that point in it's carreer having been replaced for many lab tasks with a mix of Apple II, BBC Micro and MDL S-100 Bus machines.

It was still a very impressive looking machine with the blinking lights and front panel switches.  I wonder what happened to it?

 

Fast forward to 2012 and having completed the Z80 machine on prototype board I was looking for another construction project.

In 2003 Bob Armstrong's Spare Time Gizmos produced a PDP8 compatible single board kit computer (SBC6120) and companion front panel (FP6120).    The kits had been out of production for many years but Bob had very generously published all the design files on his web site.  If I would build a Z80 on prototype board surely I could build a PDP8.  It didn't look too hard and someone else had been crazy enough to try (http://juliepalooza.8m.com/sl/pdp8e.htm).  I even found a source for the HD6120 CPU.

I posted an enquiry on the Yahoo Groups SBC6120 group before I kicked off the process to see if anyone had comments on the practicality of building the machine this way.

The result was contact from a group member and a very generous opportunity to acquire an unbuilt kit.  Not something I ever imagined possible.

I took my time working through the build process on the SBC6120 from October through December 2012.

Having one opportunity to build this kit I was determined to build it to the highest possible standard.  That mean't ordering the original parts specified for the kit rather than trying to substitute parts from the junk box.  Sometimes this was expensive, particularly "mechanical parts" like the IC sockets, reset switch and indicator LED's but the result was well worth it.

The following are a series of images showing the SBC6120 through the construction stages.....

SBC6120 PCB and partial parts kit as supplied by Spare Time Gizmos.

SBC6120 PCB populated with machined IC sockets, passive components and sockets.

Operation SBC6120 with Compact Flash Adaptor

Note: Indicator LED's and Stacking Header not installed.

SBC6120 with Compact Flash and 5V switching supply under test

 

SBC6120 showing J10 CPREQ jumper.  Needs to be replaced for connection to FP6120

 

Switching Mains Equipment with a Raspberry Pi - Part 2

Part 1 of the mains switching project covered the hardware and this section covers the software.

The control software is a small Python program called fence.py built around the Raspberry PI GPIO and web.py libraries.  This provides a web interface on port 80 through which the solid state relay connected to GPIO 7 can be toggled.

 

#!/usr/bin/env python
import web
import RPi.GPIO as GPIO
import atexit

CTRL_FENCE_POWER = 7
WEB_PWD = "qwerty"

GPIO.cleanup()
GPIO.setmode(GPIO.BCM)
GPIO.setup(CTRL_FENCE_POWER, GPIO.OUT)
GPIO.output(CTRL_FENCE_POWER, False)

class webservice:
    def isvalid(self):
        request = web.input()
        return True if ("id" in request and request["id"] == WEB_PWD) else False

    def render(self):
        return render.index("on",WEB_PWD) if GPIO.input(CTRL_FENCE_POWER) else render.index("off",WEB_PWD)

class root(webservice):
    def GET(self):
        if self.isvalid():
            return self.render()
        else:
            return web.notfound()

class fence(webservice):
    def GET(self,name):
        if self.isvalid():
            if name == "on":
                GPIO.output(CTRL_FENCE_POWER, True)
            elif name == "off":
                GPIO.output(CTRL_FENCE_POWER, False)
            return self.render()
        else:
            return web.notfound()

@atexit.register
def shutdown():
    GPIO.cleanup()


if __name__ == "__main__":
    urls = ('/','root','/fence/(.+)','fence')
    app = web.application(urls,globals())
    render = web.template.render('/home/pi/fence/templates/')
    app.run()
 
Three URLs are recognized by fence.py
 
The root URL will display the status of the fence and the toggle button to allow the state to be changed.
 
e.g
 
http://localhost
 
The /fence URL supports two named commands (on and off) which change the GPIO state and displays the new status of the fence.
 
e.g
 
http://localhost/fence/on and http://localhost/fence/off
 
Because I wanted to make the application accessible from the internet I added very simple security where all requests require the provision of an id in the URL.
 
e.g
 
http://localhost/fence/on?id=qwerty
Failure to provide the ID will return a "Not Found" Error (404).  Good enough security to stop someone finding the incoming port and playing.
 
 
The status page is rendered using a web.py template.
$def with (state,WEB_PWD)
<html>
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
<style>
    a { text-decoration: none; }
    .button {
        padding: 5px 10px;
        display: inline;
        background: #777 url(button.png) repeat-x bottom;
        border: none;
        color: #fff;
        cursor: pointer;
        font-weight: bold;
        border-radius: 5px;
        -moz-border-radius: 5px;
        -webkit-border-radius: 5px;
        text-shadow: 1px 1px #666;
    }
    .button.off { background-color: #000000; }
    .button.on { background-color: #000000; }
    .button.large { font-size: 125%; padding: 7px 12px; }
    .label { font-size: 100%; color: #fff; }
</style>
<br/><br/><br/><br/><br/>
$if state=="on":
    <body bgcolor="red">
    <center><a href="/fence/off?id=$WEB_PWD" class="button large on">TURN OFF</a></center>
$elif state=="off":
    <body bgcolor="green">
    <center><a href="/fence/on?id=$WEB_PWD" class="button large off">TURN ON</a></center>
$else:
    Fence state not known.
<br/><br/>
<center><p class="label">James' Electric Fence</p></center>
</body>
</html>
 
The Raspberry Pi is configured to start the fence.py program when it boots.  
 
This is done using the following /etc/init.d/fence script:
 
### BEGIN INIT INFO
# Provides: Electric Fence AC Power Controller
# Required-Start: $remote_fs $syslog
# Required-Stop: $remote_fs $syslog
# Default-Start: 2 3 4 5
# Default-Stop: 0 1 6
# Short-Description: Electric Fence
# Description: AC Power Controller
### END INIT INFO

#! /bin/sh
export HOME
case "$1" in
start)
echo "Starting Fence"
sudo /home/pi/fence/fence.py 80 &
;;

stop)
echo "Stopping Fence"
FENCE_PID=`ps auxwww | grep fence.py | head -1 | awk '{print $2}'`
kill -9 $FENCE_PID
FENCE_PID=`ps auxwww | grep fence.py | head -1 | awk '{print $2}'`
kill -9 $FENCE_PID
;;
*)
echo "Usage: /etc/init.d/fence {start|stop}"
exit 1
;;
esac
exit 0

Starting and stopping the fence service can be done with the commands:
 
sudo /etc/init.d/fence start

sudo /etc/init.d/fence stop
 
sudo is required both here and in /etc/init.d/fence because fence.py accesses the GPIO ports which is only possible as an administrator.
 
Hope this proves useful for someone.
 
 
 
 

Switching Mains Equipment with a Raspberry Pi - Part 1

With some simple hardware and software a Raspberry Pi connected to your home network can be used to switch mains powered equipment (I think this is called line power in the US).

A word of warning - if you are not familiar with the safety and construction practices required when working with mains power then please do not attempt this.  This stuff can bite, sometimes it bites hard enough to kill you (particularly in regions where mains is 220-240VAC) and I don't want to be killing off readers.

 

AC Switching

The design discussed here is not for switching high loads.  

In my case I am switching an electric fence controller and other low current items so used a solid state relay designed for 240VAC switching up to 3A.  If you are in New Zealand or Australia this is available from Jaycar Electronics as SY-4080.  A higher capacity unit is also available as SY-4084.  As the rated capacity goes up so does the price.  If you are interested there is a good article on Wikipedia that talks about the benefits of solid state switching relays over mechanical types for AC switching.  

There is another benefit... the relay can be switched on with any voltage above 3v.  This makes it easy to switch with a 5V logic level and possibly 3V3 as provided on the Pi GPIO header but if you are going to use a buffer on the GPIO pins (which you should) then using one that will give 5V logic levels provides a bit more margin.

 

Interfacing the Solid State Relay to a Raspberry Pi

The solid state relay connects is interfaced to the Pi's GPIO header via a buffer chip.  My design uses GPIO 7, 8, 9 and 10 as outputs to control the solid state relays.  I only have one relay installed at the moment but have designed for expansion.

For a description of the Pi's GPIO header and pin assignments please refer to http://www.raspberrypi-spy.co.uk/2012/06/simple-guide-to-the-rpi-gpio-header-and-pins/.  

5V power is provided to the Pi via the 5V (Pin 2) and VSS (Pin 6) GPIO Header pins.  The power is provided by a recycled external USB hard drive power supply which has 5V and 12V regulated outputs.  Only the 5V is used.

For the buffer I used a 74HCT244 buffer because it was in the junk box.  Alternative parts with small changes to the schematic would be the 74HCT573 or 74HCT245.

If using a 74HCT244

  • The GPIO 7,8,9 and 10 (Pins 26,24,21 and 19) are taken to the 1A0, 1A1, 1A2 and 1A3 inputs of the 74HCT244 buffer.  
  • All unused inputs 2A0, 2A1, 2A2 and 2A3 on the 74HCT244 are tried to ground to prevent oscillation.
  • The 74HCT244 is run at 5V.  The 74HCT is a CMOS device that uses TTL logic levels on it's inputs.  This means that >2V on one of the GPIO pins will be treated as 1 with an output of 5V from the 74HCT244 providing a nice margin above the relays minimum switching voltage. 
  • The /OE1 and /OE2 pins on the 74HCT244 are both tried to ground to enable the outputs.  

I am switching the electric fence with Pi GPIO 7 via 74HCT244 1A0 -> 2A0.  2A0 is connected to the + control input on the solid state relay.  The - control input is grounded.

 

The 74HCT244 buffer, relay(s) and header for the 240VAC mains is assembled on prototype board.  This connects to the Pi via a 20 pin IDC header.

 

The Pi and the recycled power supply are mounted on the inside of the case lid.  

For safety, plastic screws are used to mount the bottom of the original power supply box which then has the PCB held in place with cable ties.  For extra safety I should have left the top on the box but once opened it was impossible to reassemble .  The power supply gets 240VAC from the incoming switched line and can be disconnected and the Pi and interface board run from 5V via the Pi USB connector for "testing".

Coming in Part 2.... The Software

 

 

Supporting Generic Kermit 4.11 in your CPM/80 BIOS

I have written about my home built Z80 CP/M computer in earlier posts.  Based on a design by Grant Searle (http://searle.hostei.com/grant/cpm/index.html) this fabulous litle machine is easily built on prototype board as long as you take your time and keep your interconnect wires short.

 
The hardware uses a Z80-SIO to provide two serial ports (with TTL to USB adaptors on my build).  Versions of the BIOS up to 0.5 would look at which port the user pressed [space] when the monitor ROM starts and use this as the CRT.
 
The second serial port was essentially unused as there was no reader and punch support code in the BIOS to utilize this port.
 
Using the supplied source I was able to update the BIOS to provide reader and punch support without much difficulty and by providing some less than stellar code samples to Grant have prompted him to add official support for punch, reader and list to the 1.0 BIOS (thank you Grant!).
 
What I really wanted to be able to do was run Kermit 4.11 (http://www.z80.eu/kermit.html) to transfer batches of files to and from the machine.
 
Kermit 4.11 offers support for "Generic CP/M 2.2 system with IOByte".... but what did that mean?
 
Google pointed to many sites that talked about IOByte (or duplicated detail from the DR documentation). There was much comment about how poorly and inconsistently it was implemented in the BIOS of various machines, comments in the Kermit documentation that it was slow and nothing that hinted on how it was to be used with Kermit.
 
The following will, I hope benefit anyone else attempting to adapt their own BIOS to support IOByte and ultimately run Generic Kermit on CP/M 2.2.
 
First the results....
  • It works (actually it works well).  I can transfer files from a desktop to the Z80 at 115200 baud with no errors (the interrupt driven serial IO and buffers in the BIOS make this possible).
  • It requires two serial ports on your Z80 machine (or a CRT and a free serial port).
  • The BIOS changes are actually quite simple to implement.
 
Specifically
  • Kermit expects to change the lowest two bits (bits 1 and 0) of the IOByte when it wants to switch between the writing status info to the terminal and the data connection.
  • It expects the lowest two bits to be b01 when updating the terminal with transfer status information.
  • It expects the lowest two bits to be b00 when transferring files via the data connection.
  • All communication (whether updating the terminal or transferring data) is via the CONIN, CONOUT and CONST BIOS calls.
 
What this means when you are modifying your BIOS is that the CONIN, CONOUT and CONST BIOS calls need to look at the lowest two bits of IOBYTE and switch between the terminal and data ports (and their in-memory buffers which Grant's BIOS does very well) based on the value.  
 
The reason Generic Kermit does this is so it can use the CONST BIOS call to work out if any data is available rather than making a blocking call to CONIN or RDR.
 
Based on this Grant has included IOByte support in the 1.0 BIOS for the Z80 machine and it works well with Generic Kermit.
 
When using Generic Kermit I used the following configuration options successfully at the Z80 end:
 
	SET PORT CRT
	SET FILE-MODE BINARY
	SET FLOW ON
	SET AUTORECEIVE ON
	RECEIVE
and the following with my MACBook (these will be specific to your environment)
	SET PORT /dev/tty.SLAB_USBtoUART5
	SET SPEED 115200
	SET FILE TYPE BINARY
	SET FLOW ON
	SEND *

 

 

Using eBay TTL Serial/USB Interface Modules


With most computers no longer having a serial port, a TTL Serial / USB interface is required for many microcontroller projects.

I have had good results with the low cost eBay modules based on the Silicon Labs CP2102 chipset.

These modules can cost as little as US$2 per module (often including postage) but there are a few things to be aware of:

Handware Handshaking

Most eBay advertisements say "All handshaking and modem interface signals." 

This is referring to the CP2102 chip but these signals may not be available on the module.  This can be a problem if your interface requires hardware handshake lines such as RTS and CTS.

The Z80 single board computer requires RTS handshaking and the initial modules I ordered did not support this.  If you need hardware handshaking (and most microcontroller projects do not) then invest the extra $1 required to get a module with these pins available.

A CP2102 based module with no handshaking signals.

RST shown on the pin header for these modules is not RTS misspelled..... it is the reset line for the CP2102 chip.

A CP2102 based module with handshaking signals - note the extra holes on the sides on the module.

Connections

Connect the module to your circuit as follows:

3.3V Do not connect if your circuit does not require 3V power
RST Do not connect
TXD Connect to the TXD output of your circuit
RXD Connect to the RXD input of your circuit
GND Connect to the GND of your circuit
5V Do not connect if your circuit does not require 5V power

Powering your Circuit from USB

If you require 3.3V or 5V at less then 500ma then it is possible to power your circuit from the 3.3V or 5V pins on the module.

Note that the default configuration for the CP2102 is to request a power budget of 100ma.  If you require more then 100ma (0x32 units @ 2ma) then you need to change the Max Power configuration setting using the CP210xSetIDs.exe utility from Silicon Labs (www.silabs.com).

Connecting Multiple USB Serial Devices to a single computer

If you want to connect multiple USB Serial Devices to a single computer at the same time then you need to change the serial number setting using the CP210xSetIDs.exe utility from Silicon Labs (www.silabs.com).  This allows you computer to distinguish between multiple connected USB devices and assign each device a unique COM port.

I don't want a Type A USB connector

All the low cost modules I have seen use the Type A USB connector which is intended to connect directly to the host machine.  

If you are building the module into a device this is not the connector you want and a Type B USB connector is a better choice.  It is easy to remove the Type A connector from the module, solder a Type B module to your PCB and then use short wires to connect the module to the Type B connector pins.

 

Home Built Z80 CP/M Computer - Part 3

The Z80 Single Board Computer is mostly (still needs front panel LED's for power and HDD access) complete and mounted in a Jaycar instrument case.

An interesting exercise was creating the front panel art for the case.  I tried using various paint programs (Paint.Net for Windows is a great application) but found that the best results could be had from Microsoft Word.  I spend plenty of time in Word in the day job but haven't really used the Word Art feature.  Word Art and the ability to position items on the page using cm or inches makes it really easy to ensure the printed results are the right size.    

The panel art is printed on plain white paper with a clear plastic cover.  The Jaycar instrument case is slightly recessed where the panel is mounted.  The end result looks very smart.

The two serial interfaces use CP2102 USB/TTL Serial interface adaptors purchased on eBay for a couple of dollars.  They work well in this application easily running at 115200 baud as required by the machine.  Silicon Labs provides configuration software so the boards can be given unique ID's and load as different ports on the host computer.  

I did make a mistake when ordering the mobiles.  Most eBay advertisements for CP2102 boards say "All handshaking and modem interface signals.".

Yes technically this is correct... the CP2102 does have these but on many boards they are not accessible.  Most really cheap boards have a 6 pin header with VCC3, VCC5, VSS, TX, RX and RST.  RST is reset not RTS spelled incorrectly!  It is the CP2102 Reset line.  

The Z80 SBC design uses RTS handshaking on the serial ports so I really needed boards that supported this.  Slightly more expensive (about US$3) boards have this, not necessarily on the 6 pin header but available on sockets on each side of the board.  

I have replacement boards on order and will replace the existing boards when they arrive.

An unexpected benefit of the USB interface is that the entire machine can be powered from a single USB port and doesn't need an external power supply.  Power consumption is in the region of 5V/250ma... easily supported but USB but something I hadn't even considered when I started down the USB track.

The next step (after replacing the serial boards and adding the extra LED's) is to install an updated CBIOS for CP/M that implements IOBYTE.  The use case for this is to run the Generic CP/M 2.2 Kermit software for file transfer from a PC.  While Grant has done a nice job writing a file transfer application, my preference is to go with Kermit.  It's command line interface makes bulk file transfer a bit easier.  

I have many 7 x 8mb drives to fill and so many different CP/M applications to get running.  Wordstar 3.3 on CP/M.... now that brings back some memories.

 


Page 5 of 11

Powered by Easytagcloud v2.1

Contact Andrew Quinn

jaquinn@ihug.co.nz http://twitter.com/jaquinn