UT-88 Soviet DIY i8080-based Computer Emulator

This is an emulator of the UT-88 computer, developed using Python. The project has two primary objectives:

• Understand the computer schematics, and emulate it as close as possible to the real hardware
• Understand software part of the computer, disassemble and document it

Additionally, this project serves as the most comprehensive repository of UT-88 related information, encompassing:

• scematics and modules descriptions
• binary files (addressing numerous scanning issues compared to other binaries available on the internet)
• Disassembly of every program ever published for the UT-88, and even beyond.

UT-88 - Computer Description

UT-88 (Russian: ЮТ-88) is a DIY computer originally introduced in "Young Technician - For Skilled Hands" magazine (Russian: "ЮТ Для Умелых Рук") on Feb 1989. In late 1980s, a typical DIY computers were notably complex, comprised of numerous components, and demanded substantial technical expertise to assemble and bring it up. In contrast, the UT-88 presented an elegantly simple design and a step-by-step construction process. This approach significantly broadened its appeal to a wider audience, including children and hobbyists.

The magazine featured both computer schematics and software code, with the intention of guiding readers through a computer construction process in several phases:

• Basic Configuration: The CPU module resembled a calculator, featuring a 6-digit LCD display and a hexadecimal button keypad. See detailed description of the basic configuration including hardware and software description here.
• Calculator Add-on: This expanded the capabilities by incorporating a ROM with floating-point functions, enabling scientific calculations. The calculator addon is described here.
• Video Module: The next phase introduced a 55-key alphanumeric keyboard and a 64x28 character monochrome display (with TV output). The hardware and software of the Video Configuration is described in this document.
• Dynamic 64k RAM: This upgrade allowed users to run programs from other compatible computers. See 64k RAM mod notes for more details.
• 64k-256k Quasi Disk: A battery-powered dynamic RAM was added, providing the capacity to store a substantial amount of data.
• Custom Add-ons: In addition to the phases listed above, there were custom add-ons, including a Flash memory programmer and an i8253-based sound generator.

These phases offered readers a structured approach to gradually build and enhance the UT-88 computer according to their preferences and needs. Each phase of the UT-88 build not only expanded the hardware but also enriched the software capabilities, providing users with a versatile computing experience.

From a software perspective, each phase of the UT-88 computer build introduced additional functionalities:

• Basic Configuration: In the basic configuration, users could perform basic computer operations such as memory read/write, CRC calculations, load programs from tape, and create and execute simple programs.
• Video Module: With the video module installed, the UT-88 could run text-based programs, including simple text-based video games.
• Full Configuration: Achieving the full configuration unlocked the ability to run the UT-88 operating system. This OS offered essential tools like a full screen text editor and an assembler, enhancing compatibility with other i8080-based computers.
• Special CP/M Port: The magazine also provided an unique port of the CP/M operating system, enabling users to work with files stored on the quasi disk, expanding the computer's capabilities even further.

The architecture of the UT-88 computer draws significant inspiration from two previously published computer systems: the Micro-80 (from the early 1980s) and the Radio-86RK (featured in the 'Radio' magazine between 1985 and 1987). Several technical solutions and design elements are inherited from these predecessors, enhancing the UT-88's overall functionality and compatibility. Key elements carried over from its predecessors include connectivity with tape recorders and the associated recording format, the layout and schematics of the keyboard, and the general hardware framework.

Notably, the UT-88 distinguishes itself by incorporating more advanced and refined schematics. This includes the integration of components like the i8224 and i8238, which replace a multitude of TTL logic gate chips used in the Radio-86RK. Additionally, the UT-88's peripheral are connected to the CPU using I/O address space, in contrast to the Radio-86RK where peripherals were located within the main memory address space. Furthermore, the UT-88's design takes into account chip availability, addressing the scarcity of the i8275 chip in late USSR. In response, the UT-88's video module employs a combination of registers and counters, providing a practical alternative for the video signal generation.

On the software front, the UT-88 maintains a high degree of compatibility with its predecessors. For instance, the Monitor F, which serves as the primary firmware for the Video Module, closely resembles the Radio-86RK Monitor and shares common routine entry points. This compatibility allows for the loading and execution of Radio-86RK programs from tape with minimal to no modifications, underscoring the seamless transition between these related computer systems.

In order to compare UT-88 with the Radio-86RK a special configuration is created in this emulator. It allows running vast majority of the Radio-86RK programs.

Scans of the original magazine can be found here.

UT-88 Emulator

This project serves as an emulator for the UT-88 hardware, encompassing the CPU, memory, and I/O peripherals. The emulator's architecture closely mirrors the hardware design of the UT-88 computer. The emulator implementation notes are described in this document in details.

The following sections describe how to run and use the Emulator in the configuration options described above.

Note: Python 3.10 or higher is required to run the emulator.

Basic configuration

Basic UT-88 configuration is started with the following command:

python src/main.py basic

Calculator ROM is also pre-loaded in this configuration.

Video configuration

This is how to run the emulator in Video module configuration:

python src/main.py video

This configuration enables 0x0000-0x7fff (32k) memory range available for user programs, which allows running some of Radio-86RK software. The configuration also enables some workarounds that improve stability of the MonitorF when running under emulator (see setup_special_breakpoints() function for moore details)

UT-88 OS configuration

To run the emulator with UT-88 OS enter this command:

python src/main.py ut88os

This configuration skips the UT-88 OS bootstrap module, as it requires reconfiguration of RAM and ROM components on the fly. Instead, it loads UT-88 OS components directly to their target locations, as they would be loaded by the bootstrap module.

Unfortunately the UT-88 OS is pretty raw and contains a lot of bugs. Most critical of them are fixed right in the binary (see detailed description), other worked around with special hooks in setup_special_breakpoints() function (refer the code for moore details)

CP/M operating system

UT-88 with CP/M-64 system loaded can be started as follows:

python src/main.py cpm64

This command starts the regular video module monitor with CP/M components loaded to the memory (CCP, BDOS, and BIOS). Use G DA00 command to skip CP/M bootstrap module, and start CP/M directly. In this case pre-created quasi disk image is used, and its contents survive between runs.

The G 3000 command can be used to run bootstrap module, which is also preloaded in this configuration. The bootstrap module will create/clear and initialize quasi disk image, that later may be used with the system.

Note that the QuasiDisk.bin quasi disk file is created in the current directory.

CP/M-35 version of the OS can be executed as follows: load OS binary, and execute it with G 4A00 command. Note that keyboard incompatibility workaround is applied only for CP/M-64 version, but not CP/M-35.

Radio-86RK emulator

Radio086RK emulator can be started as follows:

python src/main.py radio86rk

The configuration enables 32k RAM. Video and DMA controllers are emulated to a level sufficient to run Radio-86RK programs. Keyboard is emulated for Latin letters and control symbols (Cyrillic letters mode is not implemented).

Other emulator notes

The --debug option activates CPU instruction logging, compatible with all the modes outlined earlier. To prevent log cluttering with repetitive waiting loops, each configuration selectively suppresses logging for specific well-known functions (e.g., delays, character printing, tape input/output, etc.). The configure_logging() method is responsible for configuring log suppression for a given setup.

The --alternate_font switch forces using an alternate font located in the upper part of the font generator ROM.

Both Basic and Video configurations include a tape recorder component. Utilize the Alt-L key combination to load a binary into the tape recorder. Once loaded, the data can be read using the corresponding Monitor tape load command. Additionally, th