jsbeeb 1.4.0 → 1.5.0

package/src/main.js

@@ -27,6 +27,7 @@ import { toHfe } from "./disc-hfe.js";
 import { Keyboard } from "./keyboard.js";
 import { GamepadSource } from "./gamepad-source.js";
 import { MicrophoneInput } from "./microphone-input.js";
+import { SpeechOutput } from "./speech-output.js";
 import { MouseJoystickSource } from "./mouse-joystick-source.js";
 import { getFilterForMode } from "./canvas.js";
 import {
@@ -97,6 +98,7 @@ const paramTypes = {
     logFdcStateChanges: ParamTypes.BOOL,
     coProcessor: ParamTypes.BOOL,
     mouseJoystickEnabled: ParamTypes.BOOL,
+    speechOutput: ParamTypes.BOOL,
 
     // Numeric parameters
     speed: ParamTypes.INT,
@@ -105,6 +107,7 @@ const paramTypes = {
     audiofilterfreq: ParamTypes.FLOAT,
     audiofilterq: ParamTypes.FLOAT,
     cpuMultiplier: ParamTypes.FLOAT,
+    tubeCpuMultiplier: ParamTypes.INT,
     microphoneChannel: ParamTypes.INT,
 
     // String parameters (these are the default but listed for clarity)
@@ -125,7 +128,6 @@ let keyLayout = window.localStorage.keyLayout || "physical";
 
 const BBC = utils.BBC;
 const keyCodes = utils.keyCodes;
-const emuKeyHandlers = {};
 let cpuMultiplier = 1;
 let fastAsPossible = false;
 let fastTape = false;
@@ -181,33 +183,22 @@ const printerPort = {
     },
 };
 
-let userPort = null;
+// Accessibility switch state — bits 0-7 correspond to switches 1-8.
+// Active low: 0xff = no switches pressed; clearing a bit = that switch is pressed.
+let switchState = 0xff;
 
-const keyswitch = true;
-if (keyswitch) {
-    let switchState = 0xff;
-
-    const switchKey = function (down, code) {
-        const bit = 1 << (code - utils.keyCodes.K1);
-        if (down) switchState &= 0xff ^ bit;
-        else switchState |= bit;
-    };
-
-    for (let idx = utils.keyCodes.K1; idx <= utils.keyCodes.K8; ++idx) {
-        emuKeyHandlers[idx] = switchKey;
-    }
-    userPort = {
-        write: function () {},
-        read: function () {
-            return switchState;
-        },
-    };
-}
+const userPort = {
+    write() {},
+    read() {
+        return switchState;
+    },
+};
 
 const emulationConfig = {
     keyLayout: keyLayout,
     coProcessor: parsedQuery.coProcessor,
     cpuMultiplier: cpuMultiplier,
+    tubeCpuMultiplier: parsedQuery.tubeCpuMultiplier || 2,
     videoCyclesBatch: parsedQuery.videoCyclesBatch,
     extraRoms: extraRoms,
     userPort: userPort,
@@ -222,6 +213,11 @@ const emulationConfig = {
     },
 };
 
+// Speech output: initialised from URL param; can be toggled at runtime via the Settings panel.
+// Must be created before Config so the onClose callback and setSpeechOutput() call can reference it.
+const speechOutput = new SpeechOutput();
+speechOutput.enabled = !!parsedQuery.speechOutput;
+
 const config = new Config(
     function onChange(changed) {
         if (changed.displayMode) {
@@ -263,6 +259,16 @@ const config = new Config(
                 setupMicrophone().then(() => {});
             }
         }
+        if (changed.speechOutput !== undefined) {
+            speechOutput.enabled = !!changed.speechOutput;
+        }
+        if (changed.tubeCpuMultiplier !== undefined) {
+            emulationConfig.tubeCpuMultiplier = changed.tubeCpuMultiplier;
+            config.setTubeCpuMultiplier(changed.tubeCpuMultiplier);
+            if (processor.tube && processor.tube.cpuMultiplier !== undefined) {
+                processor.tube.cpuMultiplier = changed.tubeCpuMultiplier;
+            }
+        }
         updateUrl();
     },
 );
@@ -273,11 +279,13 @@ config.mapLegacyModels(parsedQuery);
 config.setModel(parsedQuery.model || guessModelFromHostname(window.location.hostname));
 config.setKeyLayout(keyLayout);
 config.set65c02(parsedQuery.coProcessor);
+config.setTubeCpuMultiplier(parsedQuery.tubeCpuMultiplier || 2);
 config.setEconet(parsedQuery.hasEconet);
 config.setMusic5000(parsedQuery.hasMusic5000);
 config.setTeletext(parsedQuery.hasTeletextAdaptor);
 config.setMicrophoneChannel(parsedQuery.microphoneChannel);
 config.setMouseJoystickEnabled(parsedQuery.mouseJoystickEnabled);
+config.setSpeechOutput(speechOutput.enabled);
 let displayMode = parsedQuery.displayMode || "rgb";
 config.setDisplayMode(displayMode);
 
@@ -362,7 +370,13 @@ video = new Video(model.isMaster, canvas.fb32, function paint(minx, miny, maxx,
 if (parsedQuery.fakeVideo !== undefined) video = new FakeVideo();
 
 const audioStatsNode = document.getElementById("audio-stats");
-const audioHandler = new AudioHandler($("#audio-warning"), audioStatsNode, audioFilterFreq, audioFilterQ, noSeek);
+const audioHandler = new AudioHandler({
+    warningNode: $("#audio-warning"),
+    statsNode: audioStatsNode,
+    audioFilterFreq,
+    audioFilterQ,
+    noSeek,
+});
 if (!parsedQuery.audioDebug) audioStatsNode.style.display = "none";
 // Firefox will report that audio is suspended even when it will
 // start playing without user interaction, so we need to delay a
@@ -578,21 +592,19 @@ function checkPrinterWindow() {
     processor.uservia.setca1(true);
 }
 
-processor = new Cpu6502(
-    model,
+processor = new Cpu6502(model, {
     dbgr,
     video,
-    audioHandler.soundChip,
-    audioHandler.ddNoise,
-    model.hasMusic5000 ? audioHandler.music5000 : null,
+    soundChip: audioHandler.soundChip,
+    ddNoise: audioHandler.ddNoise,
+    music5000: model.hasMusic5000 ? audioHandler.music5000 : null,
     cmos,
-    emulationConfig,
+    config: emulationConfig,
     econet,
-);
+});
 
 // Create input sources
 const gamepadSource = new GamepadSource(emulationConfig.getGamepads);
-
 // Create MicrophoneInput but don't enable by default
 const microphoneInput = new MicrophoneInput();
 microphoneInput.setErrorCallback((message) => {
@@ -603,9 +615,28 @@ microphoneInput.setErrorCallback((message) => {
 const screenCanvas = document.getElementById("screen");
 const mouseJoystickSource = new MouseJoystickSource(screenCanvas);
 
+/**
+ * Attach an RS-423 composite handler to the ACIA that combines the touchscreen
+ * (which sends position data to the BBC) with the speech output (which speaks
+ * text the BBC sends out).  Call this once after processor.initialise() and
+ * again whenever speechOutput.enabled changes.
+ */
+function setupRs423Handler() {
+    const touchScreen = processor.touchScreen;
+    processor.acia.setRs423Handler({
+        onTransmit(val) {
+            touchScreen.onTransmit(val);
+            speechOutput.onTransmit(val);
+        },
+        tryReceive(rts) {
+            return touchScreen.tryReceive(rts);
+        },
+    });
+}
+
 // Helper to manage ADC source configuration
 function updateAdcSources(mouseJoystickEnabled, microphoneChannel) {
-    // Default all channels to gamepad
+    // Default all channels to the gamepad source.
     for (let ch = 0; ch < 4; ch++) {
         processor.adconverter.setChannelSource(ch, gamepadSource);
     }
@@ -753,6 +784,30 @@ keyboard.registerKeyHandler(
     { alt: false, ctrl: true },
 );
 
+// Register accessibility switch key handlers.
+// Keys 1–8 (K1–K8) and function keys F1–F8 both map to user port bits 0–7
+// (active low: pressing the key clears the corresponding bit in &FE60).
+//
+// On real hardware, the Brilliant Computing switch interface box and special-ed
+// joystick connect to the User Port only — they do not touch the analogue port
+// or the System VIA fire buttons (PB4/PB5), which belong to the standard
+// analogue joystick connector.  So we only update switchState here.
+{
+    const handleSwitch = (bit) => (down) => {
+        if (down) switchState &= ~(1 << bit);
+        else switchState |= 1 << bit;
+    };
+
+    // Alt+1–8 and Alt+F1–F8 trigger the switches.  Using Alt means the underlying
+    // key is never forwarded to the BBC Micro (keyboard.js bails out early when a
+    // handler fires), so typing numbers or using function keys works normally.
+    const altMod = { alt: true, ctrl: false };
+    for (let i = 0; i < 8; i++) {
+        keyboard.registerKeyHandler(utils.keyCodes.K1 + i, handleSwitch(i), altMod);
+        keyboard.registerKeyHandler(utils.keyCodes.F1 + i, handleSwitch(i), altMod);
+    }
+}
+
 // Setup key handlers
 document.addEventListener("keydown", (evt) => {
     audioHandler.tryResume().then(() => {});
@@ -825,6 +880,9 @@ async function tapeSthClick(item) {
 }
 
 const $sthModal = new bootstrap.Modal(document.getElementById("sth"));
+document.getElementById("sth").addEventListener("shown.bs.modal", () => {
+    document.getElementById("sth-filter").focus();
+});
 
 function makeOnCat(onClick) {
     return function (cat) {
@@ -1340,6 +1398,9 @@ syncLights = function () {
 const startPromise = (async () => {
     await Promise.all([audioHandler.initialise(), processor.initialise()]);
 
+    // Wire up the composite RS-423 handler now that the touchscreen exists.
+    setupRs423Handler();
+
     // Ideally would start the loads first. But their completion needs the FDC from the processor
     const imageLoads = [];
 

package/src/models.js

@@ -11,7 +11,7 @@ const CpuModel = Object.freeze({
 });
 
 class Model {
-    constructor(name, synonyms, os, cpuModel, isMaster, swram, fdc, tube, cmosOverride) {
+    constructor({ name, synonyms, os, cpuModel, isMaster, swram, fdc, tube, cmosOverride } = {}) {
         this.name = name;
         this.synonyms = synonyms;
         this.os = os;
@@ -97,77 +97,81 @@ const masterSwram = [
 ];
 
 export const allModels = [
-    new Model(
-        "BBC B with DFS 1.2",
-        ["B-DFS1.2"],
-        ["os.rom", "BASIC.ROM", "b/DFS-1.2.rom"],
-        CpuModel.MOS6502,
-        false,
-        beebSwram,
-        NoiseAwareIntelFdc,
-    ),
-    new Model(
-        "BBC B with DFS 0.9",
-        ["B-DFS0.9", "B"],
-        ["os.rom", "BASIC.ROM", "b/DFS-0.9.rom"],
-        CpuModel.MOS6502,
-        false,
-        beebSwram,
-        NoiseAwareIntelFdc,
-    ),
-    new Model(
-        "BBC B with 1770 (DFS)",
-        ["B1770"],
-        ["os.rom", "BASIC.ROM", "b1770/dfs1770.rom", "b1770/zADFS.ROM"],
-        CpuModel.MOS6502,
-        false,
-        beebSwram,
-        NoiseAwareWdFdc,
-    ),
+    new Model({
+        name: "BBC B with DFS 1.2",
+        synonyms: ["B-DFS1.2"],
+        os: ["os.rom", "BASIC.ROM", "b/DFS-1.2.rom"],
+        cpuModel: CpuModel.MOS6502,
+        isMaster: false,
+        swram: beebSwram,
+        fdc: NoiseAwareIntelFdc,
+    }),
+    new Model({
+        name: "BBC B with DFS 0.9",
+        synonyms: ["B-DFS0.9", "B"],
+        os: ["os.rom", "BASIC.ROM", "b/DFS-0.9.rom"],
+        cpuModel: CpuModel.MOS6502,
+        isMaster: false,
+        swram: beebSwram,
+        fdc: NoiseAwareIntelFdc,
+    }),
+    new Model({
+        name: "BBC B with 1770 (DFS)",
+        synonyms: ["B1770"],
+        os: ["os.rom", "BASIC.ROM", "b1770/dfs1770.rom", "b1770/zADFS.ROM"],
+        cpuModel: CpuModel.MOS6502,
+        isMaster: false,
+        swram: beebSwram,
+        fdc: NoiseAwareWdFdc,
+    }),
     // putting ADFS in a higher ROM slot gives it priority
-    new Model(
-        "BBC B with 1770 (ADFS)",
-        ["B1770A"],
-        ["os.rom", "BASIC.ROM", "b1770/zADFS.ROM", "b1770/dfs1770.rom"],
-        CpuModel.MOS6502,
-        false,
-        beebSwram,
-        NoiseAwareWdFdc,
-    ),
-    new Model(
-        "BBC Master 128 (DFS)",
-        ["Master"],
-        ["master/mos3.20"],
-        CpuModel.CMOS65C12,
-        true,
-        masterSwram,
-        NoiseAwareWdFdc,
-        null,
-        pickDfs,
-    ),
-    new Model(
-        "BBC Master 128 (ADFS)",
-        ["MasterADFS"],
-        ["master/mos3.20"],
-        CpuModel.CMOS65C12,
-        true,
-        masterSwram,
-        NoiseAwareWdFdc,
-        null,
-        pickAdfs,
-    ),
-    new Model(
-        "BBC Master 128 (ANFS)",
-        ["MasterANFS"],
-        ["master/mos3.20"],
-        CpuModel.CMOS65C12,
-        true,
-        masterSwram,
-        NoiseAwareWdFdc,
-        null,
-        pickAnfs,
-    ),
-    new Model("Tube65C02", [], ["tube/6502Tube.rom"], CpuModel.CMOS65C02, false), // Although this can not be explicitly selected as a model, it is required by the configuration builder later
+    new Model({
+        name: "BBC B with 1770 (ADFS)",
+        synonyms: ["B1770A"],
+        os: ["os.rom", "BASIC.ROM", "b1770/zADFS.ROM", "b1770/dfs1770.rom"],
+        cpuModel: CpuModel.MOS6502,
+        isMaster: false,
+        swram: beebSwram,
+        fdc: NoiseAwareWdFdc,
+    }),
+    new Model({
+        name: "BBC Master 128 (DFS)",
+        synonyms: ["Master"],
+        os: ["master/mos3.20"],
+        cpuModel: CpuModel.CMOS65C12,
+        isMaster: true,
+        swram: masterSwram,
+        fdc: NoiseAwareWdFdc,
+        cmosOverride: pickDfs,
+    }),
+    new Model({
+        name: "BBC Master 128 (ADFS)",
+        synonyms: ["MasterADFS"],
+        os: ["master/mos3.20"],
+        cpuModel: CpuModel.CMOS65C12,
+        isMaster: true,
+        swram: masterSwram,
+        fdc: NoiseAwareWdFdc,
+        cmosOverride: pickAdfs,
+    }),
+    new Model({
+        name: "BBC Master 128 (ANFS)",
+        synonyms: ["MasterANFS"],
+        os: ["master/mos3.20"],
+        cpuModel: CpuModel.CMOS65C12,
+        isMaster: true,
+        swram: masterSwram,
+        fdc: NoiseAwareWdFdc,
+        cmosOverride: pickAnfs,
+    }),
+    // Although this can not be explicitly selected as a model, it is required by the configuration builder later
+    new Model({
+        name: "Tube65C02",
+        synonyms: [],
+        os: ["tube/6502Tube.rom"],
+        cpuModel: CpuModel.CMOS65C02,
+        isMaster: false,
+    }),
 ];
 
 export function findModel(name) {
@@ -182,19 +186,43 @@ export function findModel(name) {
     return null;
 }
 
-export const TEST_6502 = new Model("TEST", ["TEST"], [], CpuModel.MOS6502, false, beebSwram, NoiseAwareIntelFdc);
+export const TEST_6502 = new Model({
+    name: "TEST",
+    synonyms: ["TEST"],
+    os: [],
+    cpuModel: CpuModel.MOS6502,
+    isMaster: false,
+    swram: beebSwram,
+    fdc: NoiseAwareIntelFdc,
+});
 TEST_6502.isTest = true;
-export const TEST_65C02 = new Model("TEST", ["TEST"], [], CpuModel.CMOS65C02, false, masterSwram, NoiseAwareIntelFdc);
+export const TEST_65C02 = new Model({
+    name: "TEST",
+    synonyms: ["TEST"],
+    os: [],
+    cpuModel: CpuModel.CMOS65C02,
+    isMaster: false,
+    swram: masterSwram,
+    fdc: NoiseAwareIntelFdc,
+});
 TEST_65C02.isTest = true;
-export const TEST_65C12 = new Model("TEST", ["TEST"], [], CpuModel.CMOS65C12, false, masterSwram, NoiseAwareIntelFdc);
+export const TEST_65C12 = new Model({
+    name: "TEST",
+    synonyms: ["TEST"],
+    os: [],
+    cpuModel: CpuModel.CMOS65C12,
+    isMaster: false,
+    swram: masterSwram,
+    fdc: NoiseAwareIntelFdc,
+});
 TEST_65C12.isTest = true;
 
-export const basicOnly = new Model(
-    "Basic only",
-    ["Basic only"],
-    ["master/mos3.20"],
-    CpuModel.CMOS65C12,
-    true,
-    masterSwram,
-    NoiseAwareWdFdc,
-);
+export const basicOnly = new Model({
+    name: "Basic only",
+    synonyms: ["Basic only"],
+    os: ["master/mos3.20"],
+    cpuModel: CpuModel.CMOS65C12,
+    isMaster: true,
+    swram: masterSwram,
+    fdc: NoiseAwareWdFdc,
+});

package/src/soundchip.js

@@ -288,6 +288,84 @@ export class SoundChip {
     }
 }
 
+/**
+ * InstrumentedSoundChip - wraps a real SoundChip and captures all writes
+ * for debugging purposes. Provides the same interface as SoundChip.
+ */
+export class InstrumentedSoundChip extends SoundChip {
+    constructor() {
+        super(() => {}); // no audio output callback needed in headless mode
+        this._capturedWrites = [];
+        this._capturing = false;
+        this._totalCycles = 0;
+    }
+
+    poke(value) {
+        if (this._capturing) {
+            this._capturedWrites.push({ cycle: this._totalCycles, value });
+        }
+        super.poke(value);
+    }
+
+    /** Start capturing SN76489 writes. Clears any previous capture. */
+    startCapture() {
+        this._capturedWrites = [];
+        this._capturing = true;
+    }
+
+    /** Stop capturing and return the captured writes. */
+    stopCapture() {
+        this._capturing = false;
+        return this._capturedWrites;
+    }
+
+    /** Get the captured writes without stopping. */
+    getCapturedWrites() {
+        return this._capturedWrites;
+    }
+
+    /** Clear captured writes. */
+    clearCapture() {
+        this._capturedWrites = [];
+    }
+
+    /** Track total cycles for timestamps. Called by the scheduler. */
+    advance(cycles) {
+        this._totalCycles += cycles;
+        super.advance(cycles);
+    }
+
+    /** Read current SN76489 register state in a friendly format. */
+    getState() {
+        return {
+            tone: [
+                this.registers[0],
+                this.registers[1],
+                this.registers[2],
+            ],
+            noise: this.registers[3],
+            volume: [
+                this._attenuationFromVolume(0),
+                this._attenuationFromVolume(1),
+                this._attenuationFromVolume(2),
+                this._attenuationFromVolume(3),
+            ],
+            lfsr: this.lfsr,
+            latchedRegister: this.latchedRegister,
+        };
+    }
+
+    /** Convert internal float volume back to 0-15 attenuation. */
+    _attenuationFromVolume(channel) {
+        const v = this.volume[channel];
+        // volumeTable[15] = 0 (silent), volumeTable[0] = loudest
+        for (let i = 0; i < 16; i++) {
+            if (Math.abs(volumeTable[i] - v) < 0.001) return i;
+        }
+        return 15; // silent
+    }
+}
+
 export class FakeSoundChip {
     reset() {}
 

package/src/speech-output.js

@@ -0,0 +1,85 @@
+"use strict";
+
+/**
+ * RS-423 handler that routes transmitted bytes to the Web Speech API.
+ *
+ * BBC programs use *FX3,1 (or *FX3,3) to send OSWRCH output to the RS-423
+ * serial port, which on real hardware fed a Votrax Type 'N Talk synthesiser.
+ * We intercept at the ACIA hardware boundary and route to speechSynthesis.
+ *
+ * Byte handling is based on the Votrax Type 'N Talk Operator's Manual (1981):
+ *  - Printable ASCII 0x20–0x7E: accumulated into the text buffer.
+ *  - CR (0x0D): "TALK-CLR" — speaks the buffer and clears it.  Multiple CR-
+ *    terminated lines queue naturally via speechSynthesis.speak().  A future
+ *    improvement could heuristically combine lines that arrive within a single
+ *    frame (~20 ms) into one utterance, which would give modern TTS engines a
+ *    better sentence to work with — but the simple per-line queue works well
+ *    enough and has no surprising pauses or dropped output.
+ *  - LF (0x0A): explicitly listed as null data in the manual; ignored.
+ *  - ESC (0x1B): unit-select prefix for daisy-chained TNT units.  ESC plus
+ *    the following byte are consumed silently (not passed to speechSynthesis).
+ *  - All other bytes: null data per the manual; ignored.
+ */
+
+// From the TNT Operator's Manual: "The input buffer can hold more than 750
+// characters".
+export const MAX_BUFFER = 750;
+
+export class SpeechOutput {
+    constructor() {
+        this._buffer = "";
+        this._escapeNext = false;
+        this._enabled = false;
+    }
+
+    get enabled() {
+        return this._enabled;
+    }
+
+    set enabled(value) {
+        this._enabled = !!value;
+        if (!this._enabled) {
+            this._buffer = "";
+            if (typeof speechSynthesis !== "undefined") speechSynthesis.cancel();
+        }
+    }
+
+    /** RS-423 handler interface: called for each byte the BBC transmits. */
+    onTransmit(byte) {
+        if (!this._enabled) return;
+
+        if (this._escapeNext) {
+            this._escapeNext = false;
+            return;
+        }
+
+        switch (byte) {
+            case 0x1b: // ESC — next byte is a unit-select code, not text.
+                this._escapeNext = true;
+                return;
+
+            case 0x0d: // CR — TALK-CLR: speak current buffer and clear it.
+                this._flush();
+                return;
+
+            default:
+                if (byte >= 0x20 && byte <= 0x7e) {
+                    this._buffer += String.fromCharCode(byte);
+                    if (this._buffer.length >= MAX_BUFFER) this._flush();
+                }
+            // Everything else is null data — silently ignored.
+        }
+    }
+
+    /** RS-423 handler interface: nothing to send back to the BBC. */
+    tryReceive() {
+        return -1;
+    }
+
+    _flush() {
+        const text = this._buffer.trim();
+        this._buffer = "";
+        if (!text || typeof speechSynthesis === "undefined") return;
+        speechSynthesis.speak(new SpeechSynthesisUtterance(text));
+    }
+}