cpm

Retrocomputing is an enjoyable and educational pursuit and — of course — there are a variety of emulators that can let you use and program a slew of old computers. However, there’s something attractive about avoiding booting a modern operating system and then emulating an older system on top of it. Part of it is just aesthetics, and of course the real retrocomputing happens on retro hardware. However, as a practical matter, retrocomptuters break, and with emulation, you’d assume that CPU cycles spent on the host operating system (and other programs running in the background) will take away from the target retrocomputer.

If you want to try booting a “bare metal” Z80 emulator with CP/M on a Raspberry Pi, you can try EMUZ80 RPI. The files reside on an SD card and the Pi directly boots it, avoiding any Linux OS (like Raspian). It’s available for the Raspberry Pi Model B, A+, and the Raspberry Pi 2 Model B. Unlike the significant boot times of the standard Linux distros on the earliest models of Pi, you can boot into CP/M in just five seconds. Just like the old days.

The secret to this development is an open source system known as Ultibo, a framework based on Open Pascal which allows you to create bare metal applications for the Raspberry Pi. The choice of Free Pascal will delight some and annoy others, depending on your predilections. Ultibo is still very much in active development, but the most common functions are already there; you can write to the framebuffer, read USB keyboards, and write to a serial port. That’s all you really need to make your own emulator or write your own Doom clone. You can see a video about Ultibo (the first of a series) below.

What do you do when you decide that running CP/M on a Commodore 128 with a 5.25″ drive “Isn’t CP/M enough”? If you are [Chris Osborn], you reach for your trusty TRS-80 Model II, with its much more CP/M-appropriate 8″ drive.

There was one small snag with the TRS-80 though, its keyboard didn’t work. It’s a capacitive device, meaning that instead of each key activating a switch, it contains a capacitive sensor activated by a piece of aluminized Mylar film on a piece of foam. Nearly four decades of decay had left the foam in [Chris]’s example sadly deflated, leaving the keys unable to perform. Not a problem, he cast around for modern alternatives and crafted replacements from a combination of foam weather strip and metalized gift wrap.

Care had to be taken to ensure that the non-metalized side of the gift wrap faced the capacitive sensor pads, and that the weather strip used had the right thickness to adequately fill the gap. But the result was a keyboard that worked, and for a lot less outlay and effort than he’d expected. We would guess that this will be a very useful technique for owners of other period machines with similar keyboards.

What is CP/M, I hear you ask? Before there was Linux, Windows, and MacOS, there was DOS, and before DOS, there was CP/M. In the 1970s this was the go-to desktop operating system, running on machines powered by Intel’s 8080 and its derivatives like the Zilog Z80 in the TRS-80. When IBM needed an OS for their new PC they initially courted CP/M creators Digital Research, but eventually they hired a small software company called Microsoft instead, and the rest is history. Digital Research continued producing CP/M and its derivatives, as well as an MS-DOS clone and the GEM GUI that may be familiar to Atari ST owners, but were eventually absorbed into Novell in the 1990s.

[M] recently tipped us off about hacker [Lumir Vanek] from the Czech Republic. Between 1985 and 1989, [Lumir] built his own home brew, Z80 based computer. The list of home computers available in the 1980’s is extensive. Those living in western Europe and the Americas could choose offerings from Acorn, Apple, Commodore, Atari, Radio Shack, and Sinclair Research to name just a few. Even the erstwhile Czechoslovakia had home computers available from Didaktik and Tesla.

[Lumir]’s built was based around the Z80 processor and is built using regular, double-sided, prototyping board. It featured the 8-bit Z80 processor CPU, 8kB EPROM with monitor and BASIC, two Z80 CTC timers, an 8255 parallel interface for keyboard and external connector, 64kB DRAM, and Video output in black & white, 40×25 characters, connected to a TV. The enclosure is completely made from copper clad laminate. [Lumir] documented the schematics, but there is no board layout – since the whole thing was discrete wired. He even built the membrane keyboard – describing it as “layers of cuprextit, gum, paper with painted keys and transparent film”. When he ran out of space on the main board, he built an expansion board. This had an 8251 serial interface for cassette deck, one 8-bit D/A converter, and an 8255 parallel port connected to the “one pin” BT100 printer.

On the software side, he wrote his own monitor program, which allowed simple interactions, such as displaying and modifying registers, memory, I/O ports and to run programs. He wrote this from scratch referring to the Z80 instruction set for help. Later he added a CP/M emulator. Since the Z80 had dual registers, one was used for user interaction, while the other was reserved to allow background printing. Eventually, he even managed to port BASIC to his system.

It appears a very important anniversary passed by recently without anyone realizing. The January 1975 issue of Popular Electronics featured the Altair 8800 on the cover, otherwise known as the blinky box that launched a revolution, the machine that made Microsoft a software powerhouse, and the progenitor of the S-100 bus. The 40-year anniversary of the Altair wasn’t forgotten by [dankar], who built a front panel emulator with the help of some much more modern components.

The build unofficially began with an Intel 8080 emulator written for an Arduino. The 8080 is the brains of the Altair, and while emulators are cool, they don’t have the nerd cred of a panel of switches and LEDs. The hardware began as a bunch of perfboard, but [dankar] wired himself into a corner and decided to make a real schematic and PCB in KiCAD.

Despite the banks of LEDs and switches, there really isn’t much to this front panel. Everything is controlled by shift registers, but there is a small amount of SRAM in the form of an SPI-capable 23LC1024. This comes in handy, because [dankar] is running CP/M 2.2 on this front panel emulator from disk images saved on an SD card. Everything you would want from a computer from 1975 is there; an OS, BASIC, and enough I/O to attach some peripherals.

[Gary Kildall] and CP/M are the great ‘also ran’ of the computing world; CP/M could run on thousands of different 1980s computers, and [Gary] saw a few million in revenue each year thanks to CP/M’s popularity. Microsoft, DOS, and circumstances have relegated [Kildall] and CP/M to a rather long footnote in the history of microcomputers, but that doesn’t mean CP/M is completely dead yet. [Marcelo] wrote a Z80 emulator running CP/M inside an Arduino Due, and he did it in such a way that it’s actually convenient and useful to use.

Instead of using CP/M disk images, [Marcelo]’s emulator emulates CP/M disk drives on top of a regular FAT file system. Drives are mapped to folders in the FAT file system, so a folder named ‘A’ will show up as the A: disk in CP/M. Drives up to P: are supported, the maximum number of drives available under CP/M. The BIOS resides in the root directory of the SD card, and so far Microsoft Basic, Turbo Pascal, UCD Micromumps, and Wordstar work just fine.

The Arduino project was built upon one of [Marcelo]’s earlier projects that put the CP/M emulator on Windows. The version for the Due works exactly how you think it would, with a serial connection and terminal emulator providing the IO, and the huge amount of processing power and RAM available on the Due doing all the heavy lifting.

As an adventure in computer history, [Len] built up a clock. The Z80 Micro TV Clock brings together a homebrew computer and three Micro TVs into a rather large timepiece.

The computer powering the clock runs the CP/M operating system. This OS was eventually released as open source software, and a variety of homebrew computer projects have implemented it. This clock is based on an existing breadboard CP/M machine, which includes schematics and software.

With an OS running, [Len] got a text editor and C compiler working. Now custom software could be written for the device. Software was written to interact with a Maxim DS12885 Real Time Clock, which keeps the time, and to output the time to the display controllers.

The Micro TVs in this build are Sony Watchman displays featuring a 2″ CRT. The devices had no video input port, so [Len] ripped them open and started poking around. The NTSC signal was found by probing the board and looking for the right waveform.

To drive the TVs from CP/M, a custom video driver was built. This uses three relatively modern ATmega328P microcontrollers and the arduino-tvout library. All of these components are brought together on a stand made from wood and copper tubing, making it a functional as a desk top clock

To celebrate the 40th anniversary of CP/M, the Computer History Museum has released a package containing early source code for several versions of CP/M. Originally designed by [Gary Kildall] in 1973, Control Program for Microcomputers (CP/M) is an early operating system for microprocessor based computers. The OS was originally written for the Intel Intellec 8, an Intel 8008 based computer. Since it was on an Intel machine, CP/M was written in PL/M (Programming Language for Microcomputers), a language [Kildall] had previously developed for Intel .

CP/M pioneered the idea of a ROM based Basic Input Output/System (BIOS) for commonly used routines on a given computer. The use of BIOS made CP/M easy to port. Eventually it was ported to thousands of different machines and architectures, including the Altair, IMSAI 8080, C-64, and C-128 and Apple II systems.

Gary and his company Digital Research, were one of the top contenders for the operating system on IBM’s new personal computer. Ultimately, Microsoft got the job by purchasing 86-DOS from Seattle Computer Products. Somewhat ironically, 86-DOS itself was written based on the CP/M Application Programming interface (API).

The source itself is an amazing trip back in time. Included are portions of CP/M 1.1, 1.3, 1.4, and 2.0. Portions of CP/M have been released previously. As with the previous files, this version includes modifications performed by z80-pack author [Udo Munk] in 2007. Version 1.3 is especially interesting as it is primarily scanned copies of the CP/M source code.

If you’re into vintage computing, and know how important CP/M was to the early days of personal computers, check out the CP/M source. If you find any interesting or clever bits of code, be sure let us know about it in the comments.