2068 BBS Program

A complete bulletin board system (BBS) for the TS2068. Supports up to 90 stored messages with forward and reverse browsing, message entry with automatic word wrap, direct message retrieval by number, and a real-time sysop chat mode. Uses machine code for serial I/O and stores the message base to tape between sessions.

What it does

This is a fully functional BBS (Bulletin Board System) for the TS2068, designed to run over a serial/modem connection. It POKEs 56 bytes of machine code into high memory (address 65480) at startup to handle low-level RS-232 serial I/O via ports 115 and 119. It stores up to 90 messages in a string array (m$(90,300)), each up to 300 characters, and can save/load the message base to tape.

Once a caller connects, the BBS handles modem handshaking, prompts for a username, then presents a menu with six options: forward or reverse reading through messages, leaving a message (with word wrap), reading a message by number, and a sysop chat mode that pages the operator with an ascending beep sequence. The time-on-system is calculated from the TS2068’s system clock registers and displayed in the menu. Disconnection is handled gracefully with a hangup sequence on port 119.

---

Program Analysis

Program Structure

The program is organized into clearly separated functional blocks:

• Lines 10–25: Initialization, machine code installation, array setup, and optional data load.
• Lines 1000–1090: Modem handshake, carrier detect, main menu dispatch loop.
• Lines 2100–2218: Reverse and forward message reading routines.
• Lines 2300–2350: Leave message, with word-wrap logic.
• Lines 2400–2418: Read message by number.
• Lines 2500–2596: Real-time sysop chat mode.
• Lines 8000–8024: String output subroutines (menu text, prompts).
• Lines 9000–9950: Utility routines: save program, serial transmit loop, disconnect, input handler, message reader, time formatter, and data save.

Machine Code Installation

Lines 14–16 install 56 bytes of machine code at address 65480. The code is stored as a string of packed three-digit decimal values in l$, and a FOR loop POKEs each byte using VAL l$(3*x+1 TO 3*x+3). The entry points are stored in named variables for clarity:

Variable	Address	Purpose
o	65523	Serial transmit USR entry
i	65489	Serial receive USR entry
l	9100	BASIC line number for string-send loop
aa	1000	Main loop restart target
q	9200	Error/disconnect handler target

Serial I/O uses ports 115 (data) and 119 (control/status), consistent with the TS2068’s built-in RS-232 interface. The variable l is used as a numeric GO SUB target (line 9100), allowing the string-send loop to be called via GO SUB l — a compact idiom that avoids a literal line number in each of the eight output subroutines.

Modem Handshake and Carrier Detect

Lines 1000–1020 implement the modem answer sequence. Port 119 is written with control bytes to initialize the serial port, and the program then polls IN 119 waiting for a carrier signal (line 1004 loops while the status byte equals 5). Lines 1010–1020 send modem command bytes and perform a short handshake delay with PAUSE 300, followed by 30 iterations of the machine code transmit routine to flush or synchronize the line. The receive loop at lines 1018–1020 checks the high bit of the status byte to detect data readiness.

Input Handler (Line 9400)

The main character input routine at line 9400 accumulates characters into l$ one at a time. It uses ON ERR GO TO q to trap serial errors (e.g., loss of carrier) and redirect to the disconnect/goodbye handler. Characters below 32 or above 122 are discarded, and lowercase letters are converted to uppercase by subtracting 32 from their code. The routine returns after a single character, requiring the caller to loop (e.g., lines 9406–9412). The received byte is stored in in via PEEK 65479 after the machine code routine deposits it there.

Message Storage

Messages are stored in m$(90,300), a 90-row by 300-character string array. Each message record is structured as a header block prepended at write time (line 2312): "TO: " + recipient + CHR$ 13 + "FROM: " + caller_name + CHR$ 13. A CHR$ 7 (BEL) sentinel is written at the end of the message body to mark its actual length. The read routine at lines 9500–9510 scans backwards from position 300 to find this sentinel, then passes only the valid prefix to the output routine.

Word-Wrap Logic

Lines 2330–2346 implement a simple word-wrap algorithm for messages longer than 32 characters. Starting from position 33, the code scans left to find a space character, replaces it with CHR$ 13 (carriage return), then copies that segment into the message array and recurses on the remainder. There is a notable bug on line 2340: LET y2=ys+c1 references the variable ys, which is never defined anywhere in the program; this should almost certainly be y2=y2+c1, meaning word-wrapped messages will likely store with a corrupted offset.

Chat Mode

Lines 2500–2596 implement a duplex chat mode. The sysop is paged with a beep sequence (line 2506 ramps pitch over 128 iterations). If the sysop presses a key, full-duplex chat begins. The machine code at address 65480 is polled via LET a=USR 65480 (line 2562), which returns a bitmask: 1 = transmit ready, 2 = receive data present, 3 = both. Incoming characters are printed with a “>” line-break on CR; outgoing characters are sent with OUT 115, CODE l$ with a short FOR delay loop (line 2592). The escape condition checks for CODE INKEY$=195, which is the BASIC keyword token for a specific key combination rather than a standard ASCII code.

Time-On Display

Subroutine 9900 reads the TS2068 frame counter from system variables at addresses 23672, 23673, and 23674, combining them as t = PEEK 23672 + 2^8*PEEK 23673 + 2^16*PEEK 23674. The counter is reset to zero at line 1012 when a caller connects, so elapsed time in seconds (at 50 frames/second) is computed and formatted as m:ss for display in the main menu. This is a standard technique for elapsed-time tracking without a real-time clock.

Notable Techniques

• VAL "number" is used in several GO TO and GO SUB targets (e.g., GO TO VAL "1002", GO SUB VAL "8002") as a memory-saving optimization — the tokenized line number takes more space than a short string.
• The variable l holds the numeric value 9100 and is used directly as a GO SUB target: GO SUB l. This is legal in Sinclair BASIC and avoids repeating the literal line number across many output subroutines.
• POKE 23692,255 resets the scroll count to prevent the “scroll?” prompt from interrupting serial output.
• Line 9201 uses the TS2068-specific ON ERR RESET keyword to clear the error state before the disconnect sequence.
• Data persistence uses SAVE "" DATA m$() and SAVE "" DATA y() to tape, with a corresponding LOAD path at lines 20–23.

Bugs and Anomalies

• Line 2340: LET y2=ys+c1 — variable ys is undefined; should be y2=y2+c1. This will corrupt message write offsets whenever word-wrap is triggered.
• Line 2506: The label says p$=l$(LEN l$) is checked at line 1028 for CHR$ 13 termination, but in section 2300 the variable in is tested (lines 2310, 2320) rather than being set by the input subroutine — in is only populated inside the machine code receive path, so these checks may not behave as intended from a BASIC-only perspective.
• Line 9506: LET p$=( TO a) is missing the array reference — should be LET p$=l$( TO a) or m$(b)( TO a). As written, this is a syntax error or will reference an unexpected variable.
• Line 2576: The condition IF in>32 or in<123 is logically always true for any value of in and should likely be in>=32 AND in<123 to filter printable ASCII.