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:

Printing ordinary ASCII characters.
Expanding encoded space characters into multiple spaces.
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: