JAQ's Blog - Electronics, Microcontrollers, DEC Minicomputers, Raspberry Pi, Airplanes and other stuff....

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

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

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.

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.

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

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.

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.

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

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()

http://localhost

http://localhost/fence/on and http://localhost/fence/off

http://localhost/fence/on?id=qwerty

$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>

### 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

sudo /etc/init.d/fence start

sudo /etc/init.d/fence stop

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

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.

• 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.

• 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.

	SET PORT CRT
	SET FILE-MODE BINARY
	SET FLOW ON
	SET AUTORECEIVE ON
	RECEIVE

	SET PORT /dev/tty.SLAB_USBtoUART5
	SET SPEED 115200
	SET FILE TYPE BINARY
	SET FLOW ON
	SEND *

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:

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.