jsbeeb 1.4.0 → 1.6.0

package/package.json

@@ -7,7 +7,7 @@
   "name": "jsbeeb",
   "description": "Emulate a BBC Micro",
   "repository": "git@github.com:mattgodbolt/jsbeeb.git",
-  "version": "1.4.0",
+  "version": "1.6.0",
   "//": "If you change the version of Node, it must also be updated at the top of the Dockerfile.",
   "engines": {
     "node": "22"

package/src/6502.js

@@ -101,12 +101,12 @@ class Flags {
 }
 
 class Base6502 {
-    constructor(model) {
+    constructor(model, { cycleAccurate = true } = {}) {
         this.model = model;
         this.a = this.x = this.y = this.s = 0;
         this.p = new Flags();
         this.pc = 0;
-        this.opcodes = model.opcodesFactory(this);
+        this.opcodes = model.opcodesFactory(this, { cycleAccurate });
         this.disassembler = this.opcodes.disassembler;
         this.forceTracing = false;
         this.runner = this.opcodes.runInstruction;
@@ -405,9 +405,10 @@ class Base6502 {
 
 class Tube6502 extends Base6502 {
     constructor(model, cpu) {
-        super(model);
+        super(model, { cycleAccurate: false });
 
         this.cycles = 0;
+        this.cpuMultiplier = 2;
         this.romPaged = true;
         this.memory = new Uint8Array(65536);
         this.rom = new Uint8Array(4096);
@@ -468,7 +469,7 @@ class Tube6502 extends Base6502 {
     }
 
     execute(cycles) {
-        this.cycles += cycles * 2;
+        this.cycles += (cycles * this.cpuMultiplier) | 0;
         if (this.cycles < 3) return;
         while (this.cycles > 0) {
             const opcode = this.readmem(this.pc);
@@ -570,19 +571,22 @@ function is1MHzAccess(addr) {
 }
 
 export class Cpu6502 extends Base6502 {
-    constructor(model, dbgr, video_, soundChip_, ddNoise_, music5000_, cmos, config, econet_) {
-        super(model);
+    constructor(
+        model,
+        { dbgr, video, soundChip, ddNoise, music5000, cmos, config, econet, cycleAccurate = true } = {},
+    ) {
+        super(model, { cycleAccurate });
         this.config = fixUpConfig(config);
         this.debugFlags = this.config.debugFlags;
         this.cmos = cmos;
         this.debugger = dbgr;
 
-        this.video = video_;
+        this.video = video;
         this.crtc = this.video.crtc;
         this.ula = this.video.ula;
-        this.soundChip = soundChip_;
-        this.music5000 = music5000_;
-        this.ddNoise = ddNoise_;
+        this.soundChip = soundChip;
+        this.music5000 = music5000;
+        this.ddNoise = ddNoise;
         this.memStatOffsetByIFetchBank = 0;
         this.memStatOffset = 0;
         this.memStat = new Uint8Array(512);
@@ -602,8 +606,11 @@ export class Cpu6502 extends Base6502 {
         this.videoCyclesBatch = this.config.videoCyclesBatch | 0;
         this.peripheralCyclesPerSecond = 2 * 1000 * 1000;
         this.tube = model.tube ? new Tube6502(model.tube, this) : new FakeTube();
+        if (model.tube && this.config.tubeCpuMultiplier) {
+            this.tube.cpuMultiplier = this.config.tubeCpuMultiplier;
+        }
         this.music5000PageSel = 0;
-        this.econet = econet_;
+        this.econet = econet;
 
         this.peripheralCycles = 0;
         this.videoCycles = 0;
@@ -616,16 +623,14 @@ export class Cpu6502 extends Base6502 {
         this.debugWrite = new DebugHook(this, "_debugWrite");
 
         this.scheduler = new Scheduler();
-        this.sysvia = new via.SysVia(
-            this,
-            this.scheduler,
-            this.video,
-            this.soundChip,
-            this.cmos,
-            this.model.isMaster,
-            this.config.keyLayout,
-            this.config.getGamepads,
-        );
+        this.sysvia = new via.SysVia(this, this.scheduler, {
+            video: this.video,
+            soundChip: this.soundChip,
+            cmos: this.cmos,
+            isMaster: this.model.isMaster,
+            initialLayout: this.config.keyLayout,
+            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.serial = new Serial(this.acia);
@@ -1125,6 +1130,90 @@ export class Cpu6502 extends Base6502 {
         this.resetLine = !resetOn;
     }
 
+    snapshotState() {
+        return {
+            // CPU registers
+            a: this.a,
+            x: this.x,
+            y: this.y,
+            s: this.s,
+            pc: this.pc,
+            p: this.p.asByte(),
+            nmiLevel: this._nmiLevel,
+            nmiEdge: this._nmiEdge,
+            halted: this.halted,
+            takeInt: this.takeInt,
+            // Memory control
+            romsel: this.romsel,
+            acccon: this.acccon,
+            videoDisplayPage: this.videoDisplayPage,
+            // Cycle tracking
+            currentCycles: this.currentCycles,
+            targetCycles: this.targetCycles,
+            cycleSeconds: this.cycleSeconds,
+            peripheralCycles: this.peripheralCycles,
+            videoCycles: this.videoCycles,
+            music5000PageSel: this.music5000PageSel,
+            // RAM only (ROMs don't change at runtime)
+            ram: this.ramRomOs.slice(0, this.romOffset),
+            // Sub-component state
+            scheduler: this.scheduler.snapshotState(),
+            sysvia: this.sysvia.snapshotState(),
+            uservia: this.uservia.snapshotState(),
+            video: this.video.snapshotState(),
+            soundChip: this.soundChip.snapshotState(),
+            acia: this.acia.snapshotState(),
+            adc: this.adconverter.snapshotState(),
+        };
+    }
+
+    restoreState(state) {
+        // 1. Scheduler epoch first (so task offsets resolve correctly)
+        this.scheduler.restoreState(state.scheduler);
+
+        // 2. CPU registers
+        this.a = state.a;
+        this.x = state.x;
+        this.y = state.y;
+        this.s = state.s;
+        this.pc = state.pc;
+        this.p.setFromByte(state.p);
+        // interrupt is rebuilt by sub-component restores (VIA updateIFR, ACIA updateIrq)
+        this.interrupt = 0;
+        this._nmiLevel = state.nmiLevel;
+        this._nmiEdge = state.nmiEdge;
+        this.halted = state.halted;
+        this.takeInt = state.takeInt;
+
+        // 3. Memory
+        this.ramRomOs.set(state.ram);
+        // Load ROMs if present (e.g. from BEM snapshot import)
+        if (state.roms) {
+            this.ramRomOs.set(state.roms.slice(0, 16 * 16384), this.romOffset);
+        }
+        this.videoDisplayPage = state.videoDisplayPage;
+        this.music5000PageSel = state.music5000PageSel;
+
+        // 4. Rebuild memStat/memLook from romsel/acccon
+        this.romSelect(state.romsel);
+        if (this.model.isMaster) this.writeAcccon(state.acccon);
+
+        // 5. Cycle tracking
+        this.currentCycles = state.currentCycles;
+        this.targetCycles = state.targetCycles;
+        this.cycleSeconds = state.cycleSeconds;
+        this.peripheralCycles = state.peripheralCycles;
+        this.videoCycles = state.videoCycles;
+
+        // 6. Sub-components (these re-register scheduler tasks)
+        this.sysvia.restoreState(state.sysvia);
+        this.uservia.restoreState(state.uservia);
+        this.video.restoreState(state.video);
+        this.soundChip.restoreState(state.soundChip);
+        this.acia.restoreState(state.acia);
+        this.adconverter.restoreState(state.adc);
+    }
+
     reset(hard) {
         if (hard) {
             // On the Master, opcodes executing from 0xc000 - 0xdfff can optionally have their memory accesses

package/src/6502.opcodes.js

@@ -41,8 +41,9 @@ function push(reg) {
 }
 
 class InstructionGen {
-    constructor(is65c12) {
+    constructor(is65c12, cycleAccurate = true) {
         this.is65c12 = is65c12;
+        this.cycleAccurate = cycleAccurate;
         this.ops = {};
         this.cycle = 0;
     }
@@ -106,6 +107,10 @@ class InstructionGen {
     }
 
     spuriousOp(addr, reg) {
+        if (!this.cycleAccurate) {
+            this.cycle++;
+            return;
+        }
         if (this.is65c12) {
             this.readOp(addr, "", true);
         } else {
@@ -122,7 +127,7 @@ class InstructionGen {
                 toSkip++;
                 continue;
             }
-            if (toSkip && this.ops[i].exact) {
+            if (this.cycleAccurate && toSkip && this.ops[i].exact) {
                 if (this.ops[i].addr) {
                     out.push(`cpu.polltimeAddr(${toSkip}, ${this.ops[i].addr});`);
                 } else {
@@ -134,7 +139,7 @@ class InstructionGen {
             toSkip++;
         }
         if (toSkip) {
-            if (this.ops[this.cycle] && this.ops[this.cycle].addr) {
+            if (this.cycleAccurate && this.ops[this.cycle] && this.ops[this.cycle].addr) {
                 out.push(`cpu.polltimeAddr(${toSkip}, ${this.ops[this.cycle].addr});`);
             } else {
                 out.push(`cpu.polltime(${toSkip});`);
@@ -145,17 +150,17 @@ class InstructionGen {
     }
 
     split(condition) {
-        return new SplitInstruction(this, condition, this.is65c12);
+        return new SplitInstruction(this, condition, this.is65c12, this.cycleAccurate);
     }
 }
 
 class SplitInstruction {
-    constructor(preamble, condition, is65c12) {
+    constructor(preamble, condition, is65c12, cycleAccurate = true) {
         this.preamble = preamble;
         this.condition = condition;
-        this.ifTrue = new InstructionGen(is65c12);
+        this.ifTrue = new InstructionGen(is65c12, cycleAccurate);
         this.ifTrue.tick(preamble.cycle);
-        this.ifFalse = new InstructionGen(is65c12);
+        this.ifFalse = new InstructionGen(is65c12, cycleAccurate);
         this.ifFalse.tick(preamble.cycle);
 
         ["append", "prepend", "readOp", "writeOp", "spuriousOp"].forEach((op) => {
@@ -1052,7 +1057,7 @@ class Disassemble6502 {
     }
 }
 
-function makeCpuFunctions(cpu, opcodes, is65c12) {
+function makeCpuFunctions(cpu, opcodes, is65c12, cycleAccurate = true) {
     function getInstruction(opcodeString, needsReg) {
         const split = opcodeString.split(" ");
         const opcode = split[0];
@@ -1060,7 +1065,7 @@ function makeCpuFunctions(cpu, opcodes, is65c12) {
         const op = getOp(opcode, arg);
         if (!op) return null;
 
-        let ig = new InstructionGen(is65c12);
+        let ig = new InstructionGen(is65c12, cycleAccurate);
         if (needsReg) ig.append("let REG = 0|0;");
 
         switch (arg) {
@@ -1398,14 +1403,14 @@ ${indent}`)
     };
 }
 
-export function Cpu6502(cpu) {
-    return makeCpuFunctions(cpu, opcodes6502, false);
+export function Cpu6502(cpu, { cycleAccurate = true } = {}) {
+    return makeCpuFunctions(cpu, opcodes6502, false, cycleAccurate);
 }
 
-export function Cpu65c12(cpu) {
-    return makeCpuFunctions(cpu, opcodes65c12, true);
+export function Cpu65c12(cpu, { cycleAccurate = true } = {}) {
+    return makeCpuFunctions(cpu, opcodes65c12, true, cycleAccurate);
 }
 
-export function Cpu65c02(cpu) {
-    return makeCpuFunctions(cpu, opcodes65c02, true);
+export function Cpu65c02(cpu, { cycleAccurate = true } = {}) {
+    return makeCpuFunctions(cpu, opcodes65c02, true, cycleAccurate);
 }

package/src/acia.js

@@ -118,20 +118,34 @@ export class Acia {
     selectRs423(selected) {
         this.rs423Selected = !!selected;
         if (this.rs423Selected) {
-            // RS423 selected.
-            // CTS is always high, meaning not Clear To Send. This is
-            // because we don't yet emulate anything on the "other end",
-            // so there is nothing to pull CTS low.
-            this.sr |= 0x08;
+            // When a handler is present it acts as the remote device and is
+            // always ready to receive, so CTS is low (active = clear to send).
+            // Without a handler there is nothing on the other end and CTS
+            // stays high, which inhibits TDRE so the OS output buffer drains
+            // silently rather than hanging.
+            if (this.rs423Handler) {
+                this.sr &= ~0x08; // CTS low — clear to send
+            } else {
+                this.sr |= 0x08; // CTS high — not connected
+            }
         } else {
-            // Cassette selected.
-            // CTS is always low, meaning actually Clear To Send.
+            // Cassette selected — CTS is always low (clear to send).
             this.sr &= ~0x08;
         }
         this.dcdLineUpdated();
         this.runRs423Task.ensureScheduled(this.rs423Selected, this.serialReceiveCyclesPerByte);
     }
 
+    /**
+     * Attach or detach an RS-423 peripheral handler at runtime.
+     * The handler must implement onTransmit(byte) and tryReceive(rts).
+     * If RS-423 is already selected, the CTS line is updated immediately.
+     */
+    setRs423Handler(handler) {
+        this.rs423Handler = handler;
+        if (this.rs423Selected) this.selectRs423(true);
+    }
+
     dcdLineUpdated() {
         // AUG: "It will always be low when the RS423 interface is selected".
         const level = this.rs423Selected ? false : this.tapeDcdLineLevel;
@@ -183,6 +197,48 @@ export class Acia {
         this.updateIrq();
     }
 
+    snapshotState() {
+        const scheduler = this.txCompleteTask.scheduler;
+        return {
+            sr: this.sr,
+            cr: this.cr,
+            dr: this.dr,
+            rs423Selected: this.rs423Selected,
+            motorOn: this.motorOn,
+            tapeCarrierCount: this.tapeCarrierCount,
+            tapeDcdLineLevel: this.tapeDcdLineLevel,
+            hadDcdHigh: this.hadDcdHigh,
+            serialReceiveRate: this.serialReceiveRate,
+            serialReceiveCyclesPerByte: this.serialReceiveCyclesPerByte,
+            txCompleteTaskOffset: this.txCompleteTask.scheduled()
+                ? this.txCompleteTask.expireEpoch - scheduler.epoch
+                : null,
+            runTapeTaskOffset: this.runTapeTask.scheduled() ? this.runTapeTask.expireEpoch - scheduler.epoch : null,
+            runRs423TaskOffset: this.runRs423Task.scheduled() ? this.runRs423Task.expireEpoch - scheduler.epoch : null,
+        };
+    }
+
+    restoreState(state) {
+        this.sr = state.sr;
+        this.cr = state.cr;
+        this.dr = state.dr;
+        this.rs423Selected = state.rs423Selected;
+        this.motorOn = state.motorOn;
+        this.tapeCarrierCount = state.tapeCarrierCount;
+        this.tapeDcdLineLevel = state.tapeDcdLineLevel;
+        this.hadDcdHigh = state.hadDcdHigh;
+        this.serialReceiveRate = state.serialReceiveRate;
+        this.serialReceiveCyclesPerByte = state.serialReceiveCyclesPerByte;
+        this.updateIrq();
+
+        this.txCompleteTask.cancel();
+        this.runTapeTask.cancel();
+        this.runRs423Task.cancel();
+        if (state.txCompleteTaskOffset !== null) this.txCompleteTask.schedule(state.txCompleteTaskOffset);
+        if (state.runTapeTaskOffset !== null) this.runTapeTask.schedule(state.runTapeTaskOffset);
+        if (state.runRs423TaskOffset !== null) this.runRs423Task.schedule(state.runRs423TaskOffset);
+    }
+
     setTape(tape) {
         this.tape = tape;
     }

package/src/adc.js

@@ -99,6 +99,28 @@ export class Adc {
         }
     }
 
+    snapshotState() {
+        const scheduler = this.task.scheduler;
+        return {
+            status: this.status,
+            low: this.low,
+            high: this.high,
+            taskOffset: this.task.scheduled() ? this.task.expireEpoch - scheduler.epoch : null,
+        };
+    }
+
+    restoreState(state) {
+        this.status = state.status;
+        this.low = state.low;
+        this.high = state.high;
+        this.task.cancel();
+        if (state.taskOffset !== null) {
+            this.task.schedule(state.taskOffset);
+            // Conversion in progress: CB1 should be high (set by write(), cleared by onComplete())
+            this.sysvia.setcb1(true);
+        }
+    }
+
     /**
      * Read from the ADC registers
      * @param {number} addr - The address to read from

package/src/app/app.js

@@ -230,6 +230,30 @@ const template = [
                 click: showModal("configuration"),
             },
             { type: "separator" },
+            {
+                label: "Save State...",
+                accelerator: "CmdOrCtrl+S",
+                click: sendAction("save-state"),
+            },
+            {
+                label: "Load State...",
+                accelerator: "CmdOrCtrl+O",
+                click: async (_, browserWindow) => {
+                    const result = await dialog.showOpenDialog(browserWindow, {
+                        title: "Load emulator state",
+                        filters: [
+                            { name: "Snapshot files", extensions: ["gz", "json", "snp"] },
+                            { name: "All files", extensions: ["*"] },
+                        ],
+                        properties: ["openFile"],
+                    });
+                    if (!result.canceled) {
+                        const filePath = getFileParam(result.filePaths[0]);
+                        browserWindow.webContents.send("load-state", { path: filePath });
+                    }
+                },
+            },
+            { type: "separator" },
             {
                 label: "Soft Reset",
                 click: sendAction("soft-reset"),

package/src/app/electron.js

@@ -6,7 +6,7 @@
 export let initialise = function () {};
 
 function init(args) {
-    const { loadDiscImage, loadTapeImage, processor, modals, actions, config } = args;
+    const { loadDiscImage, loadTapeImage, loadStateFile, processor, modals, actions, config } = args;
     const api = window.electronAPI;
 
     api.onLoadDisc(async (message) => {
@@ -34,6 +34,15 @@ function init(args) {
         }
     });
 
+    api.onLoadState(async (message) => {
+        if (loadStateFile) {
+            const response = await fetch(message.path);
+            const blob = await response.blob();
+            const file = new File([blob], message.path.split("/").pop());
+            await loadStateFile(file);
+        }
+    });
+
     // Observe model name changes and update window title
     const modelElement = document.querySelector(".bbc-model");
     if (modelElement) {

package/src/app/preload.js

@@ -7,6 +7,7 @@ contextBridge.exposeInMainWorld("electronAPI", {
     onLoadTape: (callback) => ipcRenderer.on("load-tape", (event, message) => callback(message)),
     onShowModal: (callback) => ipcRenderer.on("show-modal", (event, message) => callback(message)),
     onAction: (callback) => ipcRenderer.on("action", (event, message) => callback(message)),
+    onLoadState: (callback) => ipcRenderer.on("load-state", (event, message) => callback(message)),
     setTitle: (title) => ipcRenderer.send("set-title", title),
     saveSettings: (settings) => ipcRenderer.send("save-settings", settings),
 });

package/src/bbc-palette.js

@@ -0,0 +1,24 @@
+"use strict";
+
+// The 16 standard BBC Micro colours in ABGR format (0xffBBGGRR, little-endian canvas RGBA).
+// Colours 0-7 are the primary palette; 8-15 duplicate them as the default solid/non-flash set.
+// Imported by both video.js (NulaDefaultPalette) and teletext.js (BbcDefaultCollook) to avoid
+// circular imports between those two modules.
+export const BbcDefaultPalette = new Uint32Array([
+    0xff000000, // 0: black
+    0xff0000ff, // 1: red
+    0xff00ff00, // 2: green
+    0xff00ffff, // 3: yellow
+    0xffff0000, // 4: blue
+    0xffff00ff, // 5: magenta
+    0xffffff00, // 6: cyan
+    0xffffffff, // 7: white
+    0xff000000, // 8: black (solid duplicate)
+    0xff0000ff, // 9: red
+    0xff00ff00, // 10: green
+    0xff00ffff, // 11: yellow
+    0xffff0000, // 12: blue
+    0xffff00ff, // 13: magenta
+    0xffffff00, // 14: cyan
+    0xffffffff, // 15: white
+]);