Project Log #1 — Installing and Compiling the Intel SDK-85 Emulator Under WSL

Introduction

The first step in developing the KE6JMG ASCII Banner Display was establishing a working Intel SDK-85 emulator.

The Intel SDK-85 was a development system designed around the Intel 8085 8-bit microprocessor. It provided a platform for experimenting with machine-language programming, memory operations, peripheral interfaces, and serial communications.

For this project, I am using an open-source SDK-85 emulator running under Ubuntu Linux through Windows Subsystem for Linux (WSL) on a Windows 11 computer.

This log explains how to obtain the original emulator, install the necessary development tools, compile the software, and run the SDK-85 monitor.

1. Original Emulator and Author Credit

The Intel SDK-85 emulator used in this project was originally developed by Kjetil, known as kobolt on GitHub.

Original GitHub repository:

https://github.com/kobolt/sdk85emu

Original project documentation:

https://kobolt.github.io/article-250.html

The original emulator is distributed under the MIT License.

Kjetil's software provides an emulated Intel 8085 processor, SDK-85 keyboard and display interface, serial terminal operation, memory support, and debugging facilities.

The original emulator includes:

• Intel 8085 CPU emulation
• Intel 8279 keyboard/display interface
• SDK-85 monitor ROM
• Serial terminal operation
• Debugging and breakpoint capabilities
• Intel HEX ROM loading
• Additional memory support

Full credit for the original emulator belongs to Kjetil.

My KE6JMG project builds upon this work by developing a custom Intel 8085 ASCII banner program, experimenting with character font tables, modifying the emulator startup environment, and investigating communication with an actual ASR-33 Teletype.

The original copyright and license notices will be preserved in any redistributed modified emulator source code.

2. Installing Windows Subsystem for Linux

The development computer uses Windows 11.

WSL allows Ubuntu Linux and its development tools to operate within Windows without requiring a separate Linux computer.

Open Windows PowerShell as Administrator and enter:

wsl --install -d Ubuntu

Windows may request a restart.

After restarting, open Ubuntu from the Windows Start menu.

During the initial setup, Ubuntu will request a Linux username and password.

To verify the installation, open PowerShell and enter:

wsl --list --verbose

The installed Ubuntu distribution should appear.

3. Updating Ubuntu Linux

Open the Ubuntu terminal.

Update the package information:

sudo apt update

Upgrade installed packages:

sudo apt upgrade -y

These commands prepare the Linux environment for software development.

4. Installing the Development Tools

The SDK-85 emulator is written in C and uses terminal display libraries.

Install the required development tools:

sudo apt install -y build-essential make libncurses-dev git

These packages provide:

• GCC — GNU C compiler
• Make — software build utility
• ncurses — terminal display library
• Git — source-code retrieval utility

Verify that the compiler is available:

gcc --version

Verify Make:

make --version

Verify Git:

git --version

5. Downloading the Original SDK-85 Emulator

The original source code is publicly available from Kjetil's GitHub repository.

For a straightforward Linux installation, open the Ubuntu terminal and enter:

cd ~

Download the source:

git clone https://github.com/kobolt/sdk85emu.git

Enter the project directory:

cd ~/sdk85emu

Examine the downloaded files:

ls -la

The source directory contains several important files, including:

Makefile
main.c
i8085.c
i8085.h
serial.c
serial.h
mem.c
mem.h
monitor.hex
mcs85util.hex

The monitor.hex file contains the SDK-85 monitor ROM image.

The i8085.c source provides the Intel 8085 CPU emulation.

The serial.c source handles serial communications.

The Makefile contains the instructions required to compile the emulator.

Note: During my original development, the emulator source was stored in a Windows Downloads directory and accessed from Ubuntu through /mnt/c/Users/.... Using the Linux home directory, as shown above, avoids computer-specific Windows paths.

6. Compiling the SDK-85 Emulator

From the source directory, enter:

make

The Make utility compiles the emulator's C source files and links them into an executable.

During my original compilation, GCC reported several warnings in the i8085.c source file.

Despite these warnings, the emulator compiled successfully.

The resulting executable is named:

sdk85emu

Verify that it exists:

ls -l sdk85emu

7. Starting the SDK-85 Emulator

The emulator supports both keyboard/display operation and serial terminal operation.

For this project, serial terminal operation is especially important because the eventual goal is to print the KE6JMG banner on an ASR-33 Teletype.

Start the emulator:

./sdk85emu -s

The terminal should display:

SDK-85   VER 2.1
.

This is the SDK-85 monitor sign-on message.

The period indicates that the monitor is ready to receive commands.

At this point, the emulated Intel 8085 is operational.

8. Testing the SDK-85 Monitor

The SDK-85 monitor allows machine-code programs to be entered, examined, and executed.

The following commands are entered at the SDK-85 monitor prompt, not the Ubuntu shell.

Examine memory:

.D2000

This displays memory beginning at hexadecimal address 2000.

Enter machine-code instructions:

.I2000

The monitor accepts hexadecimal machine-code bytes beginning at address 2000.

Execute a program:

.G2000

This transfers execution to hexadecimal address 2000.

A valid program must already be present at that address.

These monitor commands provided the foundation for developing and testing the KE6JMG banner program.

9. Testing an Intel 8085 Machine-Language Program

After confirming that the monitor was working, I entered a small Intel 8085 machine-language demonstration program.

The program generated printable ASCII characters through the SDK-85 serial terminal interface.

The successful test demonstrated that the emulator could:

• Execute Intel 8085 machine instructions
• Read and write emulated memory
• Perform conditional branching
• Call monitor subroutines
• Generate serial terminal output

This was an important milestone because the same serial output mechanism could be used for the KE6JMG banner generator.

The complete banner program and character font data will be documented in a later project log.

10. Exiting the Emulator

In the serial terminal configuration used during development, I exited the emulator using:

Ctrl+C

Followed by:

q

This returned control to the Ubuntu terminal.

11. Rebuilding the Emulator

The emulator source can be modified and recompiled.

After editing the source files, return to the source directory:

cd ~/sdk85emu

Rebuild:

make

If a complete rebuild is needed and the Makefile provides a clean target:

make clean
make

Restart the emulator:

./sdk85emu -s

During this project, I also developed a convenient startup menu with four options:

1 - Serial / TTY Mode
2 - SDK-85 Keypad / Display Mode
3 - Rebuild Emulator
4 - Exit

This menu makes it easier to switch between development modes without repeatedly entering Linux commands.

The custom menu will be documented separately.

12. Development Results

The initial emulator installation and testing were successful.

The completed milestones included:

• Installing WSL and Ubuntu on Windows 11
• Installing the GNU development tools
• Obtaining the SDK-85 emulator source
• Compiling the emulator
• Starting the SDK-85 serial monitor
• Examining and modifying emulated memory
• Entering and executing Intel 8085 machine code
• Generating ASCII output through the serial terminal

The emulator now provides a working development environment for the KE6JMG ASCII Banner Display project.

13. Future Development

The next phase involves implementing the KE6JMG banner generator using Intel 8085 machine code and a character font table.

The banner generator will read character patterns from memory and convert them into large printable ASCII characters.

Further development will include automatic program loading, additional character patterns, and serial communication with a physical ASR-33 Teletype.

The ASR-33 operates at 110 baud and uses a 20 mA current-loop interface.

A Teensy 4.1 microcontroller will provide the interface between the computer and the Teletype.

The eventual objective is to have an emulated Intel 8085 generate the KE6JMG banner while a real electromechanical Teletype prints the result.

Next Project Log

Project Log #2 — Programming the Intel 8085 to Display KE6JMG

The next log will document the machine-code program, memory addresses, character font data, and ASCII banner output.

The ultimate objective is to demonstrate vintage Intel 8085 programming using both modern development tools and authentic electromechanical terminal hardware.

Acknowledgment: Special thanks to Kjetil (kobolt) for developing and making the original Intel SDK-85 emulator publicly available under the MIT License.