HP 21MX/F and OS choices (was Lookee what I just got!)

[Bob Shannon]

Thanks for the HP-IPL/OS plugs Jay,

Here is the fastest known method to bootstrap something useful on any HP1000
series CPU, be that a 2114 with 4K of core up to a 2117F with maximum 
memory:

First off you need to identify your loader ROM's, there are up to 4 of them 
on a 21MX
processor.  Core memory machines of course do not use loader roms, you 
toggle the
loader code directly into memory.

Hopefully you will have either the 264x terminal loader, or (better, but 
less common) the
paper tape loader.  Some documentation claims that the paper tape loader was 
standard
on all E-series machines.

Not true, that was written by Engineering before Marketroids started talking 
with customers.

If you don't have the loader rom's you want, no big problem they are 
available from list
members.

Ok, next look at what I/O boards you have.

The paper tape reader can be used with:

Microcircuit I/F
GND TRUE I/O
+ TRUE I/O
+8 bit duplex register
+16 bit duplex register

And several other less common interface boards as well.

The 264x 'terminal' boot rom can be used with the super-common BACI board, 
but it
cannot be used with any 12521-series serial interface boards.

Now you should have some combination of loader rom and interface board that 
will talk
to each other.  Maybe you have no peripherals for your box, frankly that's 
not a problem.

How the machine boots, the EASY way...

The simplest bootable software is stored in HP's "ABS" format.  This is a 
series of 8-bit
bytes that holds an absolute binary program with memory address, block 
length, and
checksum data.

If your booting through the paper tape loader the HP will request a byte 
with a hardware
strobe and wait for an 'ack' signal, read and process the byte, and either 
request another
byte or halt with an error or success code in the S-register.  Bytes will be 
read until the
end of the ABS file is reached, or there is an address or checksum error.

So the paper tape loader wants a string of 8-bit bytes, using a simple 
request-acknowledge
protocol.  The hardware signal DEVICE_COMMAND asserted requests a byte, 
setting
the DEVICE_FLAG signal on the I/O board acknowledges the request, clearing 
the device
command signal until another byte is requested.

A simple hack could tie a TTL-level parallel I/O board to a PC's printer 
port, or a simple
microcontroller can emulate a paper tape reader using an EPROM, flash, 
EEPROM, etc.

Booting ABS files from an 8-bit parallel data source is exceedingly fast. 
It is in fact the
single fastest way to load large ABS images, and you can stuff an O/S into 
memory faster
than HP's own disk drives (given a fast source of bytes to read).

If you happen to have the 264x loader and BACI interface combo you have a 
much
simpler hardware job, but the loading process is a little more complex. 
Your still going
to need to send a series of 8-bit bytes, but this time over a RS-232 
interface.

The 264x loader rom sets up the BACI board, then transmits an escape, then a 
lower case
'e'.  This escape sequence tells an HP terminal to begin an 8-bit read of an 
ABS image
stored on those little micro-cassette tapes.

But the BACI board is a bit of a beast, there are lots of wires that need to 
be jumpered
correctly in the I/O hood, and the board even has the ability to stall the 
CPU based on an
external signal line.

Exactly how this is all configured in an actual HP installation is slightly 
unclear to me at this
time, however it is possible to send RS-232 data into the board slowly 
without any hardware
handshaking.  Normally 264x terminals use the handshaking lines, and the 
loader rom does
set some control bits that suggest the booting process expects this to take 
place.

But if the BACI board has been 'strapped' for a basic 3-line RS-232 
interface without any
handshaking you can listen for the escape-e and then start sending data in 
the serial format
that's set by the I/O board jumpers (in the I/O hood, not on the board!). 
Pace the serial
data so you don't overrun the CPU, and you will eventually halt at the end 
of the ABS file.

This serial method is slow, and at some point someone needs to really poke 
around inside
the code and the BACI interface manuals and figure out exactly what 
interface strapping
and handshaking was used by HP when the loaded field diags and other 
software using
this cute little tape drives (that almost never work anymore, until you fix 
the rollers and
find that good media is unobtainium).

With that work done, it may be practical to boot your HP over a serial port 
at a reasonable
speed, but loading a large ABS file this way can take a very long time (as 
things are).

I generally don't recommend the serial boot method due to its poor 
performance.
Then again, I think its nothing to throw together a PIC and some I2C eeprom 
and build
little paper tape reader and punch emulators, and I can burn copies of any 
loader rom
you wish.

All that aside, one of my HP's boots from a custom loader rom and an 8-gig 
IDE drive
using a custom controller (so I clearly prefer the hardware solution, build 
your own
peripheral devices).  All the others have the ability to boot from an 
emulated tape reader.
One can also boot from CS/80 disks, another has a 7960E.

Ok, that's ~how~ to get these things up and running, now the hard part. 
What to run?

If you have less than 8K words of memory:

I recommend OCTAPUS-C.
Stripped down IPL kernels exist for 4K machines, but its not very practical 
with less than 8K.

IF you have 8K words only:

I recommend HPBASIC.  This is the 1968 stand-alone interpreter.  Has very 
simple I/O
requirements, and its possible to rebuild HP BASIC for non-standard I/O 
configurations.
It supports a 'TTY' console, as well as a high speed paper tape reader, 
punch, and a
printer.  Requires a 12521-series console interface (HS TERM), does not 
support a
BACI (well, yes, it will, when patched and run from virtual memory under IPL 
on a
21MX machine).

If you have a 21MX machine.

I recommend IPL (HP-IPL/OS).  It was designed to bootstrap HP's lacking 
original
peripherals, and its quite powerful.  Its a (threaded) interpreter, a 
compiler, and has
an assembler as well.

Ideal for blinking lights and reverse engineering device drivers and 
undocumented
I/O boards, etc.

It supports all HP1000 CPU's up to, but not including the A-series.  Modular 
and
extensible, its even got file systems for disk and mag tape, even F-series 
floating
point extensions, 12555 point-plot graphics via DCPC transfers, etc, etc.

Or, you can run RTE, etc.

Personally, I've never had the chance to run RTE, TSB, or any of the 
multi-user
time share systems.  The only reason I don't recommend these is due to my 
own
lack of knowledge and experience.

I 'cut my teeth' on HP's by pulling them out of scrap heaps and 
bootstrapping them
with switches and lights.  I've usually found HP1000's in automated test 
setups, and
virtually never is 'data center' applications, so I tend to see these 
machines as being
computers for Engineers.

But clearly a lot of people had very different exposures to these machines, 
and see
them through very different eyes.  My high school had a PDP-8E that ran a 
4-user
stand-alone BASIC booted from paper tape, not some dual CPU HP rig!