jsbeeb 1.1.1

package/src/acia.js

@@ -0,0 +1,261 @@
+"use strict";
+// Some info:
+// http://www.playvectrex.com/designit/lecture/UP12.HTM
+// https://books.google.com/books?id=wUecAQAAQBAJ&pg=PA431&lpg=PA431&dq=acia+tdre&source=bl&ots=mp-yF-mK-P&sig=e6aXkFRfiIOb57WZmrvdIGsCooI&hl=en&sa=X&ei=0g2fVdDyFIXT-QG8-JD4BA&ved=0CCwQ6AEwAw#v=onepage&q=acia%20tdre&f=false
+// http://www.classiccmp.org/dunfield/r/6850.pdf
+
+export class Acia {
+    constructor(cpu, toneGen, scheduler, rs423Handler) {
+        this.cpu = cpu;
+        this.toneGen = toneGen;
+        this.rs423Handler = rs423Handler;
+
+        this.sr = 0x00;
+        this.cr = 0x00;
+        this.dr = 0x00;
+
+        this.rs423Selected = false;
+        this.motorOn = false;
+        this.tapeCarrierCount = 0;
+        this.tapeDcdLineLevel = false;
+        this.hadDcdHigh = false;
+        this.serialReceiveRate = 0;
+        this.serialReceiveCyclesPerByte = 0;
+
+        this.setSerialReceive(19200);
+        this.txCompleteTask = scheduler.newTask(() => {
+            this.sr |= 0x02; // set the TDRE
+        });
+        this.runTapeTask = scheduler.newTask(() => this.runTape());
+        this.runRs423Task = scheduler.newTask(() => this.runRs423());
+    }
+
+    updateIrq() {
+        if (this.sr & this.cr & 0x80) {
+            this.cpu.interrupt |= 0x04;
+        } else {
+            this.cpu.interrupt &= ~0x04;
+        }
+    }
+
+    reset() {
+        // TODO: testing on a real beeb seems to suggest that reset also
+        // clears CR bits (i.e. things stop working until CR is rewritten
+        // with sane value). This disagrees with the datasheet.
+        // CTS and DTD are based on external inputs so leave them alone.
+        this.sr &= 0x08 | 0x04;
+        // Reset clears the transmit register so raise the empty bit.
+        this.sr |= 0x02;
+        this.hadDcdHigh = false;
+        this.updateIrq();
+    }
+
+    tone(freq) {
+        if (!freq) this.toneGen.mute();
+        else this.toneGen.tone(freq);
+    }
+
+    setMotor(on) {
+        if (on && !this.motorOn) {
+            this.runTape();
+        } else if (!on && this.motorOn) {
+            this.toneGen.mute();
+            this.runTapeTask.cancel();
+            this.setTapeCarrier(false);
+        }
+        this.motorOn = on;
+    }
+
+    read(addr) {
+        if (addr & 1) {
+            this.sr &= ~0xa1;
+            this.hadDcdHigh = false;
+            this.updateIrq();
+            return this.dr;
+        } else {
+            let result = (this.sr & 0x7f) | (this.sr & this.cr & 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".
+            if (result & 0x08) {
+                result &= ~0x02;
+            }
+
+            // MC6850: "It remains high after the DCD input is returned low
+            // until cleared by first reading the Status Register and then
+            // the Data Register".
+            // Testing on a real machine shows that only the Data Register
+            // read matters, and clears the "saw DCD high" condition.
+            if (this.hadDcdHigh) {
+                result |= 0x04;
+            }
+
+            return result;
+        }
+    }
+
+    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.updateIrq();
+            if (this.rs423Selected && this.rs423Handler) this.rs423Handler.onTransmit(val);
+        } else {
+            if ((val & 0x03) === 0x03) {
+                // According to the 6850 docs writing 3 here doesn't affect any CR bits, but
+                // just resets the device.
+                this.reset();
+            } else {
+                this.cr = val;
+                this.setSerialReceive(this.serialReceiveRate);
+            }
+        }
+    }
+
+    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;
+        } else {
+            // Cassette selected.
+            // CTS is always low, meaning actually Clear To Send.
+            this.sr &= ~0x08;
+        }
+        this.dcdLineUpdated();
+        this.runRs423Task.ensureScheduled(this.rs423Selected, this.serialReceiveCyclesPerByte);
+    }
+
+    dcdLineUpdated() {
+        // AUG: "It will always be low when the RS423 interface is selected".
+        const level = this.rs423Selected ? false : this.tapeDcdLineLevel;
+
+        if (level && !(this.sr & 0x04)) {
+            // DCD interrupts on low -> high level change.
+            this.sr |= 0x84;
+            this.hadDcdHigh = true;
+        } else if (!level && this.sr & 0x04) {
+            this.sr &= ~0x04;
+        }
+        this.updateIrq();
+    }
+
+    setTapeCarrier(level) {
+        if (!level) {
+            this.tapeCarrierCount = 0;
+            this.tapeDcdLineLevel = false;
+        } else {
+            this.tapeCarrierCount++;
+            // The tape hardware doesn't raise DCD until the carrier tone
+            // has persisted for a while. The BBC service manual opines,
+            // "The DCD flag in the 6850 should change 0.1 to 0.4 seconds
+            // after a continuous tone appears".
+            // Star Drifter doesn't load without this.
+            // We use 0.174s, measured on an issue 3 model B.
+            // Testing on real hardware, DCD is blipped, it lowers about
+            // 210us after it raises, even though the carrier tone
+            // may be continuing.
+            this.tapeDcdLineLevel = this.tapeCarrierCount === 209;
+        }
+        this.dcdLineUpdated();
+    }
+
+    receive(byte) {
+        byte |= 0;
+        if (this.sr & 0x01) {
+            // Overrun.
+            // TODO: this doesn't match the datasheet:
+            // "The Overrun does not occur in the Status Register until the
+            // valid character prior to Overrun has been read."
+            console.log("Serial overrun");
+            this.sr |= 0xa0;
+        } else {
+            // If bit 7 contains parity, mask it off.
+            this.dr = byte & (this.cr & 0x10 ? 0xff : 0x7f);
+            this.sr |= 0x81;
+        }
+        this.updateIrq();
+    }
+
+    setTape(tape) {
+        this.tape = tape;
+    }
+
+    rewindTape() {
+        if (this.tape) {
+            console.log("rewinding tape");
+            this.tape.rewind();
+        }
+    }
+
+    secondsToCycles(sec) {
+        return Math.floor(2 * 1000 * 1000 * sec) | 0;
+    }
+
+    numBitsPerByte() {
+        const wordLength = this.cr & 0x10 ? 8 : 7;
+        let stopBits, parityBits;
+        switch ((this.cr >>> 2) & 7) {
+            case 0:
+                stopBits = 2;
+                parityBits = 1;
+                break;
+            case 1:
+                stopBits = 2;
+                parityBits = 1;
+                break;
+            case 2:
+                stopBits = 1;
+                parityBits = 1;
+                break;
+            case 3:
+                stopBits = 1;
+                parityBits = 1;
+                break;
+            case 4:
+                stopBits = 2;
+                parityBits = 0;
+                break;
+            case 5:
+                stopBits = 1;
+                parityBits = 0;
+                break;
+            case 6:
+                stopBits = 1;
+                parityBits = 1;
+                break;
+            case 7:
+                stopBits = 1;
+                parityBits = 1;
+                break;
+        }
+        return wordLength + stopBits + parityBits;
+    }
+
+    rts() {
+        // True iff CR6 = 0 or CR5 and CR6 are both 1.
+        return (this.cr & 0x40) === 0 || (this.cr & 0x60) === 0x60;
+    }
+
+    setSerialReceive(rate) {
+        this.serialReceiveRate = rate;
+        this.serialReceiveCyclesPerByte = this.secondsToCycles(this.numBitsPerByte() / rate);
+    }
+
+    runTape() {
+        if (this.tape) this.runTapeTask.reschedule(this.tape.poll(this));
+    }
+
+    runRs423() {
+        if (!this.rs423Handler) return;
+        const rcv = this.rs423Handler.tryReceive(this.rts());
+        if (rcv >= 0) this.receive(rcv);
+        this.runRs423Task.reschedule(this.serialReceiveCyclesPerByte);
+    }
+}

