rp2040js 0.19.3 → 1.0.0

package/dist/cjs/simulator.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Simulator = void 0;
+const simulation_clock_js_1 = require("./clock/simulation-clock.js");
+const rp2040_js_1 = require("./rp2040.js");
+class Simulator {
+    constructor(clock = new simulation_clock_js_1.SimulationClock()) {
+        this.clock = clock;
+        this.executeTimer = null;
+        this.stopped = true;
+        this.rp2040 = new rp2040_js_1.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;
+    }
+}
+exports.Simulator = Simulator;

package/dist/cjs/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/cjs/utils/timer32.js

@@ -12,7 +12,7 @@ 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;
@@ -20,13 +20,13 @@ 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();
     }
     /**
@@ -39,12 +39,12 @@ 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);
@@ -73,7 +73,7 @@ class Timer32 {
     }
     set frequency(value) {
         this.baseValue = this.counter;
-        this.baseMicros = this.clock.micros;
+        this.baseNanos = this.clock.nanos;
         this.baseFreq = value;
         this.updated();
     }
@@ -82,14 +82,14 @@ 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;
@@ -97,7 +97,7 @@ 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;
@@ -141,6 +141,7 @@ class Timer32PeriodicAlarm {
                 this.schedule();
             }
         };
+        this.clockAlarm = this.timer.clock.createAlarm(this.handleAlarm);
         timer.listeners.push(this.update);
     }
     get enable() {
@@ -195,14 +196,11 @@ 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();
     }
 }
 exports.Timer32PeriodicAlarm = Timer32PeriodicAlarm;

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

@@ -1,11 +1,9 @@
-export interface IClockTimer {
-    pause(currentMicros: number): void;
-    resume(currentMicros: number): void;
+export type AlarmCallback = () => void;
+export interface IAlarm {
+    schedule(deltaNanos: number): void;
+    cancel(): void;
 }
 export interface IClock {
-    readonly micros: number;
-    pause(): void;
-    resume(): void;
-    createTimer(deltaMicros: number, callback: () => void): IClockTimer;
-    deleteTimer(timer: IClockTimer): void;
+    readonly nanos: number;
+    createAlarm(callback: AlarmCallback): IAlarm;
 }

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

@@ -1,17 +1,4 @@
-import { IClock, IClockTimer } from './clock.js';
-export declare class MockClockTimer implements IClockTimer {
-    readonly micros: number;
-    readonly callback: () => void;
-    constructor(micros: number, callback: () => void);
-    pause(): void;
-    resume(): void;
-}
-export declare class MockClock implements IClock {
-    micros: number;
-    readonly timers: MockClockTimer[];
-    pause(): void;
-    resume(): void;
+import { SimulationClock } from './simulation-clock.js';
+export declare class MockClock extends SimulationClock {
     advance(deltaMicros: number): void;
-    createTimer(deltaMicros: number, callback: () => void): MockClockTimer;
-    deleteTimer(timer: IClockTimer): void;
 }

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

@@ -1,47 +1,6 @@
-export class MockClockTimer {
-    constructor(micros, callback) {
-        this.micros = micros;
-        this.callback = callback;
-    }
-    pause() {
-        /* intentionally empty */
-    }
-    resume() {
-        /* intentionally empty */
-    }
-}
-export class MockClock {
-    constructor() {
-        this.micros = 0;
-        this.timers = [];
-    }
-    pause() {
-        /* intentionally empty */
-    }
-    resume() {
-        /* intentionally empty */
-    }
+import { SimulationClock } from './simulation-clock.js';
+export class MockClock extends SimulationClock {
     advance(deltaMicros) {
-        const { timers } = this;
-        const targetTime = this.micros + Math.max(deltaMicros, 0.01);
-        while (timers[0] && timers[0].micros <= targetTime) {
-            const timer = timers.shift();
-            if (timer) {
-                this.micros = timer.micros;
-                timer.callback();
-            }
-        }
-    }
-    createTimer(deltaMicros, callback) {
-        const timer = new MockClockTimer(this.micros + deltaMicros, callback);
-        this.timers.push(timer);
-        this.timers.sort((a, b) => a.micros - b.micros);
-        return timer;
-    }
-    deleteTimer(timer) {
-        const timerIndex = this.timers.indexOf(timer);
-        if (timerIndex >= 0) {
-            this.timers.splice(timerIndex, 1);
-        }
+        this.tick(this.nanos + deltaMicros * 1000);
     }
 }

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

@@ -0,0 +1,26 @@
+import { AlarmCallback, IAlarm, IClock } from './clock.js';
+type ClockEventCallback = () => void;
+export declare class ClockAlarm implements IAlarm {
+    private readonly clock;
+    readonly callback: AlarmCallback;
+    next: ClockAlarm | null;
+    nanos: number;
+    scheduled: boolean;
+    constructor(clock: SimulationClock, callback: AlarmCallback);
+    schedule(deltaNanos: number): void;
+    cancel(): void;
+}
+export declare class SimulationClock implements IClock {
+    readonly frequency: number;
+    private nextAlarm;
+    private nanosCounter;
+    constructor(frequency?: number);
+    get nanos(): number;
+    get micros(): number;
+    createAlarm(callback: ClockEventCallback): ClockAlarm;
+    linkAlarm(nanos: number, alarm: ClockAlarm): ClockAlarm;
+    unlinkAlarm(alarm: ClockAlarm): boolean;
+    tick(deltaNanos: number): void;
+    get nanosToNextAlarm(): number;
+}
+export {};

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

@@ -0,0 +1,92 @@
+export class ClockAlarm {
+    constructor(clock, callback) {
+        this.clock = clock;
+        this.callback = callback;
+        this.next = null;
+        this.nanos = 0;
+        this.scheduled = false;
+    }
+    schedule(deltaNanos) {
+        if (this.scheduled) {
+            this.cancel();
+        }
+        this.clock.linkAlarm(deltaNanos, this);
+    }
+    cancel() {
+        this.clock.unlinkAlarm(this);
+        this.scheduled = false;
+    }
+}
+export class SimulationClock {
+    constructor(frequency = 125e6) {
+        this.frequency = frequency;
+        this.nextAlarm = null;
+        this.nanosCounter = 0;
+    }
+    get nanos() {
+        return this.nanosCounter;
+    }
+    get micros() {
+        return this.nanos / 1000;
+    }
+    createAlarm(callback) {
+        return new ClockAlarm(this, callback);
+    }
+    linkAlarm(nanos, alarm) {
+        alarm.nanos = this.nanos + nanos;
+        let alarmListItem = this.nextAlarm;
+        let lastItem = null;
+        while (alarmListItem && alarmListItem.nanos < alarm.nanos) {
+            lastItem = alarmListItem;
+            alarmListItem = alarmListItem.next;
+        }
+        if (lastItem) {
+            lastItem.next = alarm;
+            alarm.next = alarmListItem;
+        }
+        else {
+            this.nextAlarm = alarm;
+            alarm.next = alarmListItem;
+        }
+        alarm.scheduled = true;
+        return alarm;
+    }
+    unlinkAlarm(alarm) {
+        let alarmListItem = this.nextAlarm;
+        if (!alarmListItem) {
+            return false;
+        }
+        let lastItem = null;
+        while (alarmListItem) {
+            if (alarmListItem === alarm) {
+                if (lastItem) {
+                    lastItem.next = alarmListItem.next;
+                }
+                else {
+                    this.nextAlarm = alarmListItem.next;
+                }
+                return true;
+            }
+            lastItem = alarmListItem;
+            alarmListItem = alarmListItem.next;
+        }
+        return false;
+    }
+    tick(deltaNanos) {
+        const targetNanos = this.nanosCounter + deltaNanos;
+        let alarm = this.nextAlarm;
+        while (alarm && alarm.nanos <= targetNanos) {
+            this.nextAlarm = alarm.next;
+            this.nanosCounter = alarm.nanos;
+            alarm.callback();
+            alarm = this.nextAlarm;
+        }
+        this.nanosCounter = targetNanos;
+    }
+    get nanosToNextAlarm() {
+        if (this.nextAlarm) {
+            return this.nextAlarm.nanos - this.nanos;
+        }
+        return 0;
+    }
+}

package/dist/esm/cortex-m0-core.d.ts

@@ -82,6 +82,6 @@ export declare class CortexM0Core {
     private substractUpdateFlags;
     private addUpdateFlags;
     cyclesIO(addr: number, write?: boolean): 0 | 1 | 3 | 4;
-    executeInstruction(): void;
+    executeInstruction(): number;
 }
 export {};