Thomson MO5

Embedding

There is no ready-made pure-JavaScript Thomson MO5, so this build reuses the proven JavaScript Motorola 6809 core from JSVecX (e6809.js, itself a port of Valavan Manohararajah's e6809.c) and wraps a small MO5 around it. The MO5 (Thomson, 1984) is a 6809E at 1 MHz with 32 KB of user RAM, a single MC6821 system PIA, and a custom gate array that scans a two-plane bitmap screen (320×200, 16 colours).

Boot. Give the 6809 a bus object with read8 / write8, map the 16 KB BASIC + monitor ROM at $C000, reset it (the reset vector at $FFFE reads $F003 from the monitor) and drive it from a loop you own - one field is 19,968 CPU clocks at 1 MHz / 50 Hz:

var cpu = new e6809();
cpu.init(machine);              // machine.read8 / machine.write8 = the bus
cpu.e6809_reset();             // PC <- read16($FFFE) = $F003 (monitor)
(function field(){
  var irq = pendingIrq ? 1 : 0; pendingIrq = false;  // 50 Hz gate-array IRQ
  for (var c = 0; c < 19968; )
    c += cpu.e6809_sstep(irq, 0);  // one instruction, returns its cycles
  render(); requestAnimationFrame(field);
})();

The machine is plain objects. Everything the debugger needs is a field or method. There is no wasm heap to reach into:

Because the CPU, bus and RAM are ordinary JavaScript, the debugger single-steps with e6809_sstep, reads and writes registers straight off cpu, and implements breakpoints and watchpoints as host-side checks around the loop, no changes to the reused core.

Debugger integration

The plug-in (mo5-debug.js) reads the live machine from window.EMU_BOOT and hands the shared framework a description of the MO5. Nothing is patched into the emulator; the whole surface is ordinary field access.

• Registers are read straight off cpu each refresh - A B D X Y U S DP PC CC plus the E F H I N Z V C condition flags decoded from reg_cc - and written back the same way. Single-step and watch them change.
• Memory is five chips: a side-effect-free 64K CPU bus (the $A7C0 PIA / gate-array window is skipped so an auto-refreshing hex view never reads a live sync bit), the raw 32K user RAM, the two 8K video planes and the 16K ROM. Disassembly uses the shared m6809 decoder.
• Single step is e6809_sstep - one 6809 instruction with its correct IRQ handling.
• Breakpoints are host-side: with any set, the loop steps one instruction at a time and compares cpu.reg_pc before each. Watchpoints wrap the bus write path and pause on a write to a watched address.
• Input is the real MO5 key matrix: the physical keyboard maps each character to its MO5 key, and an on-screen AZERTY MO5 keyboard drives the same scancodes for touch.

Architecture

The Thomson MO5 is a clean 6809 machine, and this build keeps each block as its own object:

• e6809 - the Motorola 6809 core (reused from JSVecX), single-stepped by e6809_sstep.
• Bus - the two 8K video planes at $0000, 32K user RAM at $2000, an empty cartridge slot at $B000, the system PIA in the $A7C0 page, and the 16K Microsoft BASIC 1.0 / monitor ROM at $C000 (holding the reset and interrupt vectors).
• MC6821 PIA - port A ($A7C0) selects the video plane and border colour; port B ($A7C1) selects a keyboard scancode and reads the key back on bit 7. The gate array's 50 Hz frame-sync drives the interrupt that keeps the cursor and the BASIC timer running.
• Gate-array video - 320×200 in 16 colours. Each 8-pixel cell reads a colour byte (foreground / background palette indices) from one plane and a form byte (the 8 pixel bits) from the other; the Thomson EF9369 palette is rendered to the canvas.

With no cartridge and no cassette, the monitor sizes the RAM, prints its cyan banner and drops to OK - a complete, inspectable machine that boots straight to BASIC.