package/src/adc.js

@@ -0,0 +1,149 @@
+/**
+ * BBC Micro Analogue to Digital Converter (ADC)
+ * Handles input from analogue sources through various channels
+ *
+ * @typedef {import('./analogue-source.js').AnalogueSource} AnalogueSource
+ */
+export class Adc {
+    /**
+     * Create a new ADC
+     * @param {object} sysvia - System VIA interface
+     * @param {object} scheduler - Scheduler for timing operations
+     */
+    constructor(sysvia, scheduler) {
+        this.sysvia = sysvia;
+        this.task = scheduler.newTask(this.onComplete.bind(this));
+        this.status = 0x40;
+        this.low = 0x00;
+        this.high = 0x00;
+
+        // Initialize channel sources (one source per channel)
+        this.channelSources = [null, null, null, null];
+    }
+
+    /**
+     * Reset the ADC state
+     */
+    reset() {
+        this.status = 0x40;
+        this.low = 0x00;
+        this.high = 0x00;
+    }
+
+    /**
+     * Set the source for a specific channel
+     * @param {number} channel - The channel number (0-3)
+     * @param {AnalogueSource} source - The source to assign to the channel
+     * @returns {boolean} True if the assignment was successful
+     */
+    setChannelSource(channel, source) {
+        if (channel < 0 || channel > 3) {
+            console.error(`ADC: Invalid channel number: ${channel}`);
+            return false;
+        }
+
+        // Dispose of the old source if one exists and is different
+        const oldSource = this.channelSources[channel];
+        if (oldSource && oldSource !== source) {
+            oldSource.dispose();
+        }
+
+        // Set the channel source
+        this.channelSources[channel] = source;
+        return true;
+    }
+
+    /**
+     * Get the source for a specific channel
+     * @param {number} channel - The channel number (0-3)
+     * @returns {AnalogueSource|null} The source for the channel or null if none
+     */
+    getChannelSource(channel) {
+        if (channel < 0 || channel > 3) {
+            return null;
+        }
+        return this.channelSources[channel];
+    }
+
+    /**
+     * Clear the source for a specific channel
+     * @param {number} channel - The channel number (0-3)
+     * @returns {boolean} True if successful
+     */
+    clearChannelSource(channel) {
+        if (channel < 0 || channel > 3) {
+            console.error(`ADC: Invalid channel number: ${channel}`);
+            return false;
+        }
+
+        const source = this.channelSources[channel];
+        if (source) {
+            source.dispose();
+            this.channelSources[channel] = null;
+        }
+
+        return true;
+    }
+
+    /**
+     * Clear all sources
+     */
+    clearSources() {
+        // Dispose and clear all channel sources
+        for (let i = 0; i < 4; i++) {
+            const source = this.channelSources[i];
+            if (source) {
+                source.dispose();
+                this.channelSources[i] = null;
+            }
+        }
+    }
+
+    /**
+     * Read from the ADC registers
+     * @param {number} addr - The address to read from
+     * @returns {number} The value at the address
+     */
+    read(addr) {
+        switch (addr & 3) {
+            case 0:
+                return this.status;
+            case 1:
+                return this.high;
+            case 2:
+                return this.low;
+            default:
+                break;
+        }
+        return 0x40;
+    }
+
+    /**
+     * Write to the ADC control register
+     * @param {number} addr - The address to write to
+     * @param {number} val - The value to write
+     */
+    write(addr, val) {
+        if ((addr & 3) !== 0) return;
+        // 8 bit conversion takes 4ms whereas 10 bit conversions take 10ms, according to AUG
+        this.task.cancel();
+        this.task.schedule(val & 0x08 ? 20000 : 8000);
+        this.status = (val & 0x0f) | 0x80;
+        this.sysvia.setcb1(true);
+    }
+
+    /**
+     * Called when the ADC conversion is complete
+     */
+    onComplete() {
+        const channel = this.status & 0x03;
+
+        const source = this.channelSources[channel];
+        const val = source ? source.getValue(channel) : 0x8000;
+
+        this.status = (this.status & 0x0f) | 0x40 | ((val >>> 10) & 0x03);
+        this.low = val & 0xff;
+        this.high = (val >>> 8) & 0xff;
+        this.sysvia.setcb1(false);
+    }
+}

package/src/analogue-source.js

@@ -0,0 +1,21 @@
+/**
+ * Base interface for analog input sources for the BBC Micro's ADC
+ * @abstract
+ */
+export class AnalogueSource {
+    /**
+     * Get the current value for the specified channel
+     * @param {number} channel - The ADC channel (0-3)
+     * @returns {number} A value between 0 and 0xffff
+     */
+    getValue(_channel) {
+        throw new Error("Method not implemented");
+    }
+
+    /**
+     * Clean up resources when source is no longer needed
+     */
+    dispose() {
+        // Optional cleanup method
+    }
+}

package/src/app/app.js

@@ -0,0 +1,175 @@
+"use strict";
+import { app, BrowserWindow, dialog, Menu, shell, nativeImage } from "electron";
+import * as fs from "fs";
+import * as path from "path";
+import { ArgumentParser } from "argparse";
+
+const isMac = process.platform === "darwin";
+
+function getArguments() {
+    // Heinous hack to get "built" versions working
+    let args;
+    if (path.basename(process.argv[0]) === "jsbeeb")
+        // Is this ia "built" version?
+        args = process.argv.slice(1);
+    else args = process.argv.slice(2);
+
+    // Filter out Chrome switches that appear in process.argv. The snap wrapper
+    // adds --no-sandbox for compatibility, and `--disable-gpu` might be useful.
+    // Note that we don't support snap any more, but these seemed useful to leave.
+    const ignoredChromeFlags = ["--no-sandbox", "--disable-gpu"];
+    return args.filter((arg) => !ignoredChromeFlags.includes(arg));
+}
+
+const parser = new ArgumentParser({
+    prog: "jsbeeb",
+    add_help: true,
+    description: "Emulate a Beeb",
+});
+parser.add_argument("--noboot", {
+    action: "store_true",
+    help: "don't autoboot if given a disc image",
+});
+parser.add_argument("disc1", {
+    nargs: "?",
+    help: "image to load in drive 0",
+});
+parser.add_argument("disc2", {
+    nargs: "?",
+    help: "image to load in drive 1",
+});
+const args = parser.parse_args(getArguments());
+
+function getFileParam(filename) {
+    try {
+        return "file://" + fs.realpathSync(filename);
+    } catch (e) {
+        console.error("Unable to open file " + filename);
+        throw e;
+    }
+}
+
+async function createWindow() {
+    const iconPath = path.join(import.meta.dirname, "..", "..", "public", "jsbeeb-icon.png");
+    const icon = nativeImage.createFromPath(iconPath);
+
+    const win = new BrowserWindow({
+        width: 1280,
+        height: 1024,
+        icon: icon,
+        webPreferences: {
+            preload: path.join(import.meta.dirname, "preload.js"),
+        },
+    });
+
+    const query = {};
+    if (args.disc1 && !args.noboot) query.autoboot = true;
+    if (args.disc1) query.disc1 = getFileParam(args.disc1);
+    if (args.disc2) query.disc2 = getFileParam(args.disc2);
+    await win.loadFile("dist/index.html", { query });
+
+    app.on("activate", function () {
+        if (BrowserWindow.getAllWindows().length === 0) createWindow();
+    });
+}
+
+app.on("window-all-closed", function () {
+    if (process.platform !== "darwin") app.quit();
+});
+
+app.whenReady()
+    .then(createWindow)
+    .catch((e) => {
+        console.error("Unhandled exception", e);
+        app.exit(1);
+    });
+
+function makeLoader(drive) {
+    return async (_, browserWindow) => {
+        const result = await dialog.showOpenDialog(browserWindow, {
+            title: "Load a disc image",
+            filters: [
+                { name: "Disc images", extensions: ["ssd", "dsd"] },
+                { name: "ZIPped disc images", extensions: ["zip"] },
+            ],
+            properties: ["openFile"],
+        });
+        if (!result.canceled) {
+            browserWindow.webContents.send("load", {
+                drive,
+                path: getFileParam(result.filePaths[0]),
+            });
+        }
+    };
+}
+
+const template = [
+    // { role: 'appMenu' }
+    ...(isMac
+        ? [
+              {
+                  label: app.name,
+                  submenu: [
+                      { role: "about" },
+                      { type: "separator" },
+                      { role: "services" },
+                      { type: "separator" },
+                      { role: "hide" },
+                      { role: "hideothers" },
+                      { role: "unhide" },
+                      { type: "separator" },
+                      { role: "quit" },
+                  ],
+              },
+          ]
+        : []),
+    // { role: 'fileMenu' }
+    {
+        label: "File",
+        submenu: [
+            {
+                label: "Load disc 0",
+                click: makeLoader(0),
+            },
+            {
+                label: "Load disc 1",
+                click: makeLoader(1),
+            },
+            isMac ? { role: "close" } : { role: "quit" },
+        ],
+    },
+    // { role: 'editMenu' }
+    {
+        label: "Edit",
+        submenu: [{ role: "paste" }],
+    },
+    // { role: 'viewMenu' }
+    {
+        label: "View",
+        submenu: [
+            { role: "reload" },
+            { role: "forcereload" },
+            { role: "toggledevtools" },
+            { type: "separator" },
+            { role: "resetzoom" },
+            { role: "zoomin" },
+            { role: "zoomout" },
+            { type: "separator" },
+            { role: "togglefullscreen" },
+        ],
+    },
+    {
+        role: "help",
+        submenu: [
+            {
+                label: "Learn More",
+                click: async () => {
+                    await shell.openExternal("https://github.com/mattgodbolt/jsbeeb/");
+                },
+            },
+        ],
+    },
+];
+
+const menu = Menu.buildFromTemplate(template);
+Menu.setApplicationMenu(menu);

