CRISS CP/M Provides Modern Hardware For A Classic OS

Today you might choose run Windows, Linux, MacOS or some other OS on your computer. Back in the 1980s however, you generally had little choice: a certain home computer came with a certain OS, and that was it. If yours was based on a Z80 processor, chances are it ran CP/M. While differences in hardware often made direct data exchange difficult, CP/M provided at least a basic level of software compatibility between various Z80-based computers. Although eventually supplanted by MS-DOS (which initially aimed to be compatible with CP/M), enthusiasts kept the classic OS running on old hardware throughout the 90s and even beyond.

[Igor] decided to make a 21st-century CP/M machine by designing the CRISS, a single-board computer based mainly on AVR microcontrollers. The CPU is a 20 MHz ATMEGA1284P, which imitates a 4 MHz Z80 through machine-code emulation. A pair of ATMEGA328s run the peripheral controller and a VGA output, so the CRISS can be used with modern monitors. True to its heritage however, the image is monochrome green-on-black, looking instantly familiar to users of Kaypros, Osbornes and other contemporary CP/M machines.

Software is loaded through an SD card that holds floppy images. The CRISS can directly run programs written for the Kaypro II and Robotron 1715 computers, although other platforms can be supported as well with a software upgrade. [Igor] shows it running programs ranging from the Turbo Pascal compiler to games like Xonix and Tetris.

Housed in a neat little case, the CRISS can communicate with standard PS/2 keyboards and serial printers. Even an Ethernet port is provided for those willing to experiment with network connectivity (a rare feature in the 1980s).

We love seeing modern retro builds like this; similar projects we’ve covered before include the compact ZZ80MB and the huge Z20X. Others have used different ways of running CP/M on modern hardware, such as booting it directly on a Raspberry Pi or emulating an Altair on an ESP32.

28 thoughts on “CRISS CP/M Provides Modern Hardware For A Classic OS

    1. I lusted after that around 1981 but held out until 1985 and got an Amiga 1000. AmigaOS wasn’t as much like UNIX, but once you’ve seen the large flat address space of the 68000 you can never go back to ~the~farm~ 64k again.

    1. That’s because it was made for a magazine article.
      Probably like academic publications. You can’t put it in a public place, but you can write the author and he’s allowed to send you a copy.

      However, even in the project page, the author offers only schematic and BOM, but doesn’t mention source code for the Z/80 emulator or the other two micros used for VGA and peripheral controls.

      1. Could this be the source code, or at least some of it ? https://github.com/mastmees/z-two

        “CP/M machine with Z80 emulated on ATMega

        See project page at http://www.nomad.ee/micros/z-two/ for full story.

        Z-Two runs about 110000 Z80 instructions per second on emulator running on ATMega1284p, and is fully functional CP/M machine, albeit a slow one. It uses SD card as storage (maxed out disk space for CP/M, 16x8MB drives), VGA monitor (80×30 text) and PS/2 keyboard. There is a serial port with USB-Serial converter for getting data in and out of the machine.”

        1. Ok read both Z-one and Z-two projects. Z-one was done BEFORE Z-two and was focusing upon using a true Z80 driving I/O ports through an ATMega1284P. Z-two is based upon Z-one but with the Z80 emulation inside the AVR chip. As we know, it is even slower than Z-one (where the limitation is Z80 should not above 4.6MHz because “I/O through AVR will be 3x slower than at 4.6MHz!”).

      2. Source codes are publishing now on the Github, work is in the progress and in short they will be available. If you need it immediately just let me know :) All firmware files are open for downloading from the http://www.criss.fun, PCB and schematic are published on the project page. Step-by-step I’ll add all information to the project page, check it time to time. Thanks!

  1. First of all — the distance between mains and signal lines on PCB creeps me out. Pun intended.

    But seriously, I’d really like to see what ATtiny13 is doing in the VGA department. Looks like it provides timing with a simple assembly code doing nops and outs, but I may be wrong.

    1. A modern 20MHz ZiLOG CMOS Z80 is about €/$/£12* for the CPU alone and uses 100 mA** at 5V and then you need to add all the other required chips to do anything useful, like RAM and (EEP)ROM and IO chips.

      An Microchip ATMega1284p costs about €/$/£5 for the CPU which includes 16K x 8 RAM, 4K x 8 EEPROM and 128KB (64K x 16) FLASH which can be powered from 1.8V (4MHz) ~ 5.5V (20MHz @ 4.5V or higher) and uses a maximum of 200mA when clocked at 20MHz.

      Both will use a 512KB SRAM chip (AS6C4008) at about €/$/£5

      But the reality is, that in emulation it will be at peak a 4.6MHz Z80. If running code like: https://github.com/mastmees/z-two

      But emulation does have the advantage that someone who loves the 6052 could use the exact same hardware for their project. And a third personcould say screw the emulation I’ll use the ATMega1284p for my CPU.

      * a 10MHz ZiLOG CMOS Z80 is about €/$/£6
      ** the lower cost NMOS part is 200mA

    2. There are two main reasons: AVR is not only just CPU emulator, but also SD-card controller, DMA etc., it does a lot of useful things except emulation. The second reason is that the command set was enhanced with the int MUL, DIV and 4-byte floating-point commands, that would be impossible with the hardware Z80. Z80 was used as a donor for the command set, I love z80 assembler. The goal was to build modern computer, there was no idea to build z80 CPU-based one :) Thanks!

  2. That project is supposedly to be open source, right? so why there is no link to source? I’m very curious about how it is able to run an equivalent 4MHz Z80 on a 20MHz AVR. Usually, you cannot achieve above 1MHz Z80 emulation with an Arduino MEGA (16MHz). A lot of source is missing in the project page.

  3. My Atrix-7 student FPGA board would be better for implementing a Z80 CP/M computer. Has a USB port handled by a PIC microprocessor so that to the FPGA (via an IP library module) can be programmed as a PS/2 device. Then has several pmod connectors where can plug in, say, a PS/2 pmod board (now can have a USB device that acts like a PS/2 device and then a PS/2 port/device), then could also plug in, say, a COM serial port pmod board, and there’s a built in VGA port where can implement VGA on the FPGA (which is straightforward to adapt to HDMI). And has a SD card for persistence storage (and there’s still one more available pmod connector to do something with)

    Another FPGA board I have cost only $65 brand new, has one pmod connector and a VGA output, so it too would be completely adequate for implementing a CP/M computer similar to this one as it was described.

    Advantage of FPGA implementation is when get bored with CP/M, can then load a RISC-V CPU implementation and play around with that. Have seen a YT video where an Atrix-7 board is running Linux with a GUI all executing on 32-bit RISC-V

    So could step back into pre-history and explore ancient CP/M and then turn around and play in the modern world via RISC-V

Leave a Reply to Alex Cancel reply

Please be kind and respectful to help make the comments section excellent. (Comment Policy)

This site uses Akismet to reduce spam. Learn how your comment data is processed.