rp2040js 0.19.4 → 1.0.0

package/dist/esm/rp2040.js

@@ -1,4 +1,4 @@
-import { RealtimeClock } from './clock/realtime-clock.js';
+import { SimulationClock } from './clock/simulation-clock.js';
 import { CortexM0Core } from './cortex-m0-core.js';
 import { GPIOPin } from './gpio-pin.js';
 import { IRQ } from './irq.js';
@@ -37,7 +37,7 @@ const KB = 1024;
 const MB = 1024 * KB;
 const MHz = 1000000;
 export class RP2040 {
-    constructor(clock = new RealtimeClock()) {
+    constructor(clock = new SimulationClock()) {
         this.clock = clock;
         this.bootrom = new Uint32Array(4 * KB);
         this.sram = new Uint8Array(264 * KB);
@@ -122,9 +122,7 @@ export class RP2040 {
                 tx: DREQChannel.DREQ_SPI1_TX,
             }),
         ];
-        this.stopped = true;
         this.logger = new ConsoleLogger(LogLevel.Debug, true);
-        this.executeTimer = null;
         this.peripherals = {
             0x18000: new RPSSI(this, 'SSI'),
             0x40000: new RP2040SysInfo(this, 'SYSINFO_BASE'),
@@ -164,7 +162,6 @@ export class RP2040 {
         this.onBreak = (code) => {
             // TODO: raise HardFault exception
             // console.error('Breakpoint!', code);
-            this.stopped = true;
         };
         this.reset();
     }
@@ -339,26 +336,4 @@ export class RP2040 {
     step() {
         this.core.executeInstruction();
     }
-    execute() {
-        this.clock.resume();
-        this.executeTimer = null;
-        this.stopped = false;
-        for (let i = 0; i < 100000 && !this.stopped && !this.core.waiting; i++) {
-            this.core.executeInstruction();
-        }
-        if (!this.stopped) {
-            this.executeTimer = setTimeout(() => this.execute(), 0);
-        }
-    }
-    stop() {
-        this.stopped = true;
-        if (this.executeTimer != null) {
-            clearTimeout(this.executeTimer);
-            this.executeTimer = null;
-        }
-        this.clock.pause();
-    }
-    get executing() {
-        return !this.stopped;
-    }
 }

package/dist/esm/simulator.d.ts

@@ -0,0 +1,13 @@
+import { SimulationClock } from './clock/simulation-clock.js';
+import { IGDBTarget } from './gdb/gdb-target.js';
+import { RP2040 } from './rp2040.js';
+export declare class Simulator implements IGDBTarget {
+    readonly clock: SimulationClock;
+    executeTimer: ReturnType<typeof setTimeout> | null;
+    rp2040: RP2040;
+    stopped: boolean;
+    constructor(clock?: SimulationClock);
+    execute(): void;
+    stop(): void;
+    get executing(): boolean;
+}

package/dist/esm/simulator.js

@@ -0,0 +1,41 @@
+import { SimulationClock } from './clock/simulation-clock.js';
+import { RP2040 } from './rp2040.js';
+export class Simulator {
+    constructor(clock = new SimulationClock()) {
+        this.clock = clock;
+        this.executeTimer = null;
+        this.stopped = true;
+        this.rp2040 = new RP2040(clock);
+        this.rp2040.onBreak = () => this.stop();
+    }
+    execute() {
+        const { rp2040, clock } = this;
+        this.executeTimer = null;
+        this.stopped = false;
+        const cycleNanos = 1e9 / 125000000; // 125 MHz
+        for (let i = 0; i < 1000000 && !this.stopped; i++) {
+            if (rp2040.core.waiting) {
+                const { nanosToNextAlarm } = clock;
+                clock.tick(nanosToNextAlarm);
+                i += nanosToNextAlarm / cycleNanos;
+            }
+            else {
+                const cycles = rp2040.core.executeInstruction();
+                clock.tick(cycles * cycleNanos);
+            }
+        }
+        if (!this.stopped) {
+            this.executeTimer = setTimeout(() => this.execute(), 0);
+        }
+    }
+    stop() {
+        this.stopped = true;
+        if (this.executeTimer != null) {
+            clearTimeout(this.executeTimer);
+            this.executeTimer = null;
+        }
+    }
+    get executing() {
+        return !this.stopped;
+    }
+}

package/dist/esm/utils/timer32.d.ts

@@ -8,7 +8,7 @@ export declare class Timer32 {
     readonly clock: IClock;
     private baseFreq;
     private baseValue;
-    private baseMicros;
+    private baseNanos;
     private topValue;
     private prescalerValue;
     private timerMode;
@@ -32,7 +32,7 @@ export declare class Timer32 {
     set frequency(value: number);
     get prescaler(): number;
     set prescaler(value: number);
-    toMicros(cycles: number): number;
+    toNanos(cycles: number): number;
     get enable(): boolean;
     set enable(value: boolean);
     get mode(): TimerMode;
@@ -44,7 +44,7 @@ export declare class Timer32PeriodicAlarm {
     readonly callback: () => void;
     private targetValue;
     private enabled;
-    private clockTimer?;
+    private clockAlarm;
     constructor(timer: Timer32, callback: () => void);
     get enable(): boolean;
     set enable(value: boolean);

package/dist/esm/utils/timer32.js

@@ -9,7 +9,7 @@ export class Timer32 {
         this.clock = clock;
         this.baseFreq = baseFreq;
         this.baseValue = 0;
-        this.baseMicros = 0;
+        this.baseNanos = 0;
         this.topValue = 0xffffffff;
         this.prescalerValue = 1;
         this.timerMode = TimerMode.Increment;
@@ -17,13 +17,13 @@ export class Timer32 {
         this.listeners = [];
     }
     reset() {
-        this.baseMicros = this.clock.micros;
+        this.baseNanos = this.clock.nanos;
         this.baseValue = 0;
         this.updated();
     }
     set(value, zigZagDown = false) {
         this.baseValue = zigZagDown ? this.topValue * 2 - value : value;
-        this.baseMicros = this.clock.micros;
+        this.baseNanos = this.clock.nanos;
         this.updated();
     }
     /**
@@ -36,12 +36,12 @@ export class Timer32 {
         this.baseValue += delta;
     }
     get rawCounter() {
-        const { baseFreq, prescalerValue, baseMicros, baseValue, enabled, timerMode } = this;
+        const { baseFreq, prescalerValue, baseNanos, baseValue, enabled, timerMode } = this;
         if (!baseFreq || !prescalerValue || !enabled) {
             return this.baseValue;
         }
         const zigzag = timerMode == TimerMode.ZigZag;
-        const ticks = ((this.clock.micros - baseMicros) / 1e6) * (baseFreq / prescalerValue);
+        const ticks = ((this.clock.nanos - baseNanos) / 1e9) * (baseFreq / prescalerValue);
         const topModulo = zigzag ? this.topValue * 2 : this.topValue + 1;
         const delta = timerMode == TimerMode.Decrement ? topModulo - (ticks % topModulo) : ticks;
         let currentValue = Math.round(baseValue + delta);
@@ -70,7 +70,7 @@ export class Timer32 {
     }
     set frequency(value) {
         this.baseValue = this.counter;
-        this.baseMicros = this.clock.micros;
+        this.baseNanos = this.clock.nanos;
         this.baseFreq = value;
         this.updated();
     }
@@ -79,14 +79,14 @@ export class Timer32 {
     }
     set prescaler(value) {
         this.baseValue = this.counter;
-        this.baseMicros = this.clock.micros;
+        this.baseNanos = this.clock.nanos;
         this.enabled = this.prescalerValue !== 0;
         this.prescalerValue = value;
         this.updated();
     }
-    toMicros(cycles) {
+    toNanos(cycles) {
         const { baseFreq, prescalerValue } = this;
-        return (cycles * 1e6) / (baseFreq / prescalerValue);
+        return (cycles * 1e9) / (baseFreq / prescalerValue);
     }
     get enable() {
         return this.enabled;
@@ -94,7 +94,7 @@ export class Timer32 {
     set enable(value) {
         if (value !== this.enabled) {
             if (value) {
-                this.baseMicros = this.clock.micros;
+                this.baseNanos = this.clock.nanos;
             }
             else {
                 this.baseValue = this.counter;
@@ -137,6 +137,7 @@ export class Timer32PeriodicAlarm {
                 this.schedule();
             }
         };
+        this.clockAlarm = this.timer.clock.createAlarm(this.handleAlarm);
         timer.listeners.push(this.update);
     }
     get enable() {
@@ -191,13 +192,10 @@ export class Timer32PeriodicAlarm {
             cycleDelta = top + 1 - cycleDelta;
         }
         const cyclesToAlarm = cycleDelta >>> 0;
-        const microsToAlarm = timer.toMicros(cyclesToAlarm);
-        this.clockTimer = this.timer.clock.createTimer(microsToAlarm, this.handleAlarm);
+        const nanosToAlarm = timer.toNanos(cyclesToAlarm);
+        this.clockAlarm.schedule(nanosToAlarm);
     }
     cancel() {
-        if (this.clockTimer) {
-            this.timer.clock.deleteTimer(this.clockTimer);
-            this.clockTimer = undefined;
-        }
+        this.clockAlarm.cancel();
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rp2040js",
-  "version": "0.19.4",
+  "version": "1.0.0",
   "description": "Raspberry Pi Pico (RP2040) Emulator",
   "repository": "https://github.com/wokwi/rp2040js",
   "keywords": [

package/dist/cjs/clock/realtime-clock.d.ts

@@ -1,23 +0,0 @@
-import { IClock, IClockTimer } from './clock.js';
-export declare class ClockTimer implements IClockTimer {
-    private micros;
-    private callback;
-    private jsTimer;
-    private timeLeft;
-    constructor(micros: number, callback: () => void);
-    schedule(currentMicros: number): void;
-    unschedule(): void;
-    pause(currentMicros: number): void;
-    resume(currentMicros: number): void;
-}
-export declare class RealtimeClock implements IClock {
-    baseTime: number;
-    pauseTime: number;
-    paused: boolean;
-    timers: Set<ClockTimer>;
-    pause(): void;
-    resume(): void;
-    createTimer(deltaMicros: number, callback: () => void): ClockTimer;
-    deleteTimer(timer: ClockTimer): void;
-    get micros(): number;
-}

package/dist/cjs/clock/realtime-clock.js

@@ -1,73 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RealtimeClock = exports.ClockTimer = void 0;
-const time_js_1 = require("../utils/time.js");
-class ClockTimer {
-    constructor(micros, callback) {
-        this.micros = micros;
-        this.callback = callback;
-        this.jsTimer = null;
-        this.timeLeft = this.micros;
-    }
-    schedule(currentMicros) {
-        this.jsTimer = setTimeout(this.callback, (this.micros - currentMicros) / 1000);
-    }
-    unschedule() {
-        if (this.jsTimer) {
-            clearTimeout(this.jsTimer);
-            this.jsTimer = null;
-        }
-    }
-    pause(currentMicros) {
-        this.timeLeft = this.micros - currentMicros;
-        this.unschedule();
-    }
-    resume(currentMicros) {
-        this.micros = currentMicros + this.timeLeft;
-        this.schedule(currentMicros);
-    }
-}
-exports.ClockTimer = ClockTimer;
-class RealtimeClock {
-    constructor() {
-        this.baseTime = 0;
-        this.pauseTime = 0;
-        this.paused = true;
-        this.timers = new Set();
-    }
-    pause() {
-        if (!this.paused) {
-            for (const timer of this.timers) {
-                timer.pause(this.micros);
-            }
-            this.pauseTime = this.micros;
-            this.paused = true;
-        }
-    }
-    resume() {
-        if (this.paused) {
-            this.baseTime = (0, time_js_1.getCurrentMicroseconds)() - this.pauseTime;
-            this.paused = false;
-            for (const timer of this.timers) {
-                timer.resume(this.micros);
-            }
-        }
-    }
-    createTimer(deltaMicros, callback) {
-        const timer = new ClockTimer(this.micros + deltaMicros, () => {
-            this.timers.delete(timer);
-            callback();
-        });
-        timer.schedule(this.micros);
-        this.timers.add(timer);
-        return timer;
-    }
-    deleteTimer(timer) {
-        timer.unschedule();
-        this.timers.delete(timer);
-    }
-    get micros() {
-        return (0, time_js_1.getCurrentMicroseconds)() - this.baseTime;
-    }
-}
-exports.RealtimeClock = RealtimeClock;

package/dist/esm/clock/realtime-clock.d.ts

@@ -1,23 +0,0 @@
-import { IClock, IClockTimer } from './clock.js';
-export declare class ClockTimer implements IClockTimer {
-    private micros;
-    private callback;
-    private jsTimer;
-    private timeLeft;
-    constructor(micros: number, callback: () => void);
-    schedule(currentMicros: number): void;
-    unschedule(): void;
-    pause(currentMicros: number): void;
-    resume(currentMicros: number): void;
-}
-export declare class RealtimeClock implements IClock {
-    baseTime: number;
-    pauseTime: number;
-    paused: boolean;
-    timers: Set<ClockTimer>;
-    pause(): void;
-    resume(): void;
-    createTimer(deltaMicros: number, callback: () => void): ClockTimer;
-    deleteTimer(timer: ClockTimer): void;
-    get micros(): number;
-}

package/dist/esm/clock/realtime-clock.js

@@ -1,68 +0,0 @@
-import { getCurrentMicroseconds } from '../utils/time.js';
-export class ClockTimer {
-    constructor(micros, callback) {
-        this.micros = micros;
-        this.callback = callback;
-        this.jsTimer = null;
-        this.timeLeft = this.micros;
-    }
-    schedule(currentMicros) {
-        this.jsTimer = setTimeout(this.callback, (this.micros - currentMicros) / 1000);
-    }
-    unschedule() {
-        if (this.jsTimer) {
-            clearTimeout(this.jsTimer);
-            this.jsTimer = null;
-        }
-    }
-    pause(currentMicros) {
-        this.timeLeft = this.micros - currentMicros;
-        this.unschedule();
-    }
-    resume(currentMicros) {
-        this.micros = currentMicros + this.timeLeft;
-        this.schedule(currentMicros);
-    }
-}
-export class RealtimeClock {
-    constructor() {
-        this.baseTime = 0;
-        this.pauseTime = 0;
-        this.paused = true;
-        this.timers = new Set();
-    }
-    pause() {
-        if (!this.paused) {
-            for (const timer of this.timers) {
-                timer.pause(this.micros);
-            }
-            this.pauseTime = this.micros;
-            this.paused = true;
-        }
-    }
-    resume() {
-        if (this.paused) {
-            this.baseTime = getCurrentMicroseconds() - this.pauseTime;
-            this.paused = false;
-            for (const timer of this.timers) {
-                timer.resume(this.micros);
-            }
-        }
-    }
-    createTimer(deltaMicros, callback) {
-        const timer = new ClockTimer(this.micros + deltaMicros, () => {
-            this.timers.delete(timer);
-            callback();
-        });
-        timer.schedule(this.micros);
-        this.timers.add(timer);
-        return timer;
-    }
-    deleteTimer(timer) {
-        timer.unschedule();
-        this.timers.delete(timer);
-    }
-    get micros() {
-        return getCurrentMicroseconds() - this.baseTime;
-    }
-}