jsbeeb 1.12.0 → 1.13.0

package/tests/test-machine.js

@@ -3,6 +3,7 @@ import { fake6502 } from "../src/fake6502.js";
 import { findModel } from "../src/models.js";
 import assert from "assert";
 import * as utils from "../src/utils.js";
+import * as utils_atom from "../src/utils_atom.js";
 import * as Tokeniser from "../src/basic-tokenise.js";
 
 const MaxCyclesPerIter = 100 * 1000;
@@ -10,13 +11,46 @@ const MaxCyclesPerIter = 100 * 1000;
 export class TestMachine {
     constructor(model, opts) {
         model = model || "B-DFS1.2";
-        this.processor = fake6502(findModel(model), opts || {});
+        const modelObj = findModel(model);
+        this.model = modelObj;
+        this.processor = fake6502(modelObj, opts || {});
         this._capturedChars = [];
         this._captureHookInstalled = false;
     }
 
+    /** The keyboard interface for this machine (SysVia for BBC, PPIA for Atom). */
+    get _keyInterface() {
+        return this.model.isAtom ? this.processor.atomppia : this.processor.sysvia;
+    }
+
     async initialise() {
         await this.processor.initialise();
+        if (this.model.isAtom) this._startAtomVSync();
+    }
+
+    /**
+     * The Atom ROM's main loop waits for VSync (bit 7 of Port C) to
+     * toggle before scanning the keyboard.  The MC6847 video chip drives
+     * this in the real emulator, but fake6502 doesn't create one, so we
+     * simulate it with a scheduler task at ~60 Hz (NTSC).
+     */
+    _startAtomVSync() {
+        const ppia = this.processor.atomppia;
+        const VsyncPeriod = 16667; // 1 MHz / 60 Hz (NTSC 262-line frame)
+        const VsyncPulse = 800;
+        let inVsync = false;
+        const task = this.processor.scheduler.newTask(() => {
+            if (!inVsync) {
+                ppia.setVBlankInt(1);
+                inVsync = true;
+                task.reschedule(VsyncPulse);
+            } else {
+                ppia.setVBlankInt(0);
+                inVsync = false;
+                task.reschedule(VsyncPeriod - VsyncPulse);
+            }
+        });
+        task.schedule(VsyncPeriod);
     }
 
     /**
@@ -27,8 +61,10 @@ export class TestMachine {
     startCapture() {
         if (this._captureHookInstalled) return;
         this._captureHookInstalled = true;
+        // WRCHV is at 0x0208 on Atom, 0x020E on BBC.
+        const wrchvAddr = this.model.isAtom ? 0x0208 : 0x020e;
         this.processor.debugInstruction.add((addr) => {
-            const wrchv = this.readword(0x20e);
+            const wrchv = this.readword(wrchvAddr);
             if (addr === wrchv) {
                 this._capturedChars.push(this.processor.a);
             }
@@ -130,6 +166,23 @@ export class TestMachine {
     async runUntilInput(secs) {
         if (!secs) secs = 120;
         console.log("Running until keyboard input requested");
+        if (this.model.isAtom) {
+            // The Atom kernel's keyboard read loop at $FE94 is entered when
+            // BASIC (or the OS) waits for a keypress.  We detect entry to
+            // this routine as the idle point.
+            const atomIdleAddr = 0xfe94;
+            let hit = false;
+            const hook = this.processor.debugInstruction.add((addr) => {
+                if (addr === atomIdleAddr) {
+                    hit = true;
+                    return true;
+                }
+            });
+            await this.runFor(secs * 1 * 1000 * 1000); // Atom is 1 MHz
+            hook.remove();
+            assert(hit, "Atom did not reach keyboard input in time");
+            return this.runFor(10 * 1000);
+        }
         const idleAddr = this.processor.model.isMaster ? 0xe7e6 : 0xe581;
         let hit = false;
         const hook = this.processor.debugInstruction.add((addr) => {
@@ -304,6 +357,9 @@ export class TestMachine {
      * resumes.
      */
     async type(text) {
+        if (this.model.isAtom) {
+            return this._typeAtom(text);
+        }
         const fullText = text + "\n"; // append RETURN
         const keys = fullText.split("").map((ch) => this._charToKey(ch));
         const holdCycles = 40000;
@@ -351,20 +407,89 @@ export class TestMachine {
         }
     }
 
+    /** Type text on the Atom using its key mapping and PPIA interface. */
+    async _typeAtom(text) {
+        // stringToATOMKeys returns a flat array of [col, row] pairs.
+        // SHIFT is held across multiple characters; LOCK is tapped to
+        // toggle the ROM's internal caps lock state.
+        const keySequence = utils_atom.stringToATOMKeys(text + "\n");
+        const ppia = this.processor.atomppia;
+        const holdCycles = 80000; // Atom at 1 MHz needs longer hold than BBC at 2 MHz
+        const SHIFT = utils_atom.ATOM.SHIFT;
+
+        let index = 0;
+        let phase = "idle";
+        let nextEventCycle = 0;
+        let done = false;
+        let shiftHeld = false;
+
+        const currentCycle = () => this.processor.cycleSeconds * 1000000 + this.processor.currentCycles;
+
+        const isShift = (entry) => entry[0] === SHIFT[0] && entry[1] === SHIFT[1];
+
+        const hook = this.processor.debugInstruction.add(() => {
+            if (currentCycle() < nextEventCycle) return;
+
+            if (phase === "down") {
+                const entry = keySequence[index];
+                if (!isShift(entry)) {
+                    ppia.keyUpRaw(entry);
+                }
+                index++;
+                phase = "idle";
+                nextEventCycle = currentCycle() + holdCycles;
+                return;
+            }
+
+            if (index >= keySequence.length) {
+                if (shiftHeld) ppia.keyUpRaw(SHIFT);
+                hook.remove();
+                done = true;
+                return;
+            }
+
+            const entry = keySequence[index];
+            if (isShift(entry)) {
+                if (shiftHeld) {
+                    ppia.keyUpRaw(SHIFT);
+                    shiftHeld = false;
+                } else {
+                    ppia.keyDownRaw(SHIFT);
+                    shiftHeld = true;
+                }
+                index++;
+                nextEventCycle = currentCycle() + holdCycles;
+            } else {
+                ppia.keyDownRaw(entry);
+                phase = "down";
+                nextEventCycle = currentCycle() + holdCycles;
+            }
+        });
+
+        while (!done) {
+            const stopped = await this.runFor(holdCycles);
+            if (stopped) {
+                hook.remove();
+                if (shiftHeld) ppia.keyUpRaw(SHIFT);
+                break;
+            }
+        }
+    }
+
     /**
-     * Press a key on the BBC keyboard.
-     * @param {number} code - BBC key code (e.g. utils.keyCodes.SPACE)
+     * Press a key on the keyboard.
+     * @param {number} code - key code (BBC keyCode or Atom raw key)
      */
     keyDown(code) {
-        this.processor.sysvia.keyDown(code);
+        this._keyInterface.keyDown(code);
     }
 
     /**
-     * Release a key on the BBC keyboard.
-     * @param {number} code - BBC key code
+     * Release a key on the keyboard.
+     * @param {number} code - key code
      */
     keyUp(code) {
-        this.processor.sysvia.keyUp(code);
+        this._keyInterface.keyUp(code);
     }
 
     /**