jsbeeb 1.1.1

package/src/touchscreen.js

@@ -0,0 +1,86 @@
+"use strict";
+
+import * as utils from "./utils.js";
+
+const PollHz = 8; // Made up
+const PollCycles = (2 * 1000 * 1000) / PollHz;
+
+function doScale(val, scale, margin) {
+    val = (val - margin) / (1 - 2 * margin);
+    return val * scale;
+}
+
+export class TouchScreen {
+    constructor(scheduler) {
+        this.scheduler = scheduler;
+        this.mouse = [];
+        this.outBuffer = new utils.Fifo(16);
+        this.delay = 0;
+        this.mode = 0;
+        this.pollTask = this.scheduler.newTask(this.poll);
+    }
+
+    tryReceive(rts) {
+        if (this.outBuffer.size && rts) return this.outBuffer.get();
+        return -1;
+    }
+
+    doRead() {
+        const scaleX = 120,
+            marginX = 0.13;
+        const scaleY = 100,
+            marginY = 0.03;
+        const scaledX = doScale(this.mouse.x, scaleX, marginX);
+        const scaledY = doScale(1 - this.mouse.y, scaleY, marginY);
+        const toSend = [0x4f, 0x4f, 0x4f, 0x4f];
+        const x = Math.min(255, Math.max(0, scaledX)) | 0;
+        const y = Math.min(255, Math.max(0, scaledY)) | 0;
+        if (this.mouse.button) {
+            toSend[0] = 0x40 | ((x & 0xf0) >>> 4);
+            toSend[1] = 0x40 | (x & 0x0f);
+            toSend[2] = 0x40 | ((y & 0xf0) >>> 4);
+            toSend[3] = 0x40 | (y & 0x0f);
+        }
+        for (let i = 0; i < 4; ++i) this.store(toSend[i]);
+        this.store(".".charCodeAt(0));
+    }
+
+    poll() {
+        this.doRead();
+        this.pollTask.reschedule(PollCycles);
+    }
+
+    store(byte) {
+        this.outBuffer.put(byte);
+    }
+
+    onMouse(x, y, button) {
+        this.mouse = { x: x, y: y, button: button };
+    }
+
+    onTransmit(val) {
+        switch (String.fromCharCode(val)) {
+            case "M":
+                this.mode = 0;
+                break;
+            case "0":
+            case "1":
+            case "2":
+            case "3":
+            case "4":
+            case "5":
+            case "6":
+            case "7":
+            case "8":
+            case "9":
+                this.mode = 10 * this.mode + val - "0".charCodeAt(0);
+                break;
+            case ".":
+                break;
+            case "?":
+                if (this.mode === 1) this.doRead();
+                break;
+        }
+        this.pollTask.ensureScheduled(this.mode === 129 || this.mode === 130, PollCycles);
+    }
+}

package/src/tube.js

@@ -0,0 +1,349 @@
+"use strict";
+import * as utils from "./utils.js";
+
+//  this one should be declared more globally
+const HOST_CPU_FLAG_IRQ_TUBE_ULA = 8;
+
+const TUBE_ULA_R1 = 0;
+const TUBE_ULA_R2 = 1;
+const TUBE_ULA_R3 = 2;
+const TUBE_ULA_R4 = 3;
+const TUBE_ULA_R1_STATUS_ADDRESS = 0;
+const TUBE_ULA_R1_DATA_ADDRESS = 1;
+const TUBE_ULA_R2_STATUS_ADDRESS = 2;
+const TUBE_ULA_R2_DATA_ADDRESS = 3;
+const TUBE_ULA_R3_STATUS_ADDRESS = 4;
+const TUBE_ULA_R3_DATA_ADDRESS = 5;
+const TUBE_ULA_R4_STATUS_ADDRESS = 6;
+const TUBE_ULA_R4_DATA_ADDRESS = 7;
+const TUBE_ULA_FLAG_DATA_AVAILABLE = 0x80;
+const TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL = 0x40;
+const TUBE_ULA_FLAG_STATUS_Q = 0x01;
+const TUBE_ULA_FLAG_STATUS_I = 0x02;
+const TUBE_ULA_FLAG_STATUS_J = 0x04;
+const TUBE_ULA_FLAG_STATUS_M = 0x08;
+const TUBE_ULA_FLAG_STATUS_V = 0x10;
+const TUBE_ULA_FLAG_STATUS_P = 0x20;
+const TUBE_ULA_FLAG_STATUS_T = 0x40;
+const TUBE_ULA_FLAG_STATUS_S = 0x80;
+//  human-readable aliases for the above flags
+const TUBE_ULA_FLAG_STATUS_ENABLE_HOST_IRQ_FROM_R4_DATA = TUBE_ULA_FLAG_STATUS_Q;
+const TUBE_ULA_FLAG_STATUS_ENABLE_PARASITE_IRQ_FROM_R1_DATA = TUBE_ULA_FLAG_STATUS_I;
+const TUBE_ULA_FLAG_STATUS_ENABLE_PARASITE_IRQ_FROM_R4_DATA = TUBE_ULA_FLAG_STATUS_J;
+const TUBE_ULA_FLAG_STATUS_ENABLE_PARASITE_NMI_FROM_R3_DATA = TUBE_ULA_FLAG_STATUS_M;
+const TUBE_ULA_FLAG_STATUS_ENABLE_2_BYTE_R3_DATA = TUBE_ULA_FLAG_STATUS_V;
+const TUBE_ULA_FLAG_STATUS_PARASITE_RESET_ACTIVE_LOW = TUBE_ULA_FLAG_STATUS_P;
+const TUBE_ULA_FLAG_STATUS_CLEAR_ALL_TUBE_REGISTERS = TUBE_ULA_FLAG_STATUS_T;
+const TUBE_ULA_FLAG_STATUS_SET_CONTROL_FLAGS = TUBE_ULA_FLAG_STATUS_S;
+const TUBE_ULA_R1_PARASITE_BYTE_COUNT = 24;
+
+export class Tube {
+    constructor(hostCpu, parasiteCpu) {
+        this.hostCpu = hostCpu;
+        this.parasiteCpu = parasiteCpu;
+        this.internalStatusRegister = 0;
+        this.hostStatus = new Uint8Array(4);
+        this.parasiteStatus = new Uint8Array(4);
+        this.parasiteToHostData = [
+            new Uint8Array(TUBE_ULA_R1_PARASITE_BYTE_COUNT),
+            new Uint8Array(1),
+            new Uint8Array(2),
+            new Uint8Array(1),
+        ];
+        this.hostToParasiteData = [new Uint8Array(1), new Uint8Array(1), new Uint8Array(2), new Uint8Array(1)];
+        this.parasiteToHostFifoByteCount1 = 0;
+        this.parasiteToHostFifoByteCount3 = 0;
+        this.hostToParasiteFifoByteCount3 = 0;
+        this.debug = false;
+    }
+    reset(updateInternalStatusRegister = true) {
+        if (updateInternalStatusRegister) {
+            this.internalStatusRegister = 0;
+        }
+        for (let i = 0; i < 4; i++) {
+            this.hostStatus[i] = TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL;
+            this.parasiteStatus[i] = TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL;
+            if (i === TUBE_ULA_R3) {
+                //  register 3 has one valid but insignificant byte in the parasite to host FIFO (this is to prevent an immediate PNMI state after PRST)
+                this.hostStatus[i] |= TUBE_ULA_FLAG_DATA_AVAILABLE;
+                this.parasiteToHostData[i][0] = 0;
+            }
+        }
+        this.parasiteToHostFifoByteCount1 = 0;
+        //  see info in the loop above from Tube Application Note about R3
+        this.parasiteToHostFifoByteCount3 = 1;
+        this.hostToParasiteFifoByteCount3 = 0;
+        this.updateInterrupts();
+    }
+    updateInterrupts() {
+        //  host IRQ
+        if (
+            this.hostStatus[TUBE_ULA_R4] & TUBE_ULA_FLAG_DATA_AVAILABLE &&
+            this.internalStatusRegister & TUBE_ULA_FLAG_STATUS_ENABLE_HOST_IRQ_FROM_R4_DATA
+        ) {
+            this.hostCpu.interrupt |= HOST_CPU_FLAG_IRQ_TUBE_ULA;
+        } else {
+            this.hostCpu.interrupt &= ~HOST_CPU_FLAG_IRQ_TUBE_ULA;
+        }
+        //  parasite IRQ
+        if (
+            (this.parasiteStatus[TUBE_ULA_R1] & TUBE_ULA_FLAG_DATA_AVAILABLE &&
+                this.internalStatusRegister & TUBE_ULA_FLAG_STATUS_ENABLE_PARASITE_IRQ_FROM_R1_DATA) ||
+            (this.parasiteStatus[TUBE_ULA_R4] & TUBE_ULA_FLAG_DATA_AVAILABLE &&
+                this.internalStatusRegister & TUBE_ULA_FLAG_STATUS_ENABLE_PARASITE_IRQ_FROM_R4_DATA)
+        ) {
+            this.parasiteCpu.interrupt = true;
+        } else {
+            this.parasiteCpu.interrupt = false;
+        }
+        //  parasite NMI
+        //  (from Tube Application Note)
+        //  either: M = 1, V = 0, 1 or 2 bytes in host to parasite register 3 FIFO or 0 bytes in parasite
+        //  to host register 3 FIFO (this allows single byte transfers across
+        //  register 3)
+        //  or: M = 1, V = 1, 2 bytes in host to parasite register 3 FIFO or 0 bytes in parasite to host
+        //  register 3 FIFO. (this allows two byte transfers across register 3)
+        const r3Size = this.internalStatusRegister & TUBE_ULA_FLAG_STATUS_ENABLE_2_BYTE_R3_DATA ? 2 : 1;
+        if (
+            this.internalStatusRegister & TUBE_ULA_FLAG_STATUS_ENABLE_PARASITE_NMI_FROM_R3_DATA &&
+            (this.hostToParasiteFifoByteCount3 >= r3Size || this.parasiteToHostFifoByteCount3 === 0)
+        ) {
+            this.parasiteCpu.NMI(true);
+        } else {
+            this.parasiteCpu.NMI(false);
+        }
+        //  parasite CPU RESET held low - not implemented in the CPU - the CPU should be frozen until this signal is released
+        this.parasiteCpu.resetHeldLow = this.internalStatusRegister & TUBE_ULA_FLAG_STATUS_PARASITE_RESET_ACTIVE_LOW;
+    }
+    hostRead(address) {
+        let result = 0xfe;
+        switch (address & 7) {
+            case TUBE_ULA_R1_STATUS_ADDRESS:
+                result =
+                    (this.hostStatus[TUBE_ULA_R1] &
+                        (TUBE_ULA_FLAG_DATA_AVAILABLE | TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL)) |
+                    (this.internalStatusRegister &
+                        ~(TUBE_ULA_FLAG_DATA_AVAILABLE | TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL));
+                break;
+            case TUBE_ULA_R1_DATA_ADDRESS:
+                result = this.parasiteToHostData[TUBE_ULA_R1][0];
+                if (this.hostStatus[TUBE_ULA_R1] & TUBE_ULA_FLAG_DATA_AVAILABLE) {
+                    for (let i = 1; i < TUBE_ULA_R1_PARASITE_BYTE_COUNT; i++) {
+                        this.parasiteToHostData[TUBE_ULA_R1][i - 1] = this.parasiteToHostData[TUBE_ULA_R1][i];
+                    }
+                    this.parasiteStatus[TUBE_ULA_R1] |= TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL;
+                    this.parasiteToHostFifoByteCount1--;
+                    if (this.parasiteToHostFifoByteCount1 === 0) {
+                        this.hostStatus[TUBE_ULA_R1] &= ~TUBE_ULA_FLAG_DATA_AVAILABLE;
+                    }
+                }
+                break;
+            case TUBE_ULA_R2_STATUS_ADDRESS:
+                result = this.hostStatus[TUBE_ULA_R2];
+                break;
+            case TUBE_ULA_R2_DATA_ADDRESS:
+                result = this.parasiteToHostData[TUBE_ULA_R2][0];
+                this.parasiteStatus[TUBE_ULA_R2] |= TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL;
+                this.hostStatus[TUBE_ULA_R2] &= ~TUBE_ULA_FLAG_DATA_AVAILABLE;
+                break;
+            case TUBE_ULA_R3_STATUS_ADDRESS:
+                result = this.hostStatus[TUBE_ULA_R3];
+                break;
+            case TUBE_ULA_R3_DATA_ADDRESS:
+                result = this.parasiteToHostData[TUBE_ULA_R3][0];
+                if (this.hostStatus[TUBE_ULA_R3] & TUBE_ULA_FLAG_DATA_AVAILABLE) {
+                    this.parasiteToHostData[TUBE_ULA_R3][0] = this.parasiteToHostData[TUBE_ULA_R3][1];
+                    this.parasiteStatus[TUBE_ULA_R3] |= TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL;
+                    this.parasiteToHostFifoByteCount3--;
+                    if (this.parasiteToHostFifoByteCount3 === 0) {
+                        this.hostStatus[TUBE_ULA_R3] &= ~TUBE_ULA_FLAG_DATA_AVAILABLE;
+                    }
+                }
+                break;
+            case TUBE_ULA_R4_STATUS_ADDRESS:
+                result = this.hostStatus[TUBE_ULA_R4];
+                break;
+            case TUBE_ULA_R4_DATA_ADDRESS:
+                result = this.parasiteToHostData[TUBE_ULA_R4][0];
+                this.parasiteStatus[TUBE_ULA_R4] |= TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL;
+                this.hostStatus[TUBE_ULA_R4] &= ~TUBE_ULA_FLAG_DATA_AVAILABLE;
+                break;
+        }
+        this.updateInterrupts();
+        if (this.debug) {
+            console.log("TUBE ULA: host read " + utils.hexword(address) + " = " + utils.hexbyte(result));
+        }
+        return result;
+    }
+    hostWrite(address, value) {
+        if (this.debug) {
+            console.log("TUBE ULA: host write " + utils.hexword(address) + " = " + utils.hexbyte(value));
+        }
+        switch (address & 7) {
+            case TUBE_ULA_R1_STATUS_ADDRESS:
+                if (value & TUBE_ULA_FLAG_STATUS_SET_CONTROL_FLAGS) {
+                    this.internalStatusRegister |=
+                        value & ~(TUBE_ULA_FLAG_DATA_AVAILABLE | TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL);
+                } else {
+                    this.internalStatusRegister &= ~(
+                        value & ~(TUBE_ULA_FLAG_DATA_AVAILABLE | TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL)
+                    );
+                }
+                if (value & TUBE_ULA_FLAG_STATUS_CLEAR_ALL_TUBE_REGISTERS) {
+                    this.reset(false);
+                }
+                if (value & TUBE_ULA_FLAG_STATUS_PARASITE_RESET_ACTIVE_LOW) {
+                    //  there is still an issue with the parasite OS that runs after this happens
+                    //  it prints the startup banner but then seems to stop responding when a R3 data
+                    //  transfer (based on Advanced User Guide example) is attempted
+                    if (this.internalStatusRegister & TUBE_ULA_FLAG_STATUS_PARASITE_RESET_ACTIVE_LOW) {
+                        this.parasiteCpu.reset(true); //  this in turn calls our this.reset(true)
+                    }
+                }
+                break;
+            case TUBE_ULA_R1_DATA_ADDRESS:
+                if (this.hostStatus[TUBE_ULA_R1] & TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL) {
+                    this.hostToParasiteData[TUBE_ULA_R1][0] = value;
+                    this.parasiteStatus[TUBE_ULA_R1] |= TUBE_ULA_FLAG_DATA_AVAILABLE;
+                    this.hostStatus[TUBE_ULA_R1] &= ~TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL;
+                }
+                break;
+            case TUBE_ULA_R2_DATA_ADDRESS:
+                if (this.hostStatus[TUBE_ULA_R2] & TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL) {
+                    this.hostToParasiteData[TUBE_ULA_R2][0] = value;
+                    this.parasiteStatus[TUBE_ULA_R2] |= TUBE_ULA_FLAG_DATA_AVAILABLE;
+                    this.hostStatus[TUBE_ULA_R2] &= ~TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL;
+                }
+                break;
+            case TUBE_ULA_R3_DATA_ADDRESS:
+                if (this.hostStatus[TUBE_ULA_R3] & TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL) {
+                    if (this.internalStatusRegister & TUBE_ULA_FLAG_STATUS_ENABLE_2_BYTE_R3_DATA) {
+                        if (this.hostToParasiteFifoByteCount3 < 2) {
+                            this.hostToParasiteData[this.hostToParasiteFifoByteCount3++] = value;
+                        }
+                        if (this.hostToParasiteFifoByteCount3 === 2) {
+                            this.parasiteStatus[TUBE_ULA_R3] |= TUBE_ULA_FLAG_DATA_AVAILABLE;
+                            this.hostStatus[TUBE_ULA_R3] &= ~TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL;
+                        }
+                    } else {
+                        this.hostToParasiteData[TUBE_ULA_R3][0] = value;
+                        this.hostToParasiteFifoByteCount3 = 1;
+                        this.parasiteStatus[TUBE_ULA_R3] |= TUBE_ULA_FLAG_DATA_AVAILABLE;
+                        this.hostStatus[TUBE_ULA_R3] &= ~TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL;
+                    }
+                }
+                break;
+            case TUBE_ULA_R4_DATA_ADDRESS:
+                if (this.hostStatus[TUBE_ULA_R4] & TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL) {
+                    this.hostToParasiteData[TUBE_ULA_R4][0] = value;
+                    this.parasiteStatus[TUBE_ULA_R4] |= TUBE_ULA_FLAG_DATA_AVAILABLE;
+                    this.hostStatus[TUBE_ULA_R4] &= ~TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL;
+                }
+                break;
+        }
+        this.updateInterrupts();
+    }
+    parasiteRead(address) {
+        //  Not implemented - needs to be integrated with the parasite CPU code:
+        //  Boot mode is terminated by the software when it selects any one of the Tube addresses.
+        //  This deselects the ROM
+        let result = 0;
+        switch (address & 7) {
+            case TUBE_ULA_R1_STATUS_ADDRESS:
+                result = this.parasiteStatus[TUBE_ULA_R1];
+                break;
+            case TUBE_ULA_R1_DATA_ADDRESS:
+                result = this.hostToParasiteData[TUBE_ULA_R1][0];
+                this.hostStatus[TUBE_ULA_R1] |= TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL;
+                this.parasiteStatus[TUBE_ULA_R1] &= ~TUBE_ULA_FLAG_DATA_AVAILABLE;
+                break;
+            case TUBE_ULA_R2_STATUS_ADDRESS:
+                result = this.parasiteStatus[TUBE_ULA_R2];
+                break;
+            case TUBE_ULA_R2_DATA_ADDRESS:
+                result = this.hostToParasiteData[TUBE_ULA_R2][0];
+                this.hostStatus[TUBE_ULA_R2] |= TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL;
+                this.parasiteStatus[TUBE_ULA_R2] &= ~TUBE_ULA_FLAG_DATA_AVAILABLE;
+                break;
+            case TUBE_ULA_R3_STATUS_ADDRESS:
+                result = this.parasiteStatus[TUBE_ULA_R3];
+                break;
+            case TUBE_ULA_R3_DATA_ADDRESS:
+                result = this.hostToParasiteData[TUBE_ULA_R3][0];
+                if (this.parasiteStatus[TUBE_ULA_R3] & TUBE_ULA_FLAG_DATA_AVAILABLE) {
+                    this.hostToParasiteData[TUBE_ULA_R3][0] = this.hostToParasiteData[TUBE_ULA_R3][1];
+                    this.hostToParasiteFifoByteCount3--;
+                    if (this.hostToParasiteFifoByteCount3 === 0) {
+                        this.hostStatus[TUBE_ULA_R3] |= TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL;
+                        this.parasiteStatus[TUBE_ULA_R3] &= ~TUBE_ULA_FLAG_DATA_AVAILABLE;
+                    }
+                }
+                break;
+            case TUBE_ULA_R4_STATUS_ADDRESS:
+                result = this.parasiteStatus[TUBE_ULA_R4];
+                break;
+            case TUBE_ULA_R4_DATA_ADDRESS:
+                result = this.hostToParasiteData[TUBE_ULA_R4][0];
+                this.hostStatus[TUBE_ULA_R4] |= TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL;
+                this.parasiteStatus[TUBE_ULA_R4] &= ~TUBE_ULA_FLAG_DATA_AVAILABLE;
+                break;
+        }
+        this.updateInterrupts();
+        if (this.debug) {
+            console.log("TUBE ULA: parasite read " + utils.hexword(address) + " = " + utils.hexbyte(result));
+        }
+        return result;
+    }
+    parasiteWrite(address, value) {
+        //  Not implemented - needs to be integrated with the parasite CPU code:
+        //  Boot mode is terminated by the software when it selects any one of the Tube addresses.
+        //  This deselects the ROM
+        if (this.debug) {
+            console.log("TUBE ULA: parasite write " + utils.hexword(address) + " = " + utils.hexbyte(value));
+        }
+        switch (address & 7) {
+            case TUBE_ULA_R1_DATA_ADDRESS:
+                if (this.parasiteStatus[TUBE_ULA_R1] & TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL) {
+                    this.parasiteToHostData[TUBE_ULA_R1][this.parasiteToHostFifoByteCount1++] = value;
+                    this.hostStatus[TUBE_ULA_R1] |= TUBE_ULA_FLAG_DATA_AVAILABLE;
+                    if (this.parasiteToHostFifoByteCount1 === TUBE_ULA_R1_PARASITE_BYTE_COUNT) {
+                        this.parasiteStatus[TUBE_ULA_R1] &= ~TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL;
+                    }
+                }
+                break;
+            case TUBE_ULA_R2_DATA_ADDRESS:
+                if (this.parasiteStatus[TUBE_ULA_R2] & TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL) {
+                    this.parasiteToHostData[TUBE_ULA_R2][0] = value;
+                    this.hostStatus[TUBE_ULA_R2] |= TUBE_ULA_FLAG_DATA_AVAILABLE;
+                    this.parasiteStatus[TUBE_ULA_R2] &= ~TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL;
+                }
+                break;
+            case TUBE_ULA_R3_DATA_ADDRESS:
+                if (this.parasiteStatus[TUBE_ULA_R3] & TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL) {
+                    if (this.internalStatusRegister & TUBE_ULA_FLAG_STATUS_ENABLE_2_BYTE_R3_DATA) {
+                        if (this.parasiteToHostFifoByteCount3 < 2) {
+                            this.parasiteToHostData[TUBE_ULA_R3][this.parasiteToHostFifoByteCount3++] = value;
+                        }
+                        if (this.parasiteToHostFifoByteCount3 === 2) {
+                            this.hostStatus[TUBE_ULA_R3] |= TUBE_ULA_FLAG_DATA_AVAILABLE;
+                            this.parasiteStatus[TUBE_ULA_R3] &= ~TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL;
+                        }
+                    } else {
+                        this.parasiteToHostData[TUBE_ULA_R3][0] = value;
+                        this.parasiteToHostFifoByteCount3 = 1;
+                        this.hostStatus[TUBE_ULA_R3] |= TUBE_ULA_FLAG_DATA_AVAILABLE;
+                        this.parasiteStatus[TUBE_ULA_R3] &= ~TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL;
+                    }
+                }
+                break;
+            case TUBE_ULA_R4_DATA_ADDRESS:
+                if (this.parasiteStatus[TUBE_ULA_R4] & TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL) {
+                    this.parasiteToHostData[TUBE_ULA_R4][0] = value;
+                    this.hostStatus[TUBE_ULA_R4] |= TUBE_ULA_FLAG_DATA_AVAILABLE;
+                    this.parasiteStatus[TUBE_ULA_R4] &= ~TUBE_ULA_FLAG_DATA_REGISTER_NOT_FULL;
+                }
+                break;
+        }
+        this.updateInterrupts();
+    }
+}

package/src/url-params.js

@@ -0,0 +1,256 @@
+/**
+ * URL parameter handling for jsbeeb
+ */
+
+/**
+ * Check if a value is defined (not null and not undefined)
+ * @param {*} value - The value to check
+ * @returns {boolean} True if the value is neither null nor undefined
+ */
+function isDefined(value) {
+    return value !== null && value !== undefined;
+}
+
+/**
+ * @typedef {"string"|"array"|"int"|"float"|"bool"} ParamType
+ */
+
+/**
+ * Parameter type enum to avoid string literals
+ * @enum {string}
+ */
+export const ParamTypes = {
+    /** String parameter (default) */
+    STRING: "string",
+    /** Array parameter (for parameters that can appear multiple times) */
+    ARRAY: "array",
+    /** Integer parameter */
+    INT: "int",
+    /** Float parameter */
+    FLOAT: "float",
+    /** Boolean parameter (true if present, regardless of value) */
+    BOOL: "bool",
+};
+
+/**
+ * Parse a query string into an object
+ * @param {string} queryString - The query string to parse
+ * @param {Object.<string, ParamType>} [paramTypes={}] - A map of parameter names to their types
+ * @returns {Object} Object containing parsed query parameters
+ */
+export function parseQueryString(queryString, paramTypes = {}) {
+    if (!queryString) return {};
+
+    // workaround for shonky python web server
+    const cleanQueryString = queryString.endsWith("/") ? queryString.substring(0, queryString.length - 1) : queryString;
+
+    const parsedQuery = {};
+
+    cleanQueryString.split("&").forEach(function (keyval) {
+        if (!keyval) return;
+
+        const keyAndVal = keyval.split("=");
+        const key = decodeURIComponent(keyAndVal[0]);
+        let val = null;
+        if (keyAndVal.length > 1) val = decodeURIComponent(keyAndVal[1]);
+
+        const paramType = paramTypes[key] || ParamTypes.STRING;
+
+        switch (paramType) {
+            case ParamTypes.ARRAY:
+                if (!parsedQuery[key]) {
+                    parsedQuery[key] = [];
+                }
+                parsedQuery[key].push(val);
+                break;
+            case ParamTypes.INT:
+                if (val !== undefined) {
+                    const parsed = parseInt(val, 10);
+                    parsedQuery[key] = isNaN(parsed) ? 0 : parsed;
+                }
+                break;
+            case ParamTypes.FLOAT:
+                if (val !== undefined) {
+                    const parsed = parseFloat(val);
+                    parsedQuery[key] = isNaN(parsed) ? 0 : parsed;
+                }
+                break;
+            case ParamTypes.BOOL:
+                // Only the exact 'false' string is treated as false.
+                parsedQuery[key] = val !== "false";
+                break;
+            case ParamTypes.STRING:
+            default:
+                parsedQuery[key] = val;
+                break;
+        }
+    });
+
+    return parsedQuery;
+}
+
+/**
+ * Build a URL string from base URL and query parameters
+ * @param {string} baseUrl - The base URL (without query string)
+ * @param {Object} parsedQuery - Object containing query parameters
+ * @param {Object.<string, ParamType>} [paramTypes={}] - Object mapping parameter names to their types
+ * @returns {string} The complete URL with query parameters
+ */
+/**
+ * Append a parameter to the URL
+ * @param {string} url - Current URL
+ * @param {string} sep - Current separator (? or &)
+ * @param {string} key - Parameter key
+ * @param {string} [value] - Parameter value (optional for boolean parameters)
+ * @returns {Object} Updated URL and separator
+ */
+function appendParam(url, sep, key, value = undefined) {
+    url += sep + encodeURIComponent(key);
+    if (value !== undefined) {
+        url += "=" + encodeURIComponent(value);
+    }
+    return { url, sep: "&" };
+}
+
+export function buildUrlFromParams(baseUrl, parsedQuery, paramTypes = {}) {
+    let url = baseUrl;
+    let sep = "?";
+
+    Object.entries(parsedQuery).forEach(([key, value]) => {
+        if (key.length === 0) return;
+
+        // Default to STRING unless explicitly specified
+        const paramType = paramTypes[key] || ParamTypes.STRING;
+
+        switch (paramType) {
+            case ParamTypes.ARRAY:
+                // Handle array parameters - each item becomes a separate parameter
+                if (Array.isArray(value) && value.length > 0) {
+                    value.forEach((val) => {
+                        if (isDefined(val)) {
+                            const result = appendParam(url, sep, key, val);
+                            url = result.url;
+                            sep = result.sep;
+                        }
+                    });
+                }
+                break;
+            case ParamTypes.BOOL:
+                // For boolean params, only add the key without value if true
+                if (value === true) {
+                    const result = appendParam(url, sep, key);
+                    url = result.url;
+                    sep = result.sep;
+                }
+                break;
+            case ParamTypes.INT:
+            case ParamTypes.FLOAT:
+            case ParamTypes.STRING:
+            default:
+                // Include the parameter if it has a value (including zero)
+                if (isDefined(value) && value !== "") {
+                    const result = appendParam(url, sep, key, value);
+                    url = result.url;
+                    sep = result.sep;
+                }
+                break;
+        }
+    });
+
+    return url;
+}
+
+/**
+ * Process keyboard mapping parameters from query string
+ * @param {Object} parsedQuery - The parsed query parameters
+ * @param {Object} BBC - BBC key constants
+ * @param {Object} keyCodes - Key code constants
+ * @param {Array} userKeymap - Array to store user key mappings
+ * @param {Object} gamepad - Gamepad object for handling mapping
+ * @returns {Object} Updated query parameters
+ */
+export function processKeyboardParams(parsedQuery, BBC, keyCodes, userKeymap, gamepad) {
+    Object.entries(parsedQuery).forEach(([key, val]) => {
+        if (!val) return;
+
+        // eg KEY.CAPSLOCK=CTRL
+        if (key.toUpperCase().indexOf("KEY.") === 0) {
+            const bbcKey = val.toUpperCase();
+
+            if (BBC[bbcKey]) {
+                const nativeKey = key.substring(4).toUpperCase(); // remove KEY.
+                if (keyCodes[nativeKey]) {
+                    console.log("mapping " + nativeKey + " to " + bbcKey);
+                    userKeymap.push({ native: nativeKey, bbc: bbcKey });
+                } else {
+                    console.log("unknown key: " + nativeKey);
+                }
+            } else {
+                console.log("unknown BBC key: " + val);
+            }
+        } else if (key.indexOf("GP.") === 0) {
+            // gamepad mapping
+            // eg ?GP.FIRE2=RETURN
+            const gamepadKey = key.substring(3).toUpperCase(); // remove GP. prefix
+            gamepad.remap(gamepadKey, val.toUpperCase());
+        } else {
+            switch (key) {
+                case "LEFT":
+                case "RIGHT":
+                case "UP":
+                case "DOWN":
+                case "FIRE":
+                    gamepad.remap(key, val.toUpperCase());
+                    break;
+            }
+        }
+    });
+
+    return parsedQuery;
+}
+
+/**
+ * Process autoboot and other emulation parameters
+ * @param {Object} parsedQuery - The parsed query parameters
+ * @returns {Object} Information about autoboot settings
+ */
+export function processAutobootParams(parsedQuery) {
+    let needsAutoboot = false;
+    let autoType = "";
+
+    if (isDefined(parsedQuery.autoboot)) {
+        needsAutoboot = "boot";
+    } else if (isDefined(parsedQuery.autochain)) {
+        needsAutoboot = "chain";
+    } else if (isDefined(parsedQuery.autorun)) {
+        needsAutoboot = "run";
+    } else if (isDefined(parsedQuery.autotype)) {
+        needsAutoboot = "type";
+        autoType = parsedQuery.autotype;
+    }
+
+    return { needsAutoboot, autoType };
+}
+
+/**
+ * Guess the appropriate model based on the hostname
+ * @param {string} hostname - The hostname to check
+ * @returns {string} Model identifier
+ */
+export function guessModelFromHostname(hostname) {
+    if (hostname.startsWith("bbc")) return "B-DFS1.2";
+    if (hostname.startsWith("master")) return "Master";
+    return "B-DFS1.2";
+}
+
+/**
+ * Parse disc or tape images from the query parameters
+ * @param {Object} parsedQuery - The query parameters
+ * @returns {Object} Object containing disc and tape information
+ */
+export function parseMediaParams(parsedQuery) {
+    const { disc, disc1, disc2, tape } = parsedQuery;
+    const discImage = disc || disc1;
+
+    return { discImage, secondDiscImage: disc2, tapeImage: tape };
+}