jsbeeb 1.14.0 → 1.16.0

package/README.md

@@ -11,6 +11,7 @@ different peripherals.
 ## Table of Contents
 
 - [Keyboard Mappings](#keyboard-mappings)
+- [Remapping Keys](#remapping-keys)
 - [Emulator Shortcuts](#emulator-shortcuts)
 - [Save State and Rewind](#save-state-and-rewind)
 - [Getting Set Up to Run Locally](#getting-set-up-to-run-locally)
@@ -36,6 +37,65 @@ The BBC had a somewhat different-looking keyboard to a modern PC, and so it's us
 To play right now, visit [https://bbc.xania.org/](https://bbc.xania.org/). To load the default disc image (Elite in this
 case), press shift-F12 (which is shift-Break on the BBC).
 
+### Remapping Keys
+
+Plenty of games use keys that are awkward on a modern keyboard: `COPY` (which is `End`, or `fn`+`→` on a Mac), or
+`CAPS LOCK` (which on a Mac toggles rather than acting as a key you hold down). Any host key can be made to press any
+BBC key by adding a `KEY.` parameter to the URL:
+
+```
+KEY.<host key>=<BBC key>
+```
+
+Add one for each key you want to change. For example, Superior Software's Space Invaders fires with `COPY`; this makes
+`Enter` fire instead:
+
+[`https://bbc.xania.org/?disc1=sth:Superior/SpaceInvaders-Superior.zip&autoboot&KEY.ENTER=COPY`](https://bbc.xania.org/?disc1=sth%3ASuperior%2FSpaceInvaders-Superior.zip&autoboot&KEY.ENTER=COPY)
+
+Superior's Frogger uses `A`/`Z`/`DELETE`/`COPY` to move; this puts it on the arrow keys:
+
+[`https://bbc.xania.org/?disc1=sth:Superior/Frogger-Superior.zip&autoboot&KEY.UP=A&KEY.DOWN=Z&KEY.LEFT=DELETE&KEY.RIGHT=COPY`](https://bbc.xania.org/?disc1=sth%3ASuperior%2FFrogger-Superior.zip&autoboot&KEY.UP=A&KEY.DOWN=Z&KEY.LEFT=DELETE&KEY.RIGHT=COPY)
+
+And Superior's Hunchback steers with `CAPS LOCK` and `CTRL`, which the arrow keys can stand in for:
+
+[`https://bbc.xania.org/?disc1=sth:Superior/Hunchback-Superior.zip&autoboot&KEY.LEFT=CAPSLOCK&KEY.RIGHT=CTRL`](https://bbc.xania.org/?disc1=sth%3ASuperior%2FHunchback-Superior.zip&autoboot&KEY.LEFT=CAPSLOCK&KEY.RIGHT=CTRL)
+
+The **host key** names are jsbeeb's names for the keys on your own keyboard. Most are what you'd expect, but note:
+
+- `ENTER` (the BBC's `RETURN` key is called `ENTER` on the host side)
+- `K0` to `K9` for the number keys, `NUMPAD0` to `NUMPAD9` for the keypad
+- `SHIFT_LEFT` / `SHIFT_RIGHT`, `CTRL_LEFT` / `CTRL_RIGHT`, `ALT_LEFT` / `ALT_RIGHT` to distinguish the two of each
+- `BACK_QUOTE`, `APOSTROPHE`, `SEMICOLON`, `MINUS`, `EQUALS`, `HASH`, `BACKSLASH`, `LEFT_SQUARE_BRACKET`,
+  `RIGHT_SQUARE_BRACKET` for punctuation
+
+The **BBC key** names are:
+
+```
+RETURN COPY DELETE ESCAPE TAB SPACE SHIFT SHIFTLOCK CAPSLOCK CTRL
+LEFT RIGHT UP DOWN
+A-Z, K0-K9 (the number keys), F0-F9 (the red function keys)
+SEMICOLON_PLUS MINUS COMMA PERIOD SLASH AT COLON_STAR HAT_TILDE
+UNDERSCORE_POUND PIPE_BACKSLASH LEFT_SQUARE_BRACKET RIGHT_SQUARE_BRACKET
+
+(and, on the Master's numeric keypad only)
+NUMPAD0-NUMPAD9 NUMPADPLUS NUMPADMINUS NUMPADSLASH NUMPADASTERISK NUMPADCOMMA
+NUMPADHASH NUMPADENTER NUMPAD_DELETE NUMPAD_DECIMAL_POINT
+```
+
+Some things to know:
+
+- Names are case-insensitive, and a remapped key ignores the `SHIFT` state, so `KEY.ENTER=COPY` presses `COPY` whether
+  or not shift is held.
+- Remapping replaces what that host key normally does; in the Space Invaders example above, `Enter` no longer presses
+  `RETURN`.
+- The remapping is applied on top of whichever keyboard layout is selected, and survives changing layout or model.
+- If a name isn't recognised the mapping is skipped, and the emulator says so on startup, naming the parameter that
+  was at fault.
+- On the Atom, use the Atom's own key names (`LOCK`, `UP_DOWN`, `LEFT_RIGHT` and so on) rather than the BBC's.
+
+The definitive lists are `keyCodes` (host) and `BBC` (BBC micro) in [`src/utils.js`](src/utils.js), and `ATOM` in
+[`src/utils_atom.js`](src/utils_atom.js).
+
 ### Emulator Shortcuts
 
 | Shortcut       | Action                          |
@@ -63,6 +123,35 @@ jsbeeb supports both USB/Bluetooth gamepads and mouse-based analogue joystick em
 - X-axis: Left = 65535, Right = 0
 - Y-axis: Up = 65535, Down = 0
 
+A gamepad presses BBC keys, and which key each control presses can be changed from the URL in the same way as
+[remapping the keyboard](#remapping-keys):
+
+```
+GP.<gamepad control>=<BBC key>
+```
+
+By default the D-pad presses the "Snapper" keys (`Z`, `X`, `:`, `/`), the `A` button presses `RETURN` and `Start`
+presses `SPACE`. To play Superior's Space Invaders on a pad, where `COPY` fires:
+
+[`https://bbc.xania.org/?disc1=sth:Superior/SpaceInvaders-Superior.zip&autoboot&GP.FIRE=COPY`](https://bbc.xania.org/?disc1=sth%3ASuperior%2FSpaceInvaders-Superior.zip&autoboot&GP.FIRE=COPY)
+
+The gamepad control names are:
+
+- `FIRE` — every button at once, which is usually what you want for a one-button game
+- `UP` `DOWN` `LEFT` `RIGHT` — both analogue sticks at once, plus one face button each (`UP` is also `A`, `DOWN` is
+  `X`, `LEFT` is `Y`, `RIGHT` is `B`)
+- `UP1` `DOWN1` `LEFT1` `RIGHT1` — the left stick only; `UP2` `DOWN2` … — the right stick only; `UP3` `DOWN3` … — the
+  face buttons only
+- `A` `B` `X` `Y` `START` `BACK` `LB` `RB` `LT` `RT` — individual buttons, by their Xbox 360 names
+- `FIRE1` `FIRE2` — clicking the left and right sticks
+
+The BBC key names are the same as for the keyboard, and digits may be written either way round: `GP.A=1` and `GP.A=K1`
+both press `1`. Unlike `KEY.`, gamepad mappings are BBC-only: there's no Atom equivalent. The D-pad's default mapping
+can't currently be changed.
+
+The older `LEFT=`, `RIGHT=`, `UP=`, `DOWN=` and `FIRE=` parameters (no `GP.` prefix) still work and mean the same
+thing.
+
 ## Getting Set Up to Run Locally
 
 ### Prerequisites
@@ -157,6 +246,8 @@ sudo rpm -i out/dist/jsbeeb-1.0.1.x86_64.rpm
 - `disc1=sth:ZZZ` - loads disc ZZZ from the Stairway to Hell archive
 - `tape=XXX` - loads tape XXX (from the `tapes/` directory)
 - `tape=sth:ZZZ` - loads tape ZZZ from the Stairway to Hell archive
+- `KEY.X=Y` - makes host key `X` press BBC key `Y`, e.g. `KEY.ENTER=COPY`. See
+  [Remapping Keys](#remapping-keys).
 - `patch=P` - applies a memory patch `P`. See below.
 - `loadBasic=X` - loads 'X' (a resource on the webserver) as text, tokenises it and puts it in `PAGE` as if you'd typed
   it in to the emulator
@@ -170,6 +261,9 @@ sudo rpm -i out/dist/jsbeeb-1.0.1.x86_64.rpm
 - `cpuMultiplier=X` speeds up the CPU by a factor of `X` relative to the peripherals: video, sound and the VIAs keep
   running at their real-world rates. May be fractional or below one to slow the CPU down. NB disc loads become
   unreliable with a too-slow CPU, and running too fast might cause the browser to hang.
+- `tubeCpuMultiplier=X` overclocks the second processor by a factor of `X`, which may be fractional. `1`, the default,
+  runs it at the real part's own clock: 3MHz for the 6502 second processor a BBC B takes, 4MHz for the 65C102 Turbo
+  board a Master takes. Below about 2.2MHz the MOS's unhandshaken tube transfers lose data.
 - `sbLeft` / `sbRight` / `sbBottom` - a URL to place left of, right of, or below the cub monitor. The left and right
   should be around 648 high and the bottom image should be around 896 wide. Left and right wider than 300 will run into
   problems on smaller screens; bottom taller than 100 or so similarly.

package/package.json

@@ -7,7 +7,7 @@
   "name": "jsbeeb",
   "description": "Emulate a BBC Micro",
   "repository": "git@github.com:mattgodbolt/jsbeeb.git",
-  "version": "1.14.0",
+  "version": "1.16.0",
   "//engines": "If you change the version of Node, it must also be updated at the top of the Dockerfile.",
   "engines": {
     "node": ">=24.15.0"
@@ -54,10 +54,6 @@
     "electron-builder": "^26.15.3",
     "electron-store": "^11.0.2"
   },
-  "//overrides": "brace-expansion forced to the patched version for GHSA-mh99-v99m-4gvg; the electron-builder dependency chain still pins vulnerable versions. Remove once `npm audit` is clean without it.",
-  "overrides": {
-    "brace-expansion": "^5.0.8"
-  },
   "license": "GPL-3.0-or-later",
   "build": {
     "appId": "org.godbolt.bbc",
@@ -99,15 +95,21 @@
     "test:unit": "vitest run --silent=true tests/unit",
     "test:integration": "vitest run --silent=true tests/integration",
     "test:cpu": "node tests/test-suite.js",
+    "test:shader": "vitest run --silent=true tests/shader",
     "coverage:unit": "vitest run tests/unit --coverage",
     "coverage:all-tests": "vitest run --coverage",
     "benchmark": "node src/app-bench.js",
+    "mirror-sth": "node tools/mirror-sth.js --out .sth-mirror",
+    "mirror-sth:check": "node tools/mirror-sth.js --index-only",
+    "mirror-sth:upload": "npm-run-all mirror-sth:upload:*",
+    "mirror-sth:upload:blobs": "aws s3 sync .sth-mirror s3://bbc.xania.org/archive/sth/ --no-progress --exclude '*manifest.json' --exclude 'meta/*' --cache-control 'public, max-age=31536000, immutable'",
+    "mirror-sth:upload:index": "aws s3 sync .sth-mirror s3://bbc.xania.org/archive/sth/ --no-progress --exclude '*' --include '*manifest.json' --include 'meta/*' --cache-control 'public, max-age=300'",
     "electron": "npm run build && ELECTRON_DISABLE_SANDBOX=1 electron .",
     "electron:build": "electron-builder"
   },
   "lint-staged": {
     "*.js": [
-      "vitest related --run --exclude tests/integration --no-file-parallelism",
+      "vitest related --run --exclude tests/integration --exclude tests/shader --no-file-parallelism",
       "eslint --cache --fix",
       "prettier --write"
     ],

package/src/6502.js

@@ -15,9 +15,6 @@ import { AtomMMC2 } from "./mmc.js";
 
 const signExtend = utils.signExtend;
 
-// Speed of the second processor relative to the host, as fitted to a Master Turbo.
-export const DefaultTubeCpuMultiplier = 2;
-
 function _set(byte, mask, set) {
     return (byte & ~mask) | (set ? mask : 0);
 }
@@ -216,6 +213,9 @@ class Base6502 {
         if (this._nmiLevel && !prevLevel) this._nmiEdge = true;
     }
 
+    /** Called as the NMI vector is taken, for devices that withdraw their request at that point. */
+    nmiAcknowledged() {}
+
     polltime() {
         throw new Error("Must be overridden");
     }
@@ -242,6 +242,7 @@ class Base6502 {
         if ((this.model.nmos || isIrq) && this._nmiEdge) {
             vector = 0xfffa;
             this._nmiEdge = false;
+            this.nmiAcknowledged();
         }
         this.takeInt = false;
         this.pc = this.readmem(vector) | (this.readmem(vector + 1) << 8);
@@ -410,10 +411,13 @@ class Base6502 {
 }
 
 class Tube6502 extends Base6502 {
-    constructor(model, cpu, { cpuMultiplier = DefaultTubeCpuMultiplier } = {}) {
+    constructor(model, cpu, { cpuMultiplier = 1 } = {}) {
         super(model, { cycleAccurate: false });
 
+        if (!(cpuMultiplier > 0)) throw new Error(`Tube CPU multiplier must be positive, got ${cpuMultiplier}`);
+
         this.cycles = 0;
+        this.cyclesPerHostCycle = model.clockMhz / cpu.model.clockMhz;
         this.cpuMultiplier = cpuMultiplier;
         this.romPaged = true;
         this.memory = new Uint8Array(65536);
@@ -451,6 +455,10 @@ class Tube6502 extends Base6502 {
         return this.memory[offset & 0xffff];
     }
 
+    nmiAcknowledged() {
+        this.tube.acknowledgeNmi();
+    }
+
     writemem(addr, b) {
         if ((addr & 0xfff8) === 0xfef8) {
             return this.tube.parasiteWrite(addr, b);
@@ -479,7 +487,7 @@ class Tube6502 extends Base6502 {
     }
 
     execute(cycles) {
-        this.cycles += (cycles * this.cpuMultiplier) | 0;
+        this.cycles += cycles * this.cyclesPerHostCycle * this.cpuMultiplier;
         if (this.cycles < 3) return;
         while (this.cycles > 0) {
             const opcode = this.readmem(this.pc);
@@ -666,10 +674,11 @@ export class Cpu6502 extends Base6502 {
         this.resetLine = true;
         this.cpuMultiplier = this.config.cpuMultiplier;
         this.videoCyclesBatch = this.config.videoCyclesBatch | 0;
-        this.peripheralCyclesPerSecond = 2 * 1000 * 1000;
+        this.peripheralCyclesPerSecond = model.cyclesPerSecond;
         this.hasTube = !!this.config.tube;
         this.hasMusic5000 = !!this.config.hasMusic5000;
         this.hasTeletextAdaptor = !!this.config.hasTeletextAdaptor;
+        this.teletextAdaptor = this.hasTeletextAdaptor ? new TeletextAdaptor(this) : null;
         this.tube = this.hasTube
             ? new Tube6502(this.config.tube, this, { cpuMultiplier: this.config.tubeCpuMultiplier })
             : new FakeTube();
@@ -697,7 +706,7 @@ export class Cpu6502 extends Base6502 {
             getGamepads: this.config.getGamepads,
         });
         this.uservia = new via.UserVia(this, this.scheduler, this.model.isMaster, this.config.userPort);
-        this.acia = new Acia(this, this.soundChip.toneGenerator, this.scheduler, this.touchScreen, this.relayNoise);
+        this.acia = new Acia(this, this.soundChip.toneGenerator, this.scheduler, this.relayNoise);
         this.serial = new Serial(this.acia);
         this.adconverter = new Adc(this.sysvia, this.scheduler);
         this.soundChip.setScheduler(this.scheduler);
@@ -1360,8 +1369,7 @@ export class Cpu6502 extends Base6502 {
         this.fdc.powerOnReset();
         this.adconverter.reset();
 
-        this.touchScreen = new TouchScreen(this.scheduler);
-        if (this.hasTeletextAdaptor) this.teletextAdaptor = new TeletextAdaptor(this);
+        this.touchScreen = new TouchScreen(this.scheduler, this.model.cyclesPerSecond);
         if (this.econet) this.filestore = new Filestore(this, this.econet);
     }
 
@@ -1422,8 +1430,7 @@ export class Cpu6502 extends Base6502 {
     buildPolltime() {
         const nop = (_cycles) => {};
         const tubeStuff = this.hasTube ? (cycles) => this.tube.execute(cycles) : nop;
-        // The adaptor itself does not exist until reset() runs, so branch on the fitting, not the object.
-        const teletextStuff = this.hasTeletextAdaptor ? (cycles) => this.teletextAdaptor.polltime(cycles) : nop;
+        const teletextStuff = this.teletextAdaptor ? (cycles) => this.teletextAdaptor.polltime(cycles) : nop;
         const musicStuff = this.music5000 ? (cycles) => this.music5000.polltime(cycles) : nop;
         const econetStuff = this.econet
             ? (cycles) => {
@@ -1479,9 +1486,10 @@ export class Cpu6502 extends Base6502 {
         // that from both, to keep the domain low (while accumulating seconds). Take care to preserve the bottom
         // bit though; as that encodes whether we're on an even or odd bus cycle.
         const smaller = Math.min(this.targetCycles, this.currentCycles) & 0xfffffffe;
-        if (smaller >= 2 * 1000 * 1000) {
-            this.targetCycles -= 2 * 1000 * 1000;
-            this.currentCycles -= 2 * 1000 * 1000;
+        const cyclesPerSecond = this.model.cyclesPerSecond;
+        if (smaller >= cyclesPerSecond) {
+            this.targetCycles -= cyclesPerSecond;
+            this.currentCycles -= cyclesPerSecond;
             this.cycleSeconds++;
         }
         // Any tracing or debugging means we need to run the potentially slower version: the debug read or
@@ -1615,8 +1623,6 @@ export class AtomCpu6502 extends Cpu6502 {
             this.ramRomOs = expanded;
         }
 
-        // Atom runs at 1 MHz
-        this.peripheralCyclesPerSecond = 1 * 1000 * 1000;
         // reset() and debugger.setCpu() are called by initialise() after loadOs().
     }
 

package/src/6847.js

@@ -1,6 +1,7 @@
 "use strict";
 import * as utils from "./utils.js";
 import * as fontData from "./6847_fontdata.js";
+import { encodeLineGrid } from "./video-filters/pixel-grid.js";
 
 const VDISPENABLE = 1 << 0,
     HDISPENABLE = 1 << 1,
@@ -111,6 +112,11 @@ only 1 bit is used of SG6 - to get yellow/red, cyan/orange
 // constant for the graphics mode
 const MODE_AG = 0x10; // graphics mode
 
+// The MC6847 datasheet specifies 3.579545 MHz, but 3.638004 is used here as an
+// empirical correction to align VSync/interrupt timing with the CPU clock.
+// TODO: revisit once full integration is testable.
+const VdgClockMhz = 3.638004;
+
 export class Video6847 {
     constructor(video) {
         this.video = video;
@@ -175,6 +181,7 @@ export class Video6847 {
         this.bitmapPxPerPixel = 2; // each pixel is 2 bitmap pixels wide and high
         this.pixelsPerBit = this.bitmapPxPerPixel;
         this.bpp = 1;
+        this.updateLineGrid();
 
         this.cpuAddr = 0;
         this.dispEnabled = 0;
@@ -225,6 +232,9 @@ export class Video6847 {
     reset(cpu, ppia) {
         this.cpu = cpu;
         this.ppia = ppia;
+        // polltime() is handed CPU cycles, so how far the VDG advances per
+        // cycle depends on how fast the CPU it's attached to runs.
+        this.vdgCyclesPerCpuCycle = cpu ? VdgClockMhz / cpu.model.clockMhz : 0;
     }
 
     // USE PAINT from VIDEO
@@ -315,6 +325,7 @@ export class Video6847 {
         this.pixelsPerBit = this.bitmapPxPerPixel * this.modes[mode][1];
         let linesPerRow = this.modes[mode][2]; // move to reg9
         this.bpp = this.modes[mode][3];
+        this.updateLineGrid();
 
         this.charLinesreg9 = linesPerRow - 1; //2  - scanlines per char
 
@@ -344,11 +355,7 @@ export class Video6847 {
         // it doesn't draw the whole frame.  It regularly gives control back to the CPU.
 
         const vdgcharclock = this.pixelsPerChar / 2; // 4 or 8
-        // The MC6847 datasheet specifies 3.579545 MHz, but 3.638004 is used here
-        // as an empirical correction to align VSync/interrupt timing with the Atom's
-        // 1 MHz CPU clock. TODO: revisit once full integration is testable.
-        const vdgclock = 3.638004;
-        this.vdg_cycles += clocks * vdgclock;
+        this.vdg_cycles += clocks * this.vdgCyclesPerCpuCycle;
 
         const vdgframelines = 262; //  312 PAL (but no pal on standard atom)  262; // NTSC
         const vdglinetime = 228; // vdg cycles to do a line; not 227.5
@@ -491,9 +498,9 @@ export class Video6847 {
                         {
                             // TODO: Add in the INTEXT modifiers to mode (if necessary)
                             // blit into the fb32 buffer which is painted by VIDEO
-                            if ((mode & MODE_AG) === 0)
-                                // MODE_AG - bit 4; 0x10 is the AG bit
-                                this.blitChar(this.video.fb32, dat, offset, this.pixelsPerChar, css);
+                            const textMode = (mode & MODE_AG) === 0; // 0x10 is the AG bit
+                            this.recordLineGrid(textMode);
+                            if (textMode) this.blitChar(this.video.fb32, dat, offset, this.pixelsPerChar, css);
                             else this.blitPixels(this.video.fb32, dat, offset, css);
                         }
                     }
@@ -619,6 +626,41 @@ export class Video6847 {
         }
     }
 
+    /**
+     * Precompute this mode's grid descriptors, one per blitter.
+     *
+     * The two blitters derive their widths differently and cannot be unified:
+     * `blitChar` splits the character's texels across eight glyph bits, while
+     * `blitPixels` takes the bit width from the mode table — which for text
+     * mode holds -1, since it does not blit pixels at all.
+     *
+     * `pixelsPerBit` is right for graphics at 2bpp as well as 1bpp: the blitter
+     * steps its bit groups by `pixelsPerBit / bpp`, but reads the colour with
+     * `j & 0xe`, so pairs of groups share one and each pixel is twice as wide.
+     */
+    updateLineGrid() {
+        // Every 6847 blitter writes each pixel row into two framebuffer lines.
+        // Text mode's entry is only reachable through blitChar, which is just
+        // as well: the mode table holds -1 for it and would not encode.
+        this.lineGridText = encodeLineGrid((this.pixelsPerChar * this.bitmapPxPerPixel) / 8, true);
+        this.lineGridGraphics = this.pixelsPerBit > 0 ? encodeLineGrid(this.pixelsPerBit, true) : this.lineGridText;
+    }
+
+    /**
+     * Note the logical pixel size of the two rows about to be written, so
+     * display filters can see the picture as pixels rather than as raster
+     * samples (see video-filters/pixel-grid.js). Only the picture records a
+     * grid: the border is a solid colour, and letting it write here would
+     * leave the row describing the border rather than the picture on it.
+     *
+     * @param {boolean} textMode whether the character blitter is about to run
+     */
+    recordLineGrid(textMode) {
+        const grid = textMode ? this.lineGridText : this.lineGridGraphics;
+        this.video.lineGrid[this.bitmapY] = grid;
+        this.video.lineGrid[this.bitmapY + 1] = grid;
+    }
+
     blitChar(buf, data, destOffset, numPixels, css) {
         const scanline = this.scanlineCounter;
         const chr = data & 0x7f;

package/src/acia.js

@@ -5,10 +5,10 @@
 // http://www.classiccmp.org/dunfield/r/6850.pdf
 
 export class Acia {
-    constructor(cpu, toneGen, scheduler, rs423Handler, relayNoise) {
+    constructor(cpu, toneGen, scheduler, relayNoise) {
         this.cpu = cpu;
         this.toneGen = toneGen;
-        this.rs423Handler = rs423Handler;
+        this.rs423Handler = null;
         this.relayNoise = relayNoise;
 
         this.sr = 0x00;
@@ -22,17 +22,27 @@ export class Acia {
         this.hadDcdHigh = false;
         this.serialReceiveRate = 0;
         this.serialReceiveCyclesPerByte = 0;
+        this.serialTransmitRate = 0;
+        this.serialTransmitCyclesPerByte = 0;
 
         this.setSerialReceive(19200);
+        this.setSerialTransmit(19200);
         this.txCompleteTask = scheduler.newTask(() => {
             this.sr |= 0x02; // set the TDRE
+            this.updateIrq();
         });
         this.runTapeTask = scheduler.newTask(() => this.runTape());
         this.runRs423Task = scheduler.newTask(() => this.runRs423());
     }
 
+    // MC6850: the transmit interrupt is selected by CR6:CR5 = 01 and follows
+    // TDRE, which a high CTS inhibits.
+    txIrq() {
+        return (this.cr & 0x60) === 0x20 && (this.sr & 0x0a) === 0x02;
+    }
+
     updateIrq() {
-        if (this.sr & this.cr & 0x80) {
+        if (this.sr & this.cr & 0x80 || this.txIrq()) {
             this.cpu.interrupt |= 0x04;
         } else {
             this.cpu.interrupt &= ~0x04;
@@ -77,6 +87,7 @@ export class Acia {
             return this.dr;
         } else {
             let result = (this.sr & 0x7f) | (this.sr & this.cr & 0x80);
+            if (this.txIrq()) result |= 0x80;
             // MC6850: "A low CTS indicates that there is a Clear-to-Send
             // from the modem. In the high state, the Transmit Data Register
             // Empty bit is inhibited".
@@ -100,10 +111,7 @@ export class Acia {
     write(addr, val) {
         if (addr & 1) {
             this.sr &= ~0x02;
-            // It's not clear how long this can take; it's when the shift register is loaded.
-            // That could be straight away if not already tx-ing, but as we don't really tx,
-            // be conservative here.
-            this.txCompleteTask.reschedule(2000);
+            this.txCompleteTask.reschedule(this.serialTransmitCyclesPerByte);
             this.updateIrq();
             if (this.rs423Selected && this.rs423Handler) this.rs423Handler.onTransmit(val);
         } else {
@@ -114,6 +122,8 @@ export class Acia {
             } else {
                 this.cr = val;
                 this.setSerialReceive(this.serialReceiveRate);
+                this.setSerialTransmit(this.serialTransmitRate);
+                this.updateIrq();
             }
         }
     }
@@ -212,7 +222,7 @@ export class Acia {
             tapeDcdLineLevel: this.tapeDcdLineLevel,
             hadDcdHigh: this.hadDcdHigh,
             serialReceiveRate: this.serialReceiveRate,
-            serialReceiveCyclesPerByte: this.serialReceiveCyclesPerByte,
+            serialTransmitRate: this.serialTransmitRate,
             txCompleteTaskOffset: this.txCompleteTask.scheduled()
                 ? this.txCompleteTask.expireEpoch - scheduler.epoch
                 : null,
@@ -230,8 +240,10 @@ export class Acia {
         this.tapeCarrierCount = state.tapeCarrierCount;
         this.tapeDcdLineLevel = state.tapeDcdLineLevel;
         this.hadDcdHigh = state.hadDcdHigh;
-        this.serialReceiveRate = state.serialReceiveRate;
-        this.serialReceiveCyclesPerByte = state.serialReceiveCyclesPerByte;
+        // The byte times are derived from the rates and the restored word format, not saved.
+        this.setSerialReceive(state.serialReceiveRate);
+        // Snapshots predating transmit timing have no saved rate.
+        this.setSerialTransmit(state.serialTransmitRate ?? 19200);
         this.updateIrq();
 
         this.txCompleteTask.cancel();
@@ -253,8 +265,9 @@ export class Acia {
         }
     }
 
+    // Byte times are held in CPU cycles because that's what the scheduler counts.
     secondsToCycles(sec) {
-        return Math.floor(2 * 1000 * 1000 * sec) | 0;
+        return Math.floor(this.cpu.model.cyclesPerSecond * sec) | 0;
     }
 
     numBitsPerByte() {
@@ -294,7 +307,8 @@ export class Acia {
                 parityBits = 1;
                 break;
         }
-        return wordLength + stopBits + parityBits;
+        const startBits = 1;
+        return startBits + wordLength + stopBits + parityBits;
     }
 
     rts() {
@@ -307,6 +321,11 @@ export class Acia {
         this.serialReceiveCyclesPerByte = this.secondsToCycles(this.numBitsPerByte() / rate);
     }
 
+    setSerialTransmit(rate) {
+        this.serialTransmitRate = rate;
+        this.serialTransmitCyclesPerByte = this.secondsToCycles(this.numBitsPerByte() / rate);
+    }
+
     runTape() {
         if (this.tape) this.runTapeTask.reschedule(this.tape.poll(this));
     }