Let me introduce: PMI-80 SBC

PMI-80, 1982 Czechoslovakia single-board 8080 computer, photo by Teslaton under CC-BY-SA

A single board computer was a small computer that fit on one board in the 70s and 80s. Nowadays you can fit a lot of things on one board, but back then you couldn't jump around too much. Mostly you could fit a processor, a bit of memory (typically 1 kB RAM, 1 kB PROM), a keyboard (it usually had about 20-25 keys: 16 characters 0-9 and A-F for entering hexadecimal digits, and a few control keys), a display (made of seven-segment keys), and some I/O ports that were either available for expansion or had various LEDs, motors, and the like on them. Kind of like the famous KIM-1, TEC-1, etc.

In Czechoslovakia in the 1980s, two of the better known single board computers (and a few others, now forgotten) were produced: the legendary PMI-80 and the TEMS 80-03A school single board computer. Both with the 8080A processor and plus or minus the same technical equipment. Several single-board computers were also created by enthusiasts (BOB85, SAVIA84), they were also created as kits (Petr)... Technically speaking, other home computers of that time were also single-board computers - Spectrum, ZX-81 and Commodore, but for us, a single-board computer with a limited keyboard and a seven-segment display.

The KIM-1, a single-board computer from MOS Technology with a 6502 processor, was probably the most popular in the world. A "lightweight" version of the Junior Computer was also produced. Other interesting single board computers were the Cosmac Elf or the Heathkit ET3400.


It's very well documented, mainly thanks to a series of articles in Amateur Radio (a magazine for electronic designers). In addition to the 8080A processor, the PMI-80 contained 1 kB of RAM, 1 kB of ROM (and you could add a second kB), a 25-button keyboard, a nine-digit display from a calculator (both connected via the 8255 peripheral circuit), and a primitive tape recorder interface.

I once made a PMI-80 online emulator, so you can check how it all worked.

PMI-80 is a single board school computer based on an Intel 8080 processor. Since it was created in the eighties behind the so-called Iron Curtain, it used Czechoslovakian Tesla chips instead of original Intel ones, although they were functionally identical, including the numbering (Intel 8080A had a designation MHB8080A, PIO 8255A was sold as MHB8255A etc.)

The base consists of standard “Holy Trinity” wiring (8080A – 8224 – 8228). On the input of RESIN 8224 circuit was a capacitor and diode, providing reset after being powered on. The crystal had 10 MHz, so the computer was running at a frequency of 10/9 = 1.111 MHz. INTA input circuit 8228 was connected to +12V, which ensured that in the event of an interruption request, instruction RST 7 was executed (i.e. jump to the address $0038).

ROM was from address 0000 (logically, after RESET the program was started from that address). RAM was from address 1C00 to 1FFF. It was even possible to add additional 2708 memory ($0400 – $07FF) to the board.

Peripherals were communicated with at addresses F8, F9, FA and FB (the classic 8255 quadruple of registers - PA, PB, PC, control).

The computer further included a VQD30 display, manufactured in the former Germany (Deutsche Demokratische Republik). This was a functional equivalent of displays NSA1198 or CQYP95 – 9 seven-segmented common cathode displays. Input data was provided by a keyboard which was built as a (logical) 3×9 matrix. Both of these peripherals were driven by a circuit based on the PIO 8255. Port A outlets (PA0-PA6) controlled individual segments (anodes) through the drive transistors. Lowest four bits of port C were decoded by a circuit MH1082 (equivalent to 74145) to code 1-from-9, which was used to select positions, and simultaneously activating the columns of the keyboard. Keyboard lines were connected to bits PC4-PC6.

So the display had to be periodically refreshed by the processor; as soon as the program got stuck somewhere, a single position remained lit and the keyboard stopped responding.

Programs were stored on tape in a very simple way, which was also controlled via the PIO 8255. Every entry had a start bit (1), then the actual value, and a stop bit (0). During recording a program generated a carrier frequency cycle of 0.2ms on PA6 port and strobbed it with the pin PA7. During reading the information was available at bit PC7.



