My microcomputer career began in the mid 1970s while attending university,
where a friend and I built and programmed a small 8080 based system.

One of the first "substantial" bits of code I wrote was a tiny editor and
assembler which fit into a 2K (2716) EPROM, and allowed you to enter assembly
text in memory and assemble into a working binary program elsewhere in memory.
This was very primitive: the editor worked with hexidecimal line numbers and
supported only 256 lines. The assembler had no directives other than EQU, DB,
DW and END however it did support the entire 8080 instruction set.

This little package marked the very beginning of my career in embedded
systems development tools.

Source code to this system was cross developed on the university mainframe.
When I acquired my Altair with a floppy disk system, I wrote newer and
better disk based utiities, and never did move the original source code
over to the Altair - when I left the university and my student computer
account was closed, the original tiny editor and assembler were completely
lost, no source code or binaries remained of it (or so I thought).

During my university years, I met and became friends with Henry "Chuck"
Colford. Chuck was a few years ahead of me, and was building an 8085
based system called P.I.M.P.S. (Personal Interactive MicroProcessor System)
as part of his graduate thesis. Chuck liked my editor/assembler, and with
my permission, incorporated it in his project.

When Chuck left the university, the PIMPS system stayed behind. What I
didn't know at the time was that after he left, he built a second system
on his own. Identical to the first design, it included copies of the
original ROMs and my little editor/assembler.

Over 20 years went by and I had all but forgotten about my first software
project, when Chuck stopped in to drop off some other equipment he was
donating to my collection, and said "I brought something else that I want
you to have"... and thats how I was reunited with my long lost code.

As soon as I had the chance, I fired it up, and found myself immersed in
memories of my early computing years. It took me a little while, but I
figured out how to use the long forgotten commands to edit and assemble
a small program.

----------------------------------------------------------------------

This package contains an image of the code ROM from PIMPS, and a command
file for my NorthStar Horizon simulator to reconfigure the I/O to match
the PIMPS system. Although the Horizon uses a Z80 processor, it runs the
8085 PIMPS code perfectly.

To start the PIMPS simulation, execute: HORIZON PIMPS

All information, documentation and source code to this system is long
gone. Using intuition and very vague memories, I have put together a
list of the commands. As far as I can tell, the monitor portion is a
combination of my code and Chucks, while the editor and assembler is
pretty much unchanged from my original (I do recall that I used a '*'
for both the interactive editor prompt, and the assembler comment
directive - Chuck changed these to '->' and ';' respectively. He also
added the 8085 SIM and RIM instructions to the assembler):

A xxxx xxxx   - Assemble (from editor file): origin destination
D xxxx,xxxx   - Dump memory to host port
E             - Enter editor
 A            - Append at end of file
 C            - Clear memory file (reqires ESCAPE to confirm)
 D xx         - Delete line number xx
 I xx         - Insert at line xx
 L xx xx      - List range of lines
 Q            - Query: Display highest used address
 X            - eXit editor (requires ESCAPE to confirm)
 $ xxxx xxxx  - exit directly to assembler
F             - set for Full-duplex host operation
G xxxx        - Go (execute) at address
H             - set for Half-duplex host operation
M xxxx,xxxx   - Display a range of memory (hex dump)
P xx xx-[xx.] - display/Edit I/O Port
S xxxx        - Substitute data into memory
T             - Transparent link to host (Ctrl-A exits)
U             - set host Uart parameters (8251 control registers)
V             - Virtual memory (Not used on PIMPS board)

Notes: (This code is very primitive)

The 'D'ump command outputs memory to the host in some form of Intel
HEX records, and waits for line-feed from the host before proceeding.

The 'V'irtual memory function was to control an EPROM emulator which
was part of the original design (see Chucks notes below) and was not
used on the PIMPS board.

Editor:
 Operates in HEXIDECIMAL line numbers. Only supports up to 256 lines
 (01-00). You must enter full two-digit number when prompted.
 You MUST 'C'lear the memory file before you begin, otherwise you will
 be editing random memory content.

Assembler:
 Comment is an INSTRUCTION! - this means that you need to put at least
 one space before and after ';' when entering a line comment.

 Does not understand DECIMAL numbers. It understands character constants
 ('c' and 'cc') and hex numbers ($xx or $xxxx).

 8-bit values MUST contain two hex digits or one quoted character. 16-bit
 constants MUST contain four hex digits or two quoted characters.

 Use 'S' instead if 'SP', eg: LXI S,$1000

 Only EQU, DB, DW and END directives are supported. An END statement is
 REQUIRED (otherwise you get the message '?tab-ful' as it fills the symbol
 table with garbage occuring in memory after the end of the file).

 RST instructions are implemented as 8 separate 'RST0'-'RST8' memonics.

----- Additional notes on P.I.M.P.S. from Chuck Colford -----
I liked the write-up of the PIMPS system.  Well done.  I have a bit more
info for you...  I used an STD bus chassis for my thesis (not a SBC kit as
I told you).  I really liked the STD bus - simple, standard and easy to
expand.  It was newer than the S100, but more Intel'ish (i.e. synchronous)
and lighter weight than the VME bus that followed.  The university had
chassis, processor, memory and I/O cards, but they were not really as well
used as they could have been, largely because they lacked an environment
and toolset to do more.  While most folks beat their brains out working on
IEEE-488 (or back then called HPIB, GPIB) bus projects, everyone suffered
the slings and arrows of long edit-assemble-download-burn-test cycles.

I took a different approach and scrounged the STD buss hardware and built
a ROMulator card that emulated a 2716 or 2732 EPROM.  This gave you the
ability to load code into pseudo ROM that would plug into a target without
the hour+ long process of UV erase, wait for the DataIO programmer to burn
to test an image (remember those days).  My original design focused on the
hardware and a monitor that would allow the user to talk to the mainframe to
store and retrieve images and to map those into RAM that could be connected
to a target via umbilical cables.  To make this work stand alone, on the
ROMulator card, I included a programmable register that allowed the code to
be mapped to a desired STD bus RAM address space, even though it would be
seen as absolute address $0000 when the umbilical was plugged into a target
system.  When I ported the code over to my PIMPS board, those commands just
came along, but obviously the ROMulator register and EPROM umbilical cables
did not.  The design actually allowed multiple ROMulator cards to be run
from a single chassis so that you could provide code to multiple target
ROMs or systems at once.

When I saw your software, it was so cool, I was glad you let me include it.
Now instead of being dependant on the mainframe (which we talked to at no
more than 300 baud), you could edit and assemble it right there on the STD
system rather than having to go back to the mainframe and do an
edit-assemble cycle, download to the DataIO, etc., all of which all took
forever back then.  This was way cool back then - No floppies to boot up,
no drives.  Just instant on, and go.  You sure know how to build software
small and fast!  It worked and people used it!

Rather than just being some interesting look what could be done or a
technology showcase, other people desperate to get their projects done
against hard deadlines used your software and my hardware to complete their
own work.  They only burned the ROM after they had it working.  Real
problem solvers!  I think we were ahead of our time.