package/src/app/electron.js

@@ -0,0 +1,20 @@
+"use strict";
+
+// Electron integration for jsbeeb desktop application.
+// Handles IPC communication for loading disc images from Electron's main process.
+
+export let initialise = function () {};
+
+function init(args) {
+    const { loadDiscImage, processor } = args;
+    const electron = window.nodeRequire("electron");
+    electron.ipcRenderer.on("load", async (event, message) => {
+        const { drive, path } = message;
+        const image = await loadDiscImage(path);
+        processor.fdc.loadDisc(drive, image);
+    });
+}
+
+if (typeof window.nodeRequire !== "undefined") {
+    initialise = init;
+}

package/src/app/preload.js

@@ -0,0 +1,8 @@
+"use strict";
+window.nodeRequire = require;
+
+window.addEventListener("DOMContentLoaded", () => {
+    for (const node of document.getElementsByClassName("not-electron")) {
+        node.remove();
+    }
+});

package/src/app-bench.js

@@ -0,0 +1,33 @@
+"use strict";
+
+import { fake6502 } from "./fake6502.js";
+import * as models from "./models.js";
+import * as disc from "./fdc.js";
+
+function benchmarkCpu(cpu, numCyclesPerRep, numTimes) {
+    console.log(`Benchmarking over ${numCyclesPerRep / 1000000}M cpu cycles, ${numTimes} times`);
+    for (let time = 0; time < numTimes; ++time) {
+        const startTime = Date.now();
+        cpu.execute(numCyclesPerRep);
+        const endTime = Date.now();
+        const msTaken = endTime - startTime;
+        const virtualMhz = numCyclesPerRep / msTaken / 1000;
+        console.log(
+            `${time}: Took ${msTaken}ms to execute ${numCyclesPerRep / 1000000}M cycles; Virtual ${virtualMhz.toFixed(2)}MHz`,
+        );
+    }
+}
+
+async function main() {
+    const discName = "elite";
+    const cpu = fake6502(models.findModel("B"));
+    await cpu.initialise();
+    const data = await disc.load("discs/" + discName + ".ssd");
+    cpu.fdc.loadDisc(0, disc.discFor(cpu.fdc, discName, data));
+    cpu.sysvia.keyDown(16);
+    cpu.execute(10 * 1000 * 1000);
+    cpu.sysvia.keyUp(16);
+    benchmarkCpu(cpu, 100 * 1000 * 1000, 10);
+}
+
+main().then(() => {});

package/src/basic/multiline-tetris

@@ -0,0 +1,9 @@
+0d=d:IFd VDUd:p=POINT(64*POS,1E3-VPOS*32):RETURN ELSEMODE2:GCOL0,-9:CLG
+1d=9:REPEATVDU30:REPEATGOSUBFALSE:IFPOS=15VDU28,5,VPOS,14;11,26:IF0ELSEIFp=0PRINT:UNTIL0ELSEUNTILVPOS=25
+2b=ABSRND MOD7:k=0:VDU31,9,3
+3REPEATg=9-INKEY6MOD3
+4FORl=TRUE TO1:o=l ANDSGNo
+5IFo=l COLOURb-15:VDUl EORg:k=k+(g=7AND9-6*l)
+6IF0ELSEFORf=0TO11:d=f/3OR2EORd:GOSUBFALSE
+7IF2^((f+k)MOD12)AND975AND&C2590EC/8^b VDU2080*ABSl;:o=o+p:IF0ELSENEXT,
+8VDU20:UNTILo*LOGg:UNTIL0