The keyboard was composed of 25 keys arranged in a 5×5 matrix. Inside, however, it was wired differently. Two keys (RE and I) have led directly to the inputs of the processor (RESET, respectively INT). The remaining keys (0-9, A-F, EX, R, BR, M, L, S and =) have been wired in the already mentioned 3×9 matrix as shown here.

After turning it on, the display screen read “PMI-80” and computer waited for any key press. After that it went into main screen mode, identified by “?” on the left side of the display. Then the computer waited for monitor commands.

Monitor commands

M – change / view the memory content. After pressing M the character M appears on the left and computer waits for address entry. Pressing = activates the data entry. Each time you press = the address pointer increases by 1. Data input is finished by pressing keys other than = and 0-F.

R – view and change the contents of registers. After pressing R the character “r” appears on the left and computer waits for a keystroke which corresponds to register pair (AF = A, B = BC, D = DE, HL 9 = 8 = SP). Again, it is possible to modify data and use = move to the next pair.

Ex – runs a program. Computer waits for an address, pressing = jumps into the program. The program can be terminated by jumping to the address 0 or address 8 (corresponds to jump to the monitor).

BR – same as G, but with a breakpoint. First you need to enter an address at which the program should be discontinued, and then the next starting address.

L, S – LOAD and SAVE data

I – Interruption. Causes interruption and jumps to address $0038. There is only instruction: JMP $1FE6. At this address (in RAM), you must first create a jump into your handler routine.

RE – Reset. During reset the RAM does not clear, so it can be used as a program interruption and return to the monitor.

A Monitor listing with comments is available from the Git repository.

The display was, as with most single-channel recorders, divided into an address section (left) and a data section (right). The division was not a given, it was purely a convention. The keyboard contained 25 keys, physically arranged in a 5×5 matrix:

The RE button reset the whole system and the display showed "PMI-80". After pressing any key (i.e., except RE and I), a character appears on the far left of the display, which is probably a question mark, indicating that the PMI is ready to receive instructions.

The most significant thing about the single-board was the function to view and change the contents of the memory. After pressing the M (Memory) button, a "capital M" (I write it in quotes because on a seven-segment display it looks more like an inverted capital U or Russian P), then a space, and four address positions appeared on the left. For example, "M 1C00" You used the hexadecimal keyboard to enter the address (if you made a mistake, you just kept typing, the system only took the last four characters as valid) and used the "=" button to confirm it. The display showed an "=" after the address, followed by two characters - the contents of the memory at that address. For example, "M 1C00=00". Now you can enter the new contents, again using the hexadecimal keyboard, and again only the last two characters are taken, and the "=" button is used to confirm the change and move to the next address.

You can either cause the end of the entry by pressing a key that the program doesn't expect (like EX), or by resetting the machine (RE). Here, a reset doesn't clear the memory, so what you've entered stays in it.

With EX, you have run the program. When you press EX again, the system expects you to enter an address, and when you confirm it with the "=" button, it runs the program.

A more sophisticated form was the Break (BR) function. Here you first entered the address at which the program should break and jump to the monitor, and in the second step the starting address. Once the program hit the address, it jumped back to the monitor and you could check that everything was as it should be.

This was aided by the register checking function - the R key, for example. After pressing it, you chose which pair you wanted to view from (AF, BC, DE, HL, SP - see keyboard). Again, you can use the keyboard to change the contents, use the "=" key to confirm and move to the next pair.

This was aided by the register checking function - the R key, for example. After pressing it, you chose which pair you wanted to view from (AF, BC, DE, HL, SP - see keyboard). Again, you can use the keyboard to change the contents, use the "=" key to confirm and move to the next pair.

The last two functions, S and L, worked for saving (save) and reading (load) programs to and from tape.

Comments powered by Talkyard.

Martin Maly

Martin Maly

Programmer, journalist, writer and electronic hobbyist. Vintage CPU lover. Creating new computers with the spirit of 80's.