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

Introduction

With the Intel SDK-85 emulator successfully compiled and running under Ubuntu Linux, the next step was to develop an Intel 8085 machine-language program capable of producing a large ASCII-character banner.

The objective was to display my amateur radio callsign:

KE6JMG

The program was developed using the SDK-85 monitor, with machine-code instructions entered directly into the emulator's memory.

The finished demonstration produces an eight-line banner using printable ASCII characters and a compact method of encoding repeated spaces.

This project log contains the recorded machine-code program, complete banner data, monitor commands, and terminal output.

1. The Intel SDK-85 Emulator

The emulator used for this project was originally developed by Kjetil, known as kobolt on GitHub.

Original source repository:

https://github.com/kobolt/sdk85emu

The emulator is distributed under the MIT License.

The software emulates the Intel 8085 processor and SDK-85 development environment, including the monitor and serial terminal facilities.

My project uses this emulator to develop and execute an original ASCII banner demonstration.

2. Program Design

The banner generator separates the executable machine-code routine from the ASCII banner data.

The executable program reads bytes sequentially from memory, interprets their values, and sends the resulting characters to the SDK-85 terminal.

The program supports three important operations:

1. Printing ordinary ASCII characters.
2. Expanding encoded space characters into multiple spaces.
3. Processing carriage returns to create multiple lines of output.

A zero byte marks the end of the banner data.

This approach reduces the amount of memory required to store large banners containing substantial blank space.

3. Memory Organization

The program uses the following memory locations:

Purpose
Executable Intel 8085 program
Encoded KE6JMG banner data
End-of-data terminator
SDK-85 monitor output subroutine

The machine-code routine begins at address 2010H.

The banner data begins at 2800H and is processed sequentially.

The program calls the SDK-85 monitor's output routines to generate the display.

The byte at 2900H is set to zero, providing an end-of-data marker.

4. Starting the Emulator

Open the Ubuntu Linux terminal.

Change to the SDK-85 emulator directory:

cd ~/sdk85emu

Start the emulator in serial terminal mode:

./sdk85emu -s

The emulator displays:

SDK-85   VER 2.1
.

The period is the SDK-85 monitor prompt.

The following commands are entered into the SDK-85 monitor, not the Linux shell.

5. Entering the Intel 8085 Machine-Code Program

At the monitor prompt, enter:

.I2010

Then enter the following hexadecimal bytes:

31 C2 20 21 00 28 7E 4F 23 FE 00 CA 90 05 07 DA
34 20 0F FE 0D CA 2E 20 CD FA 07 C3 16 20 CD EB
05 C3 16 20 0F E6 7F 57 0E 20 CD FA 07 15 C2 38
20 C3 16 20 00

Finish the memory-entry operation using:

/*

This is the machine-code sequence recorded during the successful development session.

The program initializes its working registers, reads encoded banner data, and uses the SDK-85 monitor routines for terminal output.

6. Entering the Complete KE6JMG Banner Data

The banner data is stored separately from the executable instructions.

At the monitor prompt, enter:

.I2800

Enter the following hexadecimal bytes exactly as shown:

85 4B 20 20 4B 20 45 45 45 45 20 20 36 36 20 20
20 4A 4A 4A 20 4D 20 20 20 4D 20 20 47 47 47 0D
85 4B 20 4B 20 20 45 20 20 20 20 36 20 20 20 20
20 20 20 4A 20 4D 4D 20 4D 4D 20 47 20 20 20 0D
85 4B 4B 20 20 20 45 20 20 20 20 36 20 20 20 20
20 20 20 4A 20 4D 20 4D 20 4D 20 47 20 20 20 0D
85 4B 20 4B 20 20 45 45 45 20 20 36 36 36 20 20
20 20 20 4A 20 4D 20 20 20 4D 20 47 20 47 47 0D
85 4B 20 20 4B 20 45 20 20 20 20 36 20 20 36 20
20 20 20 4A 20 4D 20 20 20 4D 20 47 20 20 47 0D
85 4B 20 20 4B 20 45 20 20 20 20 36 20 20 36 20
4A 20 20 4A 20 4D 20 20 20 4D 20 47 20 20 47 0D
85 4B 20 20 4B 20 45 20 20 20 20 36 20 20 36 20
4A 20 20 4A 20 4D 20 20 20 4D 20 47 20 20 47 0D
85 4B 20 20 4B 20 45 45 45 45 20 20 36 36 20 20
20 4A 4A 20 20 4D 20 20 20 4D 82 47 47 47 0D 0D

Finish the memory-entry operation:

/*

Next, enter the end-of-data marker at address 2900H:

.I2900
00
/*

The banner data is now ready for the printing routine.

7. Understanding the Banner Encoding

The banner is constructed from ordinary ASCII character codes and specially encoded spacing commands.

For example:

Meaning
K
E
6
J
M
G
One space
Five spaces
Two spaces
Carriage return
End of data

The high bit of a byte is used to distinguish compressed spacing commands from ordinary ASCII characters.

For example, 85H represents five spaces rather than five individual 20H bytes.

This saves memory when generating large ASCII characters.

The stored banner is eight rows high. Each row is made from ordinary printable characters arranged to form larger letters.

8. Executing the Program

After entering the program and banner data, start execution at address 2010H:

.G2010

The emulator processes the banner data and sends the resulting characters to the terminal.

The following is the recorded output from the working demonstration:

     K  K EEEE  66   JJJ M   M  GGG     K K  E    6       J MM MM G     KK   E    6       J M M M G     K K  EEE  666     J M   M G GG     K  K E    6  6    J M   M G  G     K  K E    6  6 J  J M   M G  G     K  K E    6  6 J  J M   M G  G     K  K EEEE  66   JJ  M   M  GGG

The result is a large ASCII banner spelling KE6JMG.

The recorded working version printed the banner once and returned to the SDK-85 monitor.

9. Preserving Character Alignment

An important consideration when displaying large ASCII characters is the terminal font.

A proportional font gives different horizontal widths to different characters, which can destroy the intended letter shapes.

The banner must therefore be displayed using a monospaced font, such as:

• Courier New
• Consolas
• Liberation Mono
• DejaVu Sans Mono

These fonts give each character the same horizontal width.

The original ASR-33 Teletype also uses fixed character positions, making monospaced formatting particularly appropriate for this project.

For the Hackaday demonstration, the banner can be shown both as terminal text and as a rendered image resembling a vintage monochrome computer display.

10. Green Phosphor Terminal Illustration

The accompanying illustration recreates the appearance of the KE6JMG banner on a vintage green-phosphor CRT terminal.

It uses bright green monospaced characters on a dark background, with subtle scanlines and phosphor glow.

The illustration is a visual recreation of the recorded banner output rather than a photograph of the SDK-85 emulator or an actual CRT display.

It demonstrates how the program's output might have appeared on a vintage computer terminal.

11. Development and Debugging

During development, several program revisions were necessary.

Initial experiments involved generating ordinary ASCII characters and testing the SDK-85 monitor's serial output routines.

The banner program required additional work to handle encoded spacing, carriage returns, and the end-of-data condition.

One important part of the recorded machine-code sequence is:

CA 90 05

This is an Intel 8085 conditional jump instruction targeting address 0590H.

The final recorded version used the SDK-85 monitor routines to finish execution after the banner had been printed.

Earlier test programs sometimes repeated their output continuously. The completed demonstration printed once and returned control to the monitor.

12. Future Character Font Development

The current program prints a completed banner stored as encoded ASCII data.

The next stage is to create a general-purpose character generator.

Instead of storing a complete preformatted banner, a future program could read a text message such as:

KE6JMG

It could then look up the corresponding characters in a font table and construct the large banner automatically.

This would allow different messages to be printed without manually constructing each row.

Possible enhancements include:

• Complete uppercase alphabet
• Lowercase characters
• Numbers and punctuation
• Adjustable character spacing
• Variable-length messages
• Multiple character sizes
• Additional font tables

The Intel 8085's 16-bit address bus provides a 64 KB address space, although the actual usable RAM depends on the SDK-85 memory configuration.

13. Connecting to the ASR-33 Teletype

A major objective of this project is to reproduce the KE6JMG banner on an actual ASR-33 Teletype.

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

A Teensy 4.1 microcontroller is being used to bridge communications between the modern computer and the vintage Teletype.

The interface handles serial data conversion, character translation, and timing requirements associated with the electromechanical printer.

The eventual goal is to have the Intel 8085 banner program generate the characters while the ASR-33 prints them mechanically.

This will combine an emulated 1970s microprocessor development system with an authentic electromechanical terminal.

14. Development Results

The completed demonstration established the following:

• Intel 8085 machine-code execution using the SDK-85 emulator
• Separate program and banner data memory areas
• Compact repeated-space encoding
• Multi-line ASCII banner output
• Serial terminal printing through SDK-85 monitor routines
• Successful display of the KE6JMG callsign
• Return to the SDK-85 monitor after printing

The recorded program and banner data provide a reference for continued development.

Next Project Log

Project Log #3 — Developing the KE6JMG Character Font and Automatic Message Generator

The next stage will explore how to replace the fixed banner data with a reusable character font table.

The objective is to allow the Intel 8085 to generate large ASCII messages from ordinary text strings.

Additional project logs will document the modified SDK-85 startup menu and the connection to the ASR-33 Teletype.

Acknowledgment

The Intel SDK-85 emulator used in this project was originally developed by Kjetil (kobolt).

Original source repository:

https://github.com/kobolt/sdk85emu

The original emulator is distributed under the MIT License.

Full credit for the emulator belongs to its original author. The KE6JMG banner program, project experiments, and accompanying documentation are separate additions developed for this project.

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.