From f034fe75df787acb4503592335f540a162178903 Mon Sep 17 00:00:00 2001 From: JasonMo1 <111677135+JasonMo1@users.noreply.github.com> Date: Mon, 14 Aug 2023 15:19:47 +0800 Subject: [PATCH 1/2] Restart: add restart button to restart emulation easier --- index.html | 4 +- keyboard.js | 6 +- machine.js | 337 ++++++++++++++++++++++++++++++++++++++++++++++ pio.js | 2 +- rom.js | 4 +- screen.js | 4 +- uart.js | 6 +- zeal.js | 374 +++++++--------------------------------------------- 8 files changed, 399 insertions(+), 338 deletions(-) create mode 100644 machine.js diff --git a/index.html b/index.html index 574eae7..16a4873 100644 --- a/index.html +++ b/index.html @@ -84,7 +84,8 @@

Ready?

Continue Step Step over - Stop + Stop + Restart
@@ -224,6 +225,7 @@

Ready?

+ diff --git a/keyboard.js b/keyboard.js index e1bfca2..ef34a38 100644 --- a/keyboard.js +++ b/keyboard.js @@ -313,7 +313,7 @@ function Keyboard(Zeal, PIO) { transfer_active = false; } else { /* Schedule the next key in 1ms */ - zeal.registerTstateCallback(() => { + zeal.tstatesutils.registerTstateCallback(() => { transfer_active = false; send_next_keypress(); }, us_to_tstates(1000)); @@ -330,14 +330,14 @@ function Keyboard(Zeal, PIO) { for (var i = 0; i < scancodes.length; i++) { const index = i; - zeal.registerTstateCallback(() => { + zeal.tstatesutils.registerTstateCallback(() => { /* Prepare the next scancode */ shift_register = scancodes[index]; /* Assert the keyboard signal */ pio.pio_set_b_pin(IO_KEYBOARD_PIN, 0); } , i * PS2_KEY_TIMING + delay); - zeal.registerTstateCallback(() => { + zeal.tstatesutils.registerTstateCallback(() => { /* Reset the keyboard signal */ pio.pio_set_b_pin(IO_KEYBOARD_PIN, 1); /* Disable the flag too */ diff --git a/machine.js b/machine.js new file mode 100644 index 0000000..ac06aa3 --- /dev/null +++ b/machine.js @@ -0,0 +1,337 @@ +/** + * SPDX-FileCopyrightText: 2023 Zeal 8-bit Computer ; JasonMo + * + * SPDX-License-Identifier: Apache-2.0 + */ + +function Zeal8bitComputer() { + var tstates_callbacks = new Set(); + var t_state = 0; + var running = true; + var interval = null; + + const tstatesutils = { + /** + * T-states related functions + */ + getTstates: function() { + return t_state; + }, + + addTstates: function(count) { + t_state += count; + + /* Kind-of static variable within function scope */ + tstatesutils.addTstates.in_callback = tstatesutils.addTstates.in_callback || false; + + /* Check if any callback can be called, if we aren't in any */ + if (!tstatesutils.addTstates.in_callback) { + tstates_callbacks.forEach(entry => { + if (entry.tstates <= t_state) { + tstatesutils.addTstates.in_callback = true; + entry.callback(); + if (entry.period == 0) { + tstates_callbacks.delete(entry); + } else { + entry.tstates += entry.period; + } + tstatesutils.addTstates.in_callback = false; + } + }); + } + }, + + /** + * Get the earliest callback out of the list. + */ + getEarliestCallback: function() { + var earliest = null; + + tstates_callbacks.forEach((entry) => { + if (earliest == null || entry.tstates < earliest.tstates) { + earliest = entry; + } + }); + + return earliest; + }, + + /** + * Register a callback that shall be called after the number of T-states + * of the CPU given. + * If the given number is less than 0, return an error. + */ + registerTstateCallback: function(callback, call_tstates) { + if (call_tstates < 0) { + return null; + } + + var obj = null; + + /* If the CPU is halted, not registering this event in the list + * will make us completely miss it when function getEarliestCallback() + * is called. Because of that, the CPU will miss this interrupt/event. + * Keeping call_tstates as 0 should work, but let's be safe and make it + * happen in the upcoming T-state. */ + if (call_tstates == 0) { + call_tstates = 1; + } + + obj = { tstates: t_state + call_tstates, callback, period: 0 }; + tstates_callbacks.add(obj); + + return obj; + }, + + /* Register a callback to be called every call_tstates T-states. + * The delay parameter will let us, defer the start of the first call, + * without altering the period. This is handy for period signal that changes + * values for a short period of time (pulses) + */ + registerTstateInterval: function(callback, call_tstates, delay) { + if (call_tstates < 0) { + return null; + } + + /* If the delay parameter is not defined, set it to 0 */ + delay = delay || 0; + + const obj = { tstates: t_state + delay + call_tstates, callback, period: call_tstates }; + tstates_callbacks.add(obj); + return obj; + }, + + removeTstateCallback: function(callback) { + if (callback != null) { + tstates_callbacks.delete(callback); + } + }, + + interrupt: function(interrupt_vector) { + zpu.interrupt(false, interrupt_vector); + step_cpu(); + }, + + adjustTStatesWhenHalted: function(end) { + const earliest = tstatesutils.getEarliestCallback(); + if (earliest == null || earliest.tstates > end) { + /* No callback or no near callback. Increment the T-states and exit */ + t_state = end; + return; + } + /* Here, the number of T-state the callback is meant to be executed is in the range + * [t_state;end], so it is meant to happen during this iteration. + * Jump to that amount and execute instructions following it directly. */ + t_state = earliest.tstates; + } + } + + this.tstatesutils = tstatesutils; + + /* Check which scale to use for the video */ + var scale = 1; + + const mmu = new MMU(); + const rom = new ROM(this); + const ram = new RAM(); + const pio = new PIO(this); + /* Peripherals */ + const vchip = new VideoChip(this, pio, scale); + const uart = new UART(this, pio); + const i2c = new I2C(this, pio); + const keyboard = new Keyboard(this, pio); + const ds1307 = new I2C_DS1307(this, i2c); + /* We could pass an initial content to the EEPROM, but set it to null for the moment */ + const eeprom = new I2C_EEPROM(this, i2c, null); + const devices = [ rom, ram, vchip, pio, keyboard, mmu ]; + const zpu = new Z80({ mem_read, mem_write, io_read, io_write }); + + this.mmu = mmu; + this.rom = rom; + this.ram = ram; + this.pio = pio; + this.vchip = vchip; + this.uart = uart; + this.i2c = i2c; + this.keyboard = keyboard; + this.ds1307 = ds1307; + this.eeprom = eeprom; + this.devices = devices; + this.zpu = zpu; + + var registers = zpu.getState(); + this.registers = registers; + + function mem_read(address) { + var rd = 0; + var found = false; + const ext_addr = mmu.get_ext_addr(address); + + devices.forEach(function (device) { + if (device.is_valid_address(true, ext_addr)) { + console.assert(found == false, "Two devices have valid address " + ext_addr); + rd = device.mem_read(ext_addr); + found = true; + } + }); + + if (!found) { + console.log("No device replied to memory read: " + ext_addr); + } + + return rd; + } + + function mem_write(address, value) { + const ext_addr = mmu.get_ext_addr(address); + + devices.forEach(function (device) { + if (device.is_valid_address(false, ext_addr)) + device.mem_write(ext_addr, value); + }); + } + + function io_read(port) { + var rd = 0; + var found = false; + + devices.forEach(function (device) { + if (device.is_valid_port(true, port)) { + console.assert(found == false, "Two devices have valid ports " + port); + rd = device.io_read(port); + found = true; + } + }); + + return rd; + } + + function io_write(port, value) { + port = port & 0xff; + devices.forEach(function (device) { + if (device.is_valid_port(false, port)) + device.io_write(port, value); + }); + } + + function step_cpu() { + running = true; + + if (interval == null) { + /* Execute the CPU every 16ms */ + interval = setInterval(() => { + /* In 16ms, the number of T-states the CPU could execute is Math.floor(16666.666 / TSTATES_US) */ + const to_execute = us_to_tstates(16666.666); + const end = t_state + to_execute; + + /* t_state is global and will be incremented by addTstates */ + while (t_state <= end && running) { + tstatesutils.addTstates(zpu.run_instruction()); + registers = zpu.getState(); + /* Check whether the current PC is part of the breakpoints list */ + const filtered = breakpoints.find(elt => elt.address == registers.pc); + if (filtered != undefined && filtered.enabled) { + running = false; + updateRegistersHTML(); + if (filtered.callback) { + filtered.callback(filtered); + } + } + + if (registers.halted && t_state <= end) { + tstatesutils.adjustTStatesWhenHalted(end); + } + } + }, 16.666); + } + } + + function step () { + if (registers.halted || running) { + return; + } + var pc = registers.pc; + while (registers.pc == pc) { + /* TODO: check if jr/jp to self instruction */ + tstatesutils.addTstates(zpu.run_instruction()); + registers = zpu.getState(); + } + updateRegistersHTML(); + } + + function step_over () { + /* If the CPU is running, step is meaningless */ + if (running) { + return; + } + + /* Ideally, we would need the size of the instruction, to know where to put the breakpoint + * but as we don't have such thing yet, we can put 4 breakpoints, one after each byte. + * TODO: refactor once we have a working disassembler. */ + var pc = registers.pc; + var former_breakpoints = [...breakpoints]; + /* Define the callback that will be called when reaching one of the breakpoints */ + const callback = (obj) => { + /* Restore the breakpoints list */ + breakpoints = former_breakpoints; + }; + + for (var i = 1; i <= 4; i++) { + var brk = getBreakpoint(pc + i); + if (brk == null) { + breakpoints.push({ address: pc + i, enabled: true, callback }); + } else { + /* Enable it */ + brk.enabled = true; + } + } + + step_cpu(); + } + + function cont() { + step_cpu(); + } + + function stop() { + /* Clear the interval that executes the CPU */ + clearInterval(interval); + interval = null; + updateRegistersHTML(); + running = false; + } + + function restart() { + zealcom = new Zeal8bitComputer(); + /* Reset all the file inputs */ + $("#romfile [type=file]").val(""); + /* Remove the ticks from the ready list */ + $(".status").removeClass("ready"); + } + + function reset() { + zpu.reset(); + step_cpu(); + } + + function destroy() { + clearInterval(interval); + interval = null; + running = false; + } + + this.mem_read = mem_read; + this.mem_write = mem_write; + + this.io_read = io_read; + this.io_write = io_write; + + this.step_cpu = step_cpu; + this.step = step; + this.step_over = step_over; + this.cont = cont; + this.stop = stop; + this.restart = restart; + this.reset = reset; + this.destroy = destroy; +} \ No newline at end of file diff --git a/pio.js b/pio.js index 9a1c145..1a32b8e 100644 --- a/pio.js +++ b/pio.js @@ -189,7 +189,7 @@ function PIO(Zeal) { port.mode != MODE_OUTPUT && (port.mode != MODE_BITCTRL || pio_check_bitctrl_interrupt(port, pin, value))) { - zeal.interrupt(port.int_vector); + zeal.tstatesutils.interrupt(port.int_vector); } } diff --git a/rom.js b/rom.js index 427f683..ed2e228 100644 --- a/rom.js +++ b/rom.js @@ -121,7 +121,7 @@ erasing = true; console.log("Erasing FLASH"); /* Erasing a sector takes 25ms on real hardware, register a callback to actually reflect this */ - zeal.registerTstateCallback(() => { + zeal.tstatesutils.registerTstateCallback(() => { for (var i = 0 ; i< 4096; i++) data[i + sector] = 0xff; erasing = false; @@ -156,7 +156,7 @@ writing = true; console.log("Writing byte to FLASH"); /* Writing a byte takes 20us on real hardware, register a callback to actually reflect this */ - zeal.registerTstateCallback(() => { + zeal.tstatesutils.registerTstateCallback(() => { data[address] = value; writing = false; writing_byte = 0; diff --git a/screen.js b/screen.js index aee10aa..dfb8160 100644 --- a/screen.js +++ b/screen.js @@ -343,7 +343,7 @@ function VideoChip(Zeal, PIO, scale) { /* We don't need to add a listener on the PIO, as they are mainly for OUTPUT pins. * But let's keep in mind that this may change in the future */ /* Start the V_Blank signal generation */ - const vblank_interval = zeal.registerTstateInterval(() => { + const vblank_interval = zeal.tstatesutils.registerTstateInterval(() => { /* Clear VBLANK bit in the PIO state */ pio.pio_set_b_pin(IO_VBLANK_PIN, 0); }, VBLANK_TSTATES_PERIOD); @@ -351,7 +351,7 @@ function VideoChip(Zeal, PIO, scale) { /* Register the same interval but for disabling the signal * So the period is the same as the one above, but we need to start it * a bit later (after 63us) */ - const vblank_interval_end = zeal.registerTstateInterval(() => { + const vblank_interval_end = zeal.tstatesutils.registerTstateInterval(() => { pio.pio_set_b_pin(IO_VBLANK_PIN, 1); }, VBLANK_TSTATES_PERIOD, VBLANK_TSTATES_PERIOD_END); diff --git a/uart.js b/uart.js index 3c6562a..c95772b 100644 --- a/uart.js +++ b/uart.js @@ -55,13 +55,13 @@ function UART(Zeal, PIO) { return; } - const tstates = zeal.getTstates(); + const tstates = zeal.tstatesutils.getTstates(); /* Ignore the case where a transfer hasn't been started and the line is set to 1 */ if (bit == 1 && tx_fifo.length == 0) { /* Nothing to do */ } else if (bit == 0 && tx_fifo.length == 0) { /* Register a callback in 10 UART bits */ - zeal.registerTstateCallback(transferComplete, Math.floor(9.1 * bit_tstates)); + zeal.tstatesutils.registerTstateCallback(transferComplete, Math.floor(9.1 * bit_tstates)); tx_fifo.push({ tstates, bit }); } else { tx_fifo.push({ tstates, bit }); @@ -104,7 +104,7 @@ function UART(Zeal, PIO) { /* If we have to register a callback, do it now */ if (callback) { - zeal.registerTstateCallback(start_shifting, bit_tstates - 1); + zeal.tstatesutils.registerTstateCallback(start_shifting, bit_tstates - 1); } } diff --git a/zeal.js b/zeal.js index 514ddef..71f3583 100644 --- a/zeal.js +++ b/zeal.js @@ -12,91 +12,13 @@ * In theory, a Binary Heap (min heap) would be better. In practice, * We won't have a lot on entries in here. At most 4. */ -var tstates_callbacks = new Set(); -var t_state = 0; -var breakpoints = []; -var running = true; -var registers = null; - -/* Check which scale to use for the video */ -var scale = 1; -if ($(window).height() > 920 && $(window).width() > 1280) { - // scale = 2; -} -const mmu = new MMU(); -const rom = new ROM(this); -const ram = new RAM(); -const pio = new PIO(this); -/* Peripherals */ -const vchip = new VideoChip(this, pio, scale); -const uart = new UART(this, pio); -const i2c = new I2C(this, pio); -const keyboard = new Keyboard(this, pio); -const ds1307 = new I2C_DS1307(this, i2c); -/* We could pass an initial content to the EEPROM, but set it to null for the moment */ -const eeprom = new I2C_EEPROM(this, i2c, null); +var zealcom = new Zeal8bitComputer(); const disassembler = new Disassembler(); /* Memdump related */ const byte_per_line = 0x20; -const devices = [ rom, ram, vchip, pio, keyboard, mmu ]; - -const zpu = new Z80({ mem_read, mem_write, io_read, io_write }); - -function mem_read(address) { - var rd = 0; - var found = false; - const ext_addr = mmu.get_ext_addr(address); - - devices.forEach(function (device) { - if (device.is_valid_address(true, ext_addr)) { - console.assert(found == false, "Two devices have valid address " + ext_addr); - rd = device.mem_read(ext_addr); - found = true; - } - }); - - if (!found) { - console.log("No device replied to memory read: " + ext_addr); - } - - return rd; -} - -function mem_write(address, value) { - const ext_addr = mmu.get_ext_addr(address); - - devices.forEach(function (device) { - if (device.is_valid_address(false, ext_addr)) - device.mem_write(ext_addr, value); - }); -} - -function io_read(port) { - var rd = 0; - var found = false; - - devices.forEach(function (device) { - if (device.is_valid_port(true, port)) { - console.assert(found == false, "Two devices have valid ports " + port); - rd = device.io_read(port); - found = true; - } - }); - - return rd; -} - -function io_write(port, value) { - port = port & 0xff; - devices.forEach(function (device) { - if (device.is_valid_port(false, port)) - device.io_write(port, value); - }); -} - function isPrintable(byteCode) { return byteCode >= 32 && byteCode <= 126; } @@ -113,7 +35,7 @@ function dumpRamContent(virtaddr, physaddr, lines) { '
'; for (var j = 0; j < byte_per_line; j++) { const virt = virtaddr + i + j - var byte = mem_read(virt); + var byte = zealcom.mem_read(virt); if (isPrintable(byte)) { ascii.push(String.fromCharCode(byte)); } else { @@ -137,7 +59,7 @@ function dumpRamContent(virtaddr, physaddr, lines) { function setASMView() { /* Get the PC, which is a virtual address */ - const pc = registers != null ? (registers.pc) : 0; + const pc = zealcom.registers != null ? (zealcom.registers.pc) : 0; /* Set the number of instructions we need to disassemble and show */ const instructions = 20; @@ -149,7 +71,7 @@ function setASMView() { /* Add 4 bytes so that if the last instruction is a 4 byte instruction, we won't go out of * bounds when disassembling */ for (var i = 0; i < bytes + 4; i++) { - memory.push(mem_read(pc + i)); + memory.push(zealcom.mem_read(pc + i)); } /* Disassemble this part of the memory */ @@ -179,7 +101,7 @@ function setASMView() { function setRAMView(virtaddr, size) { // TODO: Add the addr to a watchlist that will be updates after a breakpoint is reached - const physaddr = mmu.get_ext_addr(virtaddr); + const physaddr = zealcom.mmu.get_ext_addr(virtaddr); const dumptxt = dumpRamContent(virtaddr, physaddr, size / byte_per_line); $("#dumpcontent").html(dumptxt); } @@ -202,29 +124,30 @@ function updateAndShowRAM () { } function updateRegistersHTML() { - $("#rega").text(hex8(registers.a)); - $("#regb").text(hex8(registers.b)); - $("#regc").text(hex8(registers.c)); - $("#regd").text(hex8(registers.d)); - $("#rege").text(hex8(registers.e)); - $("#regh").text(hex8(registers.h)); - $("#regl").text(hex8(registers.l)); - $("#regix").text(hex(registers.ix)); - $("#regiy").text(hex(registers.iy)); - $("#regbc").text(hex16(registers.b, registers.c)); - $("#regde").text(hex16(registers.d, registers.e)); - $("#reghl").text(hex16(registers.h, registers.l)); - $("#regpc").text(hex(registers.pc)); - $("#regsp").text(hex(registers.sp)); + let reg = zealcom.registers; + $("#rega").text(hex8(reg.a)); + $("#regb").text(hex8(reg.b)); + $("#regc").text(hex8(reg.c)); + $("#regd").text(hex8(reg.d)); + $("#rege").text(hex8(reg.e)); + $("#regh").text(hex8(reg.h)); + $("#regl").text(hex8(reg.l)); + $("#regix").text(hex(reg.ix)); + $("#regiy").text(hex(reg.iy)); + $("#regbc").text(hex16(reg.b, reg.c)); + $("#regde").text(hex16(reg.d, reg.e)); + $("#reghl").text(hex16(reg.h, reg.l)); + $("#regpc").text(hex(reg.pc)); + $("#regsp").text(hex(reg.sp)); /* Special treatment for the flags */ - var flags = (registers.flags.S == 1 ? "S" : "") + - (registers.flags.Z == 1 ? "Z" : "") + - (registers.flags.Y == 1 ? "Y" : "") + - (registers.flags.H == 1 ? "H" : "") + - (registers.flags.X == 1 ? "X" : "") + - (registers.flags.P == 1 ? "P" : "") + - (registers.flags.N == 1 ? "N" : "") + - (registers.flags.C == 1 ? "C" : ""); + var flags = (reg.flags.S == 1 ? "S" : "") + + (reg.flags.Z == 1 ? "Z" : "") + + (reg.flags.Y == 1 ? "Y" : "") + + (reg.flags.H == 1 ? "H" : "") + + (reg.flags.X == 1 ? "X" : "") + + (reg.flags.P == 1 ? "P" : "") + + (reg.flags.N == 1 ? "N" : "") + + (reg.flags.C == 1 ? "C" : ""); $("#flags").text(flags); @@ -232,214 +155,6 @@ function updateRegistersHTML() { updateAndShowRAM(); } -var stop_cpu = false; -var interval = null; - - -var count = 0; -var elapsed = 0; - -function adjustTStatesWhenHalted(end) { - const earliest = getEarliestCallback(); - if (earliest == null || earliest.tstates > end) { - /* No callback or no near callback. Increment the T-states and exit */ - t_state = end; - return; - } - /* Here, the number of T-state the callback is meant to be executed is in the range - * [t_state;end], so it is meant to happen during this iteration. - * Jump to that amount and execute instructions following it directly. */ - t_state = earliest.tstates; -} - -function step_cpu() { - running = true; - - if (interval == null) { - /* Execute the CPU every 16ms */ - interval = setInterval(() => { - /* In 16ms, the number of T-states the CPU could execute is Math.floor(16666.666 / TSTATES_US) */ - const to_execute = us_to_tstates(16666.666); - const end = t_state + to_execute; - - /* t_state is global and will be incremented by addTstates */ - while (t_state <= end && running) { - addTstates(zpu.run_instruction()); - registers = zpu.getState(); - /* Check whether the current PC is part of the breakpoints list */ - const filtered = breakpoints.find(elt => elt.address == registers.pc); - if (filtered != undefined && filtered.enabled) { - running = false; - updateRegistersHTML(); - if (filtered.callback) { - filtered.callback(filtered); - } - } - - if (registers.halted && t_state <= end) { - adjustTStatesWhenHalted(end); - } - } - }, 16.666); - } -} - -function step () { - if (registers.halted || running) { - return; - } - var pc = registers.pc; - while (registers.pc == pc) { - /* TODO: check if jr/jp to self instruction */ - addTstates(zpu.run_instruction()); - registers = zpu.getState(); - } - updateRegistersHTML(); -} - -function step_over () { - /* If the CPU is running, step is meaningless */ - if (running) { - return; - } - - /* Ideally, we would need the size of the instruction, to know where to put the breakpoint - * but as we don't have such thing yet, we can put 4 breakpoints, one after each byte. - * TODO: refactor once we have a working disassembler. */ - var pc = registers.pc; - var former_breakpoints = [...breakpoints]; - /* Define the callback that will be called when reaching one of the breakpoints */ - const callback = (obj) => { - /* Restore the breakpoints list */ - breakpoints = former_breakpoints; - }; - - for (var i = 1; i <= 4; i++) { - var brk = getBreakpoint(pc + i); - if (brk == null) { - breakpoints.push({ address: pc + i, enabled: true, callback }); - } else { - /* Enable it */ - brk.enabled = true; - } - } - - step_cpu(); -} - -function cont() { - step_cpu(); -} - -function stop() { - /* Clear the interval that executes the CPU */ - clearInterval(interval); - interval = null; - updateRegistersHTML(); - running = false; -} - -/** - * T-states related functions - */ -function getTstates() { - return t_state; -} - -function addTstates(count) { - t_state += count; - - /* Kind-of static variable within function scope */ - addTstates.in_callback = addTstates.in_callback || false; - - /* Check if any callback can be called, if we aren't in any */ - if (!addTstates.in_callback) { - tstates_callbacks.forEach(entry => { - if (entry.tstates <= t_state) { - addTstates.in_callback = true; - entry.callback(); - if (entry.period == 0) { - tstates_callbacks.delete(entry); - } else { - entry.tstates += entry.period; - } - addTstates.in_callback = false; - } - }); - } -} - -/** - * Get the earliest callback out of the list. - */ -function getEarliestCallback() { - var earliest = null; - - tstates_callbacks.forEach((entry) => { - if (earliest == null || entry.tstates < earliest.tstates) { - earliest = entry; - } - }); - - return earliest; -} - -/** - * Register a callback that shall be called after the number of T-states - * of the CPU given. - * If the given number is less than 0, return an error. - */ -function registerTstateCallback(callback, call_tstates) { - if (call_tstates < 0) { - return null; - } - - var obj = null; - - /* If the CPU is halted, not registering this event in the list - * will make us completely miss it when function getEarliestCallback() - * is called. Because of that, the CPU will miss this interrupt/event. - * Keeping call_tstates as 0 should work, but let's be safe and make it - * happen in the upcoming T-state. */ - if (call_tstates == 0) { - call_tstates = 1; - } - - obj = { tstates: t_state + call_tstates, callback, period: 0 }; - tstates_callbacks.add(obj); - - return obj; -} - -/* Register a callback to be called every call_tstates T-states. - * The delay parameter will let us, defer the start of the first call, - * without altering the period. This is handy for period signal that changes - * values for a short period of time (pulses) - */ -function registerTstateInterval(callback, call_tstates, delay) { - if (call_tstates < 0) { - return null; - } - - /* If the delay parameter is not defined, set it to 0 */ - delay = delay || 0; - - const obj = { tstates: t_state + delay + call_tstates, callback, period: call_tstates }; - tstates_callbacks.add(obj); - return obj; -} - -function removeTstateCallback(callback) { - if (callback != null) { - tstates_callbacks.delete(callback); - } -} - -function interrupt(interrupt_vector) { - zpu.interrupt(false, interrupt_vector); - step_cpu(); -} - $("#read-button").on('click', function() { /* If a dump/map file was provided, try to load it */ let fdump = $("#file-dump")[0].files[0]; @@ -462,12 +177,12 @@ $("#read-button").on('click', function() { reader.addEventListener('load', function(e) { let binary = e.target.result; if (isos) { - rom.loadFile(binary); + zealcom.rom.loadFile(binary); $("#binready").addClass("ready"); } else { const addr = $("#address").val(); const result = parseInt(addr, 16); - ram.loadFile(result, binary); + zealcom.ram.loadFile(result, binary); } }); if (typeof file !== "undefined") { @@ -479,7 +194,7 @@ $("#read-button").on('click', function() { let eepromr = new FileReader(); eepromr.addEventListener('load', function(e) { let binary = e.target.result; - eeprom.loadFile(binary); + zealcom.eeprom.loadFile(binary); $("#eepromready").addClass("ready"); }); if (typeof file !== "undefined") { @@ -487,9 +202,8 @@ $("#read-button").on('click', function() { } }); - $("#screen").on("keydown", function(e) { - const handled = keyboard.key_pressed(e.keyCode); + const handled = zealcom.keyboard.key_pressed(e.keyCode); if (handled) { e.preventDefault(); @@ -497,7 +211,7 @@ $("#screen").on("keydown", function(e) { }); $("#screen").on("keyup", function(e) { - const handled = keyboard.key_released(e.keyCode); + const handled = zealcom.keyboard.key_released(e.keyCode); if (handled) { e.preventDefault(); @@ -532,6 +246,8 @@ $("#addbp").on("click", function (){ addBreakpoint(result); }); +var breakpoints = []; + function addBreakpoint(addr) { if (!breakpoints.includes(addr) && addr <= 0xFFFF) { breakpoints.push({ address: addr, enabled: true }); @@ -574,11 +290,17 @@ $("#memdump").on("click", ".dumpline", function() { } }); +/** + * @brief The following events must NOT be linked to zealcom object methods + * because that object will change after a reset. As such, these method must be + * evaluated and called lazily only when needed. + */ +$("#step").on("click", () => zealcom.step()); +$("#stop").on("click", () => zealcom.stop()); +$("#stepover").on("click", () => zealcom.step_over()); +$("#continue").on("click", () => zealcom.cont()); +$("#restart").on("click", () => zealcom.restart()); -$("#step").on("click", step); -$("#stop").on("click", stop); -$("#stepover").on("click", step_over); -$("#continue").on("click", cont); $("#bps").on("click", "li", function() { /* Get the breakpoint address */ const bkpaddr = $(this).data("addr"); @@ -633,7 +355,7 @@ $("#uart-file-send").on("click", function() { let reader = new FileReader(); reader.addEventListener('load', function(e) { let binary = e.target.result; - uart.send_binary_array(binary); + zealcom.uart.send_binary_array(binary); }); if (typeof file !== "undefined") { reader.readAsBinaryString(file); @@ -641,11 +363,11 @@ $("#uart-file-send").on("click", function() { }); document.addEventListener('keydown', function(event) { - const binding = {'F9': cont, 'F10': step, 'F11': step_over}; + const binding = {'F9': zealcom.cont, 'F10': zealcom.step, 'F11': zealcom.step_over}; if (binding[event.key]) { binding[event.key](); } - }); +}); $(".regaddr").click(function() { From d1587b0ad8e0ec64fd868fb25385ec2357fd78cf Mon Sep 17 00:00:00 2001 From: JasonMo1 <111677135+JasonMo1@users.noreply.github.com> Date: Tue, 15 Aug 2023 11:31:12 +0800 Subject: [PATCH 2/2] Restart: Repackaged some APIs --- keyboard.js | 8 ++++---- machine.js | 33 +++++++++++++++++++++++--------- pio.js | 2 +- rom.js | 4 ++-- screen.js | 4 ++-- uart.js | 6 +++--- zeal.js | 54 ++++++++++++++++++++++++++--------------------------- 7 files changed, 63 insertions(+), 48 deletions(-) diff --git a/keyboard.js b/keyboard.js index ef34a38..c92055f 100644 --- a/keyboard.js +++ b/keyboard.js @@ -262,7 +262,7 @@ function Keyboard(Zeal, PIO) { * * Returns true if the key is valid, false else. */ - function key_released(keycode) { + function key_released(keycode) { /* Get the PS/2 code for the key pressed */ const list = get_ps2_code(keycode); @@ -313,7 +313,7 @@ function Keyboard(Zeal, PIO) { transfer_active = false; } else { /* Schedule the next key in 1ms */ - zeal.tstatesutils.registerTstateCallback(() => { + zeal.registerTstateCallback(() => { transfer_active = false; send_next_keypress(); }, us_to_tstates(1000)); @@ -330,14 +330,14 @@ function Keyboard(Zeal, PIO) { for (var i = 0; i < scancodes.length; i++) { const index = i; - zeal.tstatesutils.registerTstateCallback(() => { + zeal.registerTstateCallback(() => { /* Prepare the next scancode */ shift_register = scancodes[index]; /* Assert the keyboard signal */ pio.pio_set_b_pin(IO_KEYBOARD_PIN, 0); } , i * PS2_KEY_TIMING + delay); - zeal.tstatesutils.registerTstateCallback(() => { + zeal.registerTstateCallback(() => { /* Reset the keyboard signal */ pio.pio_set_b_pin(IO_KEYBOARD_PIN, 1); /* Disable the flag too */ diff --git a/machine.js b/machine.js index ac06aa3..0c8323b 100644 --- a/machine.js +++ b/machine.js @@ -107,11 +107,6 @@ function Zeal8bitComputer() { } }, - interrupt: function(interrupt_vector) { - zpu.interrupt(false, interrupt_vector); - step_cpu(); - }, - adjustTStatesWhenHalted: function(end) { const earliest = tstatesutils.getEarliestCallback(); if (earliest == null || earliest.tstates > end) { @@ -126,7 +121,13 @@ function Zeal8bitComputer() { } } - this.tstatesutils = tstatesutils; + this.getTstates = tstatesutils.getTstates; + this.addTstates = tstatesutils.addTstates; + this.getEarliestCallback = tstatesutils.getEarliestCallback; + this.registerTstateCallback = tstatesutils.registerTstateCallback; + this.registerTstateInterval = tstatesutils.registerTstateInterval; + this.removeTstateCallback = tstatesutils.removeTstateCallback; + this.adjustTStatesWhenHalted = tstatesutils.adjustTStatesWhenHalted; /* Check which scale to use for the video */ var scale = 1; @@ -158,9 +159,7 @@ function Zeal8bitComputer() { this.eeprom = eeprom; this.devices = devices; this.zpu = zpu; - - var registers = zpu.getState(); - this.registers = registers; + this.getCPUState = zpu.getState function mem_read(address) { var rd = 0; @@ -314,12 +313,25 @@ function Zeal8bitComputer() { step_cpu(); } + function interrupt(interrupt_vector) { + zpu.interrupt(false, interrupt_vector); + step_cpu(); + } + function destroy() { clearInterval(interval); interval = null; running = false; } + function KeyboardKeyPressed(keycode) { + return keyboard.key_pressed(keycode); + } + + function KeyboardKeyReleased(keycode) { + return keyboard.key_released(keycode); + } + this.mem_read = mem_read; this.mem_write = mem_write; @@ -333,5 +345,8 @@ function Zeal8bitComputer() { this.stop = stop; this.restart = restart; this.reset = reset; + this.interrupt = interrupt; this.destroy = destroy; + this.KeyboardKeyPressed = KeyboardKeyPressed; + this.KeyboardKeyReleased = KeyboardKeyReleased; } \ No newline at end of file diff --git a/pio.js b/pio.js index 1a32b8e..9a1c145 100644 --- a/pio.js +++ b/pio.js @@ -189,7 +189,7 @@ function PIO(Zeal) { port.mode != MODE_OUTPUT && (port.mode != MODE_BITCTRL || pio_check_bitctrl_interrupt(port, pin, value))) { - zeal.tstatesutils.interrupt(port.int_vector); + zeal.interrupt(port.int_vector); } } diff --git a/rom.js b/rom.js index ed2e228..427f683 100644 --- a/rom.js +++ b/rom.js @@ -121,7 +121,7 @@ erasing = true; console.log("Erasing FLASH"); /* Erasing a sector takes 25ms on real hardware, register a callback to actually reflect this */ - zeal.tstatesutils.registerTstateCallback(() => { + zeal.registerTstateCallback(() => { for (var i = 0 ; i< 4096; i++) data[i + sector] = 0xff; erasing = false; @@ -156,7 +156,7 @@ writing = true; console.log("Writing byte to FLASH"); /* Writing a byte takes 20us on real hardware, register a callback to actually reflect this */ - zeal.tstatesutils.registerTstateCallback(() => { + zeal.registerTstateCallback(() => { data[address] = value; writing = false; writing_byte = 0; diff --git a/screen.js b/screen.js index dfb8160..aee10aa 100644 --- a/screen.js +++ b/screen.js @@ -343,7 +343,7 @@ function VideoChip(Zeal, PIO, scale) { /* We don't need to add a listener on the PIO, as they are mainly for OUTPUT pins. * But let's keep in mind that this may change in the future */ /* Start the V_Blank signal generation */ - const vblank_interval = zeal.tstatesutils.registerTstateInterval(() => { + const vblank_interval = zeal.registerTstateInterval(() => { /* Clear VBLANK bit in the PIO state */ pio.pio_set_b_pin(IO_VBLANK_PIN, 0); }, VBLANK_TSTATES_PERIOD); @@ -351,7 +351,7 @@ function VideoChip(Zeal, PIO, scale) { /* Register the same interval but for disabling the signal * So the period is the same as the one above, but we need to start it * a bit later (after 63us) */ - const vblank_interval_end = zeal.tstatesutils.registerTstateInterval(() => { + const vblank_interval_end = zeal.registerTstateInterval(() => { pio.pio_set_b_pin(IO_VBLANK_PIN, 1); }, VBLANK_TSTATES_PERIOD, VBLANK_TSTATES_PERIOD_END); diff --git a/uart.js b/uart.js index c95772b..3c6562a 100644 --- a/uart.js +++ b/uart.js @@ -55,13 +55,13 @@ function UART(Zeal, PIO) { return; } - const tstates = zeal.tstatesutils.getTstates(); + const tstates = zeal.getTstates(); /* Ignore the case where a transfer hasn't been started and the line is set to 1 */ if (bit == 1 && tx_fifo.length == 0) { /* Nothing to do */ } else if (bit == 0 && tx_fifo.length == 0) { /* Register a callback in 10 UART bits */ - zeal.tstatesutils.registerTstateCallback(transferComplete, Math.floor(9.1 * bit_tstates)); + zeal.registerTstateCallback(transferComplete, Math.floor(9.1 * bit_tstates)); tx_fifo.push({ tstates, bit }); } else { tx_fifo.push({ tstates, bit }); @@ -104,7 +104,7 @@ function UART(Zeal, PIO) { /* If we have to register a callback, do it now */ if (callback) { - zeal.tstatesutils.registerTstateCallback(start_shifting, bit_tstates - 1); + zeal.registerTstateCallback(start_shifting, bit_tstates - 1); } } diff --git a/zeal.js b/zeal.js index 71f3583..f94061f 100644 --- a/zeal.js +++ b/zeal.js @@ -57,9 +57,9 @@ function dumpRamContent(virtaddr, physaddr, lines) { } function setASMView() { - + let regs = zealcom.getCPUState(); /* Get the PC, which is a virtual address */ - const pc = zealcom.registers != null ? (zealcom.registers.pc) : 0; + const pc = regs != null ? (regs.pc) : 0; /* Set the number of instructions we need to disassemble and show */ const instructions = 20; @@ -124,30 +124,30 @@ function updateAndShowRAM () { } function updateRegistersHTML() { - let reg = zealcom.registers; - $("#rega").text(hex8(reg.a)); - $("#regb").text(hex8(reg.b)); - $("#regc").text(hex8(reg.c)); - $("#regd").text(hex8(reg.d)); - $("#rege").text(hex8(reg.e)); - $("#regh").text(hex8(reg.h)); - $("#regl").text(hex8(reg.l)); - $("#regix").text(hex(reg.ix)); - $("#regiy").text(hex(reg.iy)); - $("#regbc").text(hex16(reg.b, reg.c)); - $("#regde").text(hex16(reg.d, reg.e)); - $("#reghl").text(hex16(reg.h, reg.l)); - $("#regpc").text(hex(reg.pc)); - $("#regsp").text(hex(reg.sp)); + let regs = zealcom.getCPUState(); + $("#rega").text(hex8(regs.a)); + $("#regb").text(hex8(regs.b)); + $("#regc").text(hex8(regs.c)); + $("#regd").text(hex8(regs.d)); + $("#rege").text(hex8(regs.e)); + $("#regh").text(hex8(regs.h)); + $("#regl").text(hex8(regs.l)); + $("#regix").text(hex(regs.ix)); + $("#regiy").text(hex(regs.iy)); + $("#regbc").text(hex16(regs.b, regs.c)); + $("#regde").text(hex16(regs.d, regs.e)); + $("#reghl").text(hex16(regs.h, regs.l)); + $("#regpc").text(hex(regs.pc)); + $("#regsp").text(hex(regs.sp)); /* Special treatment for the flags */ - var flags = (reg.flags.S == 1 ? "S" : "") + - (reg.flags.Z == 1 ? "Z" : "") + - (reg.flags.Y == 1 ? "Y" : "") + - (reg.flags.H == 1 ? "H" : "") + - (reg.flags.X == 1 ? "X" : "") + - (reg.flags.P == 1 ? "P" : "") + - (reg.flags.N == 1 ? "N" : "") + - (reg.flags.C == 1 ? "C" : ""); + var flags = (regs.flags.S == 1 ? "S" : "") + + (regs.flags.Z == 1 ? "Z" : "") + + (regs.flags.Y == 1 ? "Y" : "") + + (regs.flags.H == 1 ? "H" : "") + + (regs.flags.X == 1 ? "X" : "") + + (regs.flags.P == 1 ? "P" : "") + + (regs.flags.N == 1 ? "N" : "") + + (regs.flags.C == 1 ? "C" : ""); $("#flags").text(flags); @@ -203,7 +203,7 @@ $("#read-button").on('click', function() { }); $("#screen").on("keydown", function(e) { - const handled = zealcom.keyboard.key_pressed(e.keyCode); + const handled = zealcom.KeyboardKeyPressed(e.keyCode); if (handled) { e.preventDefault(); @@ -211,7 +211,7 @@ $("#screen").on("keydown", function(e) { }); $("#screen").on("keyup", function(e) { - const handled = zealcom.keyboard.key_released(e.keyCode); + const handled = zealcom.KeyboardKeyReleased(e.keyCode); if (handled) { e.preventDefault();