Okimate 20 Downline Loadable Character Generator

This program is a Downline Loadable Character Generator (DLCG) for the Okimate 20 color printer, allowing users to design custom bitmap characters and transfer them to the printer via an AERCO interface. Characters are assigned to ASCII codes in the range 64–127 (A–Z, a–z, and symbols) and stored in a binary block starting at address 62868. The editor uses a STICK-controlled crosshair cursor on an 18×14 pixel grid, with keyboard commands for adding points (A), deleting points (D), clearing the grid (C), and keeping the finished character (K). Machine code routines loaded from tape handle low-level data encoding and transfer operations, with entry points at addresses 61626, 61988, and 62307. The quit routine at line 930 prints the exact SAVE command needed to preserve the custom character block to tape, along with OUT port 127 sequences for activating and deactivating custom character mode on the printer.

---

Program Analysis

Program Structure

The program is divided into several logical phases managed by GO TO flow control rather than a structured subroutine model. The main phases are:

1. Initialization (lines 10–30): Clears memory, loads a machine code block from tape, sets up system variables and POKEs key addresses.
2. File load option (lines 40–80): Optionally loads a previously saved custom character CODE block by name.
3. Post-load menu (lines 90–150): Offers display, quit, or continue options after loading a file.
4. Character display (line 160): Calls machine code at 61988 to render the current character set; offers copy to printer or quit.
5. Character editor (lines 220–830): The main interactive drawing loop — assigns a character code, sets ascender/descender, and enters the STICK-driven pixel editor.
6. Utility subroutines (lines 840–920): Grid drawing (840–870), beep/prompt (880–900), machine code DATA loader (910–920).
7. Quit and instructions (lines 930–980): Prints SAVE command, OUT sequences for printer control, and restart instructions before STOPping.

Machine Code Usage

Three machine code entry points are used, all loaded from tape as a CODE block in line 10, with a small 32-byte routine POKEd from DATA at lines 910–920 into addresses 65368–65399:

Address	Called from	Purpose
61626	Line 520	Encodes the completed character data into the storage block (36 bytes per character)
61988	Line 160	Renders/displays the current custom character set on screen
62307	Line 300	Decodes an existing character from the storage block back into the grid for editing

The machine code block is loaded with LOAD ""CODE at line 10. Address pointers are maintained in memory at 62762/62763 (low/high byte of a 16-bit pointer) and 62758/62760, which are updated before each machine code call to direct the routine to the correct storage offset.

Character Storage Format

Each custom character occupies 38 bytes in the storage block starting at address 62868. The layout per entry is:

• Byte 0: Ascender/Descender flag (65 = ‘A’, 68 = ‘D’)
• Byte 1: ASCII code of the assigned character (64–127)
• Bytes 2–37: 36 bytes of encoded pixel data (handled by machine code)
• A sentinel value of 255 in byte 0 marks the end of the character list

The variable stmx tracks the end-of-data address, reconstructed as 256*PEEK 62763+PEEK 62762 at line 160. The SAVE command printed at line 930 uses stmx-62779 to calculate the exact byte length needed.

The Pixel Editor Loop

The editor operates on the screen attribute grid, using POKE to directly write attribute values to the display file. The grid spans columns 9–26 and rows 3–16, mapping to a 18×14 character cell. Screen address calculation uses the standard formula q = x + 22528 + (32*y). Set pixels use attribute value 10 (INK 2, PAPER 1 — red on blue) and cleared pixels use 56 (white on black). The crosshair cursor is drawn using PLOT INVERSE 1 and DRAW INVERSE 1, which XOR the cursor onto the display without destroying pixel data underneath.

The preview dot in the side panel is maintained at PLOT xo+31, 155-yo (line 760) and PLOT INVERSE 1; xo+31, 155-yo (line 820), giving a single-pixel preview of each edit in a small 18×14 preview area.

STICK-Based Navigation

Joystick input is read with STICK (1,1) at line 450. The four cardinal directions are handled with standard bitmask values: 4 = left, 2 = down, 1 = up, 8 = right. Keyboard commands are read simultaneously via INKEY$ at line 440 and stored in kk as a character code, allowing both input methods to coexist in the same polling loop without blocking.

Key BASIC Idioms

• Low/high byte address splitting: Used extensively, e.g., POKE 62762,(s-256*INT(s/256)): POKE 62763,INT(s/256) to store a 16-bit pointer across two bytes.
• Sentinel-terminated list: The character store uses a 255 byte as an end-of-list marker, walked by the loop at lines 270–290.
• POKE 23658,8 / POKE 23658,0: Toggles the caps lock / input mode flag to control INPUT prompt behavior.
• INPUT #0;AT …: Used throughout for styled prompts in the lower screen area.
• PAUSE 0 followed by INKEY$ check: Used at line 880/890 as an efficient keypress wait.
• VAL “number” in GO TO/GO SUB: Not used; all GO TO targets are literal line numbers.

Grid Drawing Subroutine

The subroutine at lines 850–860 draws the character editor grid using nested FOR loops with PLOT/DRAW. Horizontal lines are drawn at 8-pixel intervals from y=40 to y=152 (DRAW 144,0), and vertical lines from x=72 to x=216 (DRAW 0,112), creating an 18-column by 14-row pixel grid aligned to the 8×8 character cell boundaries.

Printer Control Information

Line 930–970 print complete operating instructions including the dynamically calculated SAVE command. The OUT sequences printed in lines 940–950 use port 127 to send Okimate 20 escape codes directly: OUT 127,27: OUT 127,37: OUT 127,90 enters custom character mode, while OUT 127,27: OUT 127,73: OUT 127,2 or ...73,1 exits to NLQ or draft mode respectively. These codes are printed in INK 2 (red) to visually distinguish them as control values.

Anomalies and Notes

• Lines 120–140 read INKEY$ three more times after the debounce loop at 100–110, but each call is a fresh read with no inter-call delay; rapid key release between lines 120 and 130 could cause the ‘D’ or ‘Q’ check to miss the key. This is a minor timing sensitivity rather than a logic error.
• Line 730 checks PEEK(q)=10 before setting a pixel, acting as a no-redraw guard for already-set cells. Similarly line 790 checks for 56 before clearing. This prevents unnecessary screen writes but does not affect the preview dot logic, which always plots regardless.
• The variable p is set to 0 at line 750 and 1 at line 810 but is never read elsewhere in the listing — it appears to be an unused state variable, possibly a remnant of a prior version.
• Line 300 decodes an existing character for re-editing, but the grid clear at lines 530 only fills with attribute 56; it does not reset the pixel graphics layer, relying on the attribute color alone to represent the cleared state.