This is the main landing page for Rob's 1970's and 1980's Retro-Computing Archive site on GitHub and its various repositories. No A.I was used in the creation of these historical writings and recollections of RCL9.

This repository contains a snapshot of some of my more interesting projects from the 1970's to late 1980's which I can say that I had actually built myself. I do have other interesting hardware projects but some of them were not built by me originally. This will provide you with a bit more visual context as to what type and extent of projects I used to build before getting distracted with a professional career in similar activities. Almost all of these documented projects are from the first 24 years of my life. You may also be interested to read over my Where and How Did it all Start? section and its associated photo montages.

This repository contains new firmware & related Z80 source code for the Multiflex Z80 Video Display Terminal Kit (previously sold by Exceltronix of Toronto Canada in 1984) which adds a plethora of new features and functionality, including new H19/VT52 terminal emulation support. The original stock firmware which came with the terminal in the early 1980s was quite primitive at best, only providing very basic text sending and receiving functionality.

If you are an owner of one of these 1984-era Multiflex terminals then you'll want to read over this overview, dust off your old hardware and install my new firmware ROM to give it new life.

This repository documents my "Colossus Control Computer" which was my main go-to development machine ("It has every feature including the kitchen sink") that was started in March 1985. I call it a "beast of a Z80 machine" because it has more odds and ends + add-on gadgets than with most self-built computers. It was also the test bed and development platform for my follow-on March 1987 Phoenix MIDI Processor Computer. An interesting sub-project for Colossus was my Dec 1985 Drum Pad Triggers for a MIDI Drum Machine.

The repository also contains the schematics and Z80 assembly source code to: (1) my Z80 custom monitor, (2) an extensive Votrax SC-01 speech synthesizer driver & 'text to speech' converter, (3) a Hitachi HD44780 LCD driver, (4) the game of 'Simon' for my corresponding hardware device, (5) a slimmed down version of the XMODEM protocol for inclusion into the monitor ROM and (6) a very simple D/A music waveform generator.

For those wanting to build a Z80 computer, this repo can help teach you:

• How to design, wire, scan and map an ASCII keyboard (using an Intel 8279 is a keyboard and display controller) + numeric keypad for data entry.
• How to interface a Hitachi HD44780 LCD to the Z80 bus and provide data access.
• How to design, build and drive an 8 segment LED display.
• How to design, build and interface with 1MB of DRAM as 64k banked memory segments.
• How to design, build and interface with a 58167 real time clock chip.
• How to interace with a 8 channel, 8-bit multiplexed analog-to-digital converter based on the TI ADC0809.
• How to interface the Votrax SC-01 speech synthesizer to the Z80 bus + drive it interactively with mapping tables.
• How to build a WD2797-based floppy drive controller system + Z80 driver code.
• How to create an interrupt and queue driven MIDI/RS-232 buffering mechanism based on the Z80 SIO chip.
• How to do I/O port decoding using an Abel logic file for a PAL16L8.
• How to interface to the Roland M-16C and M-64C synthesizer memory cartridges.
• And additional design notes for the 8253 timer, Z80 CTC timer, Z80 PIO, 8255 PIO and 8253 baud rate generator.

This repository documents my Z80-based "Phoenix MIDI Processor Computer" which is the successor and more refined version of my 1985-era Colossus Control Computer (1985-1987). The presented material can be useful as a teaching aid for:

• Learning how to integrate low-level Z80 assembler code along with Aztec C high-level code, all within a static ROM.
• Learning how to design and build a MIDI-centric data processing system, including the usage of its well tested interrupt and queue driven MIDI/RS-232 buffering mechanisms.
• Learning how to write real time MIDI processing C-code routines supported by a lower level Z80 framework.
• Learning how to use a LCD interface & keypad for restricted user interface interactions.

The full intent and focus of this custom computer was to act as a "MIDI stream processor" which has these basic processing capabilities (written in Aztec C code):

• Real time MIDI data analyzer with filtering
• Display active MIDI channels
• Display highest and lowest notes of each MIDI channel
• Casio CZ-series, Roland TR-707 drum machine & Yamaha Tx-81Z patch librarian

This repository explains how I created the custom numeric keypad for my Phoenix MIDI Processor and how the animated "Cylon Eye" (inspired from Battlestar Galatica) was implemented in hardware + Z80 assembly code.

This repository documents my 1983-84 era S-100 card design which interfaced my Exidy Sorcerer to a traditional rotary-dial telephone (using relays and reed switches). My goal was to create an "automated telephone answering service" using a Votrax SC-01 speech synthesizer and SN76489 sound generators for the "beeps and boops". Outgoing DTMF tone dialing was provided via a MK5086 tone generator. The board also contains dual linear joysticks, a real time clock module and one of my "Universal I/O Ports".

This repository documents a sub-project I designed and built in December 1985 to simulate SIMMONS electronic drum pads, "on the cheap" ($20 in parts compared to $1500). The intent was to design a physical drum pad interface that would provide digital triggers to my then-new Colossus Computer Computer which itself would create MIDI messages for a Roland TR-707 drum machine. Schematics and "piezo drum trigger analysis" charts are provided for those considering to build their own similar mechanisms.

This repository strives to provide a historical snapshot, archive and description of the short lived Cypher Z80/68000 single board computer which was designed, built and sold by Motel Computers of Willowdale Ontario in the 1984-86 era. It was believed at the time that CP/M-based computers would (ideally) remain the dominant operating system well into the early to mid 1980s. The Cypher SBC arrived in the 1983-1984 era when CP/M-68k and 68000 CPUs were becoming more readily available. What the designers of the Cypher computer did not foresee was the rise and dominance of the IBM PC, DOS and 8086 processors which would have been a prime reason that the company disbanded the project in 1986. Tech manuals, schematics, historical advertisements and a history of Motel Computers is provided.

This repository documents the thought and build process of a new supporting structure to hold all of the components of the 1984-era Motel Computers Cypher Z80/68000 SBC.

This repository documents the hardware expansion board that I had designed and built for the Motel Computers Cypher Z80/68000 SBC in 1986. This includes schematics for a "Universal I/O Parallel Port", a SASI hard disk controller interface and a SCSI bus interface.

This repository documents the rather simple port organizer and break-out box that I had designed and built for the Motel Computers Cypher Z80/68000 SBC in 1985.

This repository documents a universal EPROM plug-in emulator which I designed and built in July 1985, including the schematics and Z80 driver code.

This repository documents a variation made by me of the "OMNI-Prom" programmer outlined in the April 1983 issue of 80 Microcomputing with new software written in both Z80 assembler and a follow-on version written for Aztec-C. With the 5 personality modules, the programmer could handle 2704, 2708, 2716, 2732/2532, 2732A/462732, 2764, 27128 and 27256 EPROMs.

This repository documents a variation of the ZAP-A-PAL programmer that I designed and built in May 1987, including the schematics and C + Z80 user interface code.

This repository was written as a historical "book end" to my decade of hardware and software development, being the first computer-based electronics device I built in August 1979. This snapshot contains the hardware schematics plus BASIC + Z80 assembler code to the game of SIMON.

By 1987 I was getting pretty good at making a professional looking product and hence came up with the idea of making a flexible breadboard prototyping station. This repository acts as another one of my "book ends" to justify the time and effort I took into making this device back in the day just in case it may inspire others to make something similar.

This repo also contains the only known copy of the Tabuchi Electronics (Japan) TR095 switched mode power supply schematics of the 1978 era.

This important repository explains in detail how to create CP/M boot disks from scratch in the IMG, IMD and HFE file formats from a collection of files on a PC computer. In particular it handles the case of "mixed-mode track geometry" whereby track 0 is in single density (FM) and tracks 1+ are in double density (MFM). For this tutorial the target is the Morrow DiskJockey 2D disk controller (attached to a HxC 8" floppy disk emulator) on an Exidy Sorcerer computer with an S-100 expansion bus. The provided script will also insert from a number of provided system boot images for this hardware setup. The series of documented operations were quite tricky to get working over a period of two months.

This repository explains how to boot from CP/M-3 via the HxC Floppy Emulator attached to the floppy disk controller interface connector of the 1985-era Motel Computers Cypher Z80/68000 SBC. This will allow the Cypher SBC to boot from the floppy emulator rather than its stock 8" floppy disks or 22MB hard disk.

This repository documents how to rebuild a CP/M 2.2 "SYSGEN" image, from scratch, for the Morrow DISK JOCKEY 2D S-100 8" floppy disk drive controller card. In particular, the image will be set up for the Exidy Sorcerer variation whereby the DJ2D's ROM firmware is located at D000H instead of the standard E000H.

This repository is an important historical compendium and snapshot of technical information plus personal experiences with the Morrow DISK JOCKEY 2D Floppy Disk Controller card for the S-100 Bus (1981 era). It explains (1) how it and my other hardware was recapped and made stable (Exidy Sorcerer, Exidy S-100 Box and six 8in floppy drive controller cards) (2) how to connect it to a HxC floppy emulator, (3) how to use 50pin to 36pin Shugart cable adapters (such as the "fd50to34" board and one of my own design + Excel spreadsheet signal mapping), (4) PROM captures from the card, (5) the original CP/M distribution disks and (6) other "need to know" technical information about the card + its disk format layout and access via CPMTools + 32-bit ImageDisk.

This repository provides a historical and archival overview of the 1983-era "Light Speed 100" (LS-100) 256k S-100 RAMdisk board produced by Digital Research Computers. This archive also provides a custom BIOS which tightly integrates the card as a virtual floppy disk drive for the Exidy Sorcerer computer running CP/M 2.2 with the Morrow Disk Jockey 2D S-100 controller card. Beyond this archive there is little online information about this card and no orignal runtime software or source code.

This repository captures my experience with retrieving and archiving early 1980's Exidy Sorcerer data tapes and directly converting them to binary, Exidy Sorcerer .tape format and related de-blocked text files using the TapeTool2 utility program. If I had access to this repo before starting my project then it would have saved me a good day or two of head banging and head scratching.

However, much more importantly for an Exidy Sorcerer user (or other retro-computer enthusiasts) reading this tutorial, I provide a well defined batch script file named "convert.bat" which will quickly convert a 300 or 1200 baud .wav file into a corresponding binary (for CP/M usage) and .tape file (for jSorcerer or MAME usage). Other sites on the Internet often provide dozens of 1980s software downloads in .wav audio file format but no simple method to convert them into runnable files for the Sorcerer.

This repository provides a useful (and relatively simple) command line utility program to overlay Intel HEX files ( the boot code, the CCP, BDOS and/or CBIOS) on top of a pre-existing CP/M 2.2 SYSGEN image file. The HEX files are generated from M80.com and MAC.com from a running copy of CP/M which is documented in this associated repository.

This repository:

• Provides a visual snapshot of my Exidy Sorcerer computer system
• Justifies why I purchased it over an Apple II, TRS-80, PET and IMSAI 8080
• Enumerates why the basic system cost me $18,262 (in today's dollars. Yikes!)
• Compares those costs to equivalent 1979-era computers
• Compares those costs to 1985 and 1991 IBM PC machines ($21,500 for a basic system!)
• Mentions the explosion of popularity of the machine in the Nethderlands and Australia, (7) explains some of my machine hardware modifications and,
• Provides a succinct "See also" section to other Exidy Sorcerer computer information and file respository sites.

Additionally 19 screen snapshots of the original two Exidy Inc. demo programs from 1979 are inlined, which had impressed me back in the day to purchase the Sorcerer.

This repository provides a photo tutorial about how to replace the original Exidy Sorcerer's (version 1) linear power supply with a modern switched mode supply, hidden within the original case. This is a relatively tricky procedure to implement.

This repository explains and documents how I ported the actual Tandy TRS-80 Model I "Level II BASIC" (in 1981-83) so that .trs BASIC files could be run "out of the box" on the Exidy Sorcerer computer with little or no modifications. It is not an emulator but rather the real 12k BASIC-in-ROM running on the Sorcerer. A fully operational system + example TRS-80 .trs BASIC programs are being provided in this repo so that you can run the same code today on a real Exidy Sorcerer (incl. with CP/M 2.2) and/or within the MAME emulator running the Dreamdisk CP/M 2.2 system.

This was not a simple 1:1 "port". The most useful addition was the inclusion of the DIR, DLOAD and DSAVE commands which provide CP/M disk support to view a disk directory, load in a .trs BASIC file or save out to a .trs BASIC file. 14 new or modified commands were also added: APPEND, CALL(x), CLOAD, CSAVE, INKEY$, KEY, OLD, PADL(x), PEEK(x), POKE(x), SET/RESET, SOUND(x) and TEXT(x). The development, coding and debugging was done entirely by hand (back in the day) on lined paper in machine language and using a hex editor. It took years of effort and fiddling.

This repository seeks to document my 1981-era method of porting TRS-80 Model I machine language software (namely games) over to the Exidy Sorcerer computer. In essense it is a fairly simple process when presented properly. It also provides a hardware level modification to the Sorcerer.

This repository was created to "market" or make more people aware of my customized PacBasic work of 1981 which added CP/M disk I/O commands to the stock Exidy Sorcerer 8k BASIC-in-ROM. To this very day retro-computing people still struggle to run Rom-Pac 8k BASIC programs on their real or emulated Exidy Sorcerer machines by way of data cassette file loading. It only took 45+ years to get this into the hands of the retro-computing community.

This repository contains my personal curated and notarized collection of ~180 Exidy 8k BASIC programs from the 1979 to ~1982 era which run under my customized PacBasic.com program. I had typed in these programs from books and magazines (over endless years of my life), ported them from the PET computer, ported them from the TRS-80 computer or written them myself.

This repository encapsulates my personal experience and notes as how to set up the well known MAME emulator for the Exidy Sorcerer and the Dreamdisk floppy disk system running CP/M 2.2 (and some info about how to do the same for the Exidy Micropolis FDC). It will also explain how to transfer files from a PC computer to a MAME .mfi CP/M disk image (and back again) with ease. A latter section explains how a single PC-bound file can be quickly loaded into the emulator without first going through a CP/M disk image file. I wish I had access to this tutorial from the get-go as it would have saved me a fair bit of time to figure out these finer details.

This repository acts to document and rebuild the mental history, the development history and the final outcome of my two years of writing Space Invaders for the Exidy Sorcerer during 1980 and 1981, primarily in the little known BASEX programming language for Z80.

It also provides a good snapshot of the "Psychology and Reality of Game Development in 1980" from my personal perspective with access to no code or text editor, no debugger, no disk operating system and doing all programming on lined paper with backups to 1200 baud cassette data tapes.

This repository documents a hardware modification I made to my Exidy Sorcerer in 1981 to increase its clock rate from 2Mhz to 3.16Mhz, switchable.

This is a significant historical repository in the world of retro-computing. Over the last 40 years I have not seen any hand's-on tear downs or reverse engineering of the super-rare Exidy Multi-Net 80 "User Module" S-100 card nor one which has been hacked and repurposed as a stand-alone MIDI processor board (as I have done herein).

I decided to reverse engineer the board on November 17 and 18 1984, write a new monitor system for it, then eventually develop a daughter card to give it RS-232 and MIDI capabilities. This repository documents those endeavors for the current and future benefit of the retro-computing community.

This repository provides a series of in-depth explanations and tutorials describing the internals of the Exidy Standard 8k RomPac BASIC and how to control those internals. It is based on the two years of disassembling the BASIC starting in 1980.

This repository is a complete archive of the 'Port FE' Exidy Sorcerers Users' Group of Toronto newsletters from June 1979 through to the final issue published in December 1982. I was a technical co-editor of the newsletter. I have cleaned them up a bit and made them text-searchble.

This repository acts as a tribute and time capsule to the long lost BASEX compiler of the 1979 era of early computing written by Paul K. Warme (retired accountant from State College, PA) as a faster byte-code interpreted version of BASIC that ran on the 8080 and Z80 platforms. This history came about from my work to resurrect the complete runtime environment and development history of my Exidy Sorcerer "Space Invaders" game of 1980-81, written in BASEX.

This repository documents the early history as how computer music and sounds effects were generated on early home computers in the late 1970's and early 1980's, notably via 6-bit D/A boards with a focus on the Arrington, Newtech, Northamerican & ZYTEK commercial boards. It also briefly touches upon using the cassette data port of the TRS-80 Model I computer to output sound effects.

11 magazine references are also provided which extensively document computer music generation via these D/A hardware boards and methods. This was all the rage during the first five years of the home computing era (1975-1980).

This repository provides a newly available Z80/8080-based playback system for the 1980-era ALF Music Card MC1 (Apple Music II) files. This is a unique, *gem* of a system that has been hiding on my CP/M 8" disks for 40 years that deserves its spotlight in the retro-computing community. I consider this repository a "gift" for current and future retro-computing enthusiasts who are need of a more complex hosting mechanism to play native ALF chip-tune music files on their 76489 based music synthesis system running on a Z80/8080 computer.

This repository was written as a historical book-end to my 10 year fixation with computer music synthesis design, with this short and simple summary focusing on the generation of rudimentary computer music played through an AM radio in the mid to late 1970s via RF noise emitted by the CPU. Source code and data files are provided for both Z80/8080 and PDP-8 computers.

This repository documents the source code and related visual screen snapshots to a number of grades 9-12 educational math programs I wrote for the Commodore PET computer in 1982. At the time I was more of an Exidy Sorcerer + CP/M 2.2 sort of person but I was still well versed in PET programming, 6502 PET binary program reverse engineering, TRS-80 programming, etc.

This repository documents the unique and custom build of the 'Missile-Bot Commando' robot based on LEGO Technic, a 6811 HandyBoard SBC, two Wii controllers, Bluetooth + RS-232 communications and a Windows host controller computer.

This repository documents the evolution and custom development build of a flip-up 'Surveillance Garbage Can' based on a 6811 HandyBoard SBC and various LEGO Technic motors and related pieces.

This respository aims to expand upon the publicly available history for Jud Newell's "Mississauga RCP/M", "Toronto RCP/M" and "Canada Remote Systems" bulletin board (BBS) systems, starting from 1977. This history is partly from my personal experience as one of Jud Newell's first users of his "Mississauga RCP/M" (located in his home) as of February 1982. I have derived the factual information from the original 1985-1991 Canada Remote Systems (CRS) member newsletters from my personal collection.

This links to my SoundCloud account which documents my 1986-1989 synth music sequencing done in conjunction with the MIDI hardware devices documented in this Retro-Computing GitHub archive site, along with my Roland JX8P, Yamaha TX-81Z, Casio CZ-5000 and Yamaha SPX-90 effects processor (which are now departed from my collection).

This repository documents two designs for a programmable RAM cartridge for the Roland JX8P synthesizer which I had designed and built in late 1985. Prior to this design my only option would have been to buy an expensive Roland MC-16C Memory Cartridge which held just 16 patches. With my new design, the single plug-in cartridge could handle 256 patches and be programmed by an external computer such as the special cartridge slot I designed into my Colossus Control Computer.

This repository contains 15 Roland JX8P synthesizer patch banks, with up to 32 voices per bank, which were collected or created by me between 1985 and 1989.