rp2040js 0.17.17 → 0.18.0

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

@@ -1,11 +1,11 @@
-export interface IClockTimer {
-    pause(currentMicros: number): void;
-    resume(currentMicros: number): void;
-}
-export interface IClock {
-    readonly micros: number;
-    pause(): void;
-    resume(): void;
-    createTimer(deltaMicros: number, callback: () => void): IClockTimer;
-    deleteTimer(timer: IClockTimer): void;
-}
+export interface IClockTimer {
+    pause(currentMicros: number): void;
+    resume(currentMicros: number): void;
+}
+export interface IClock {
+    readonly micros: number;
+    pause(): void;
+    resume(): void;
+    createTimer(deltaMicros: number, callback: () => void): IClockTimer;
+    deleteTimer(timer: IClockTimer): void;
+}

package/dist/cjs/clock/clock.js

@@ -1,2 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,17 +1,17 @@
-import { IClock, IClockTimer } from './clock';
-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;
-    advance(deltaMicros: number): void;
-    createTimer(deltaMicros: number, callback: () => void): MockClockTimer;
-    deleteTimer(timer: IClockTimer): void;
-}
+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;
+    advance(deltaMicros: number): void;
+    createTimer(deltaMicros: number, callback: () => void): MockClockTimer;
+    deleteTimer(timer: IClockTimer): void;
+}

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

@@ -1,52 +1,52 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MockClock = exports.MockClockTimer = void 0;
-class MockClockTimer {
-    constructor(micros, callback) {
-        this.micros = micros;
-        this.callback = callback;
-    }
-    pause() {
-        /* intentionally empty */
-    }
-    resume() {
-        /* intentionally empty */
-    }
-}
-exports.MockClockTimer = MockClockTimer;
-class MockClock {
-    constructor() {
-        this.micros = 0;
-        this.timers = [];
-    }
-    pause() {
-        /* intentionally empty */
-    }
-    resume() {
-        /* intentionally empty */
-    }
-    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);
-        }
-    }
-}
-exports.MockClock = MockClock;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockClock = exports.MockClockTimer = void 0;
+class MockClockTimer {
+    constructor(micros, callback) {
+        this.micros = micros;
+        this.callback = callback;
+    }
+    pause() {
+        /* intentionally empty */
+    }
+    resume() {
+        /* intentionally empty */
+    }
+}
+exports.MockClockTimer = MockClockTimer;
+class MockClock {
+    constructor() {
+        this.micros = 0;
+        this.timers = [];
+    }
+    pause() {
+        /* intentionally empty */
+    }
+    resume() {
+        /* intentionally empty */
+    }
+    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);
+        }
+    }
+}
+exports.MockClock = MockClock;

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

@@ -1,23 +1,23 @@
-import { IClock, IClockTimer } from './clock';
-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;
-}
+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 +1,73 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RealtimeClock = exports.ClockTimer = void 0;
-const time_1 = require("../utils/time");
-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 = time_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 time_1.getCurrentMicroseconds() - this.baseTime;
-    }
-}
-exports.RealtimeClock = RealtimeClock;
+"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/cjs/cortex-m0-core.d.ts

@@ -1,87 +1,87 @@
-import { RP2040 } from './rp2040';
-export declare const SYSM_MSP = 8;
-export declare const SYSM_PSP = 9;
-export declare const SYSM_PRIMASK = 16;
-export declare const SYSM_CONTROL = 20;
-declare enum ExecutionMode {
-    Mode_Thread = 0,
-    Mode_Handler = 1
-}
-declare enum StackPointerBank {
-    SPmain = 0,
-    SPprocess = 1
-}
-export declare class CortexM0Core {
-    readonly rp2040: RP2040;
-    readonly registers: Uint32Array;
-    bankedSP: number;
-    cycles: number;
-    eventRegistered: boolean;
-    waiting: boolean;
-    N: boolean;
-    C: boolean;
-    Z: boolean;
-    V: boolean;
-    breakRewind: number;
-    PM: boolean;
-    SPSEL: StackPointerBank;
-    nPRIV: boolean;
-    currentMode: ExecutionMode;
-    IPSR: number;
-    interruptNMIMask: number;
-    pendingInterrupts: number;
-    enabledInterrupts: number;
-    interruptPriorities: number[];
-    pendingNMI: boolean;
-    pendingPendSV: boolean;
-    pendingSVCall: boolean;
-    pendingSystick: boolean;
-    interruptsUpdated: boolean;
-    VTOR: number;
-    SHPR2: number;
-    SHPR3: number;
-    /** Hook to listen for function calls - branch-link (BL/BLX) instructions */
-    blTaken: (core: CortexM0Core, blx: boolean) => void;
-    constructor(rp2040: RP2040);
-    get logger(): import(".").Logger;
-    reset(): void;
-    get SP(): number;
-    set SP(value: number);
-    get LR(): number;
-    set LR(value: number);
-    get PC(): number;
-    set PC(value: number);
-    get APSR(): number;
-    set APSR(value: number);
-    get xPSR(): number;
-    set xPSR(value: number);
-    checkCondition(cond: number): boolean;
-    readUint32(address: number): number;
-    readUint16(address: number): number;
-    readUint8(address: number): number;
-    writeUint32(address: number, value: number): void;
-    writeUint16(address: number, value: number): void;
-    writeUint8(address: number, value: number): void;
-    switchStack(stack: StackPointerBank): void;
-    get SPprocess(): number;
-    set SPprocess(value: number);
-    get SPmain(): number;
-    set SPmain(value: number);
-    exceptionEntry(exceptionNumber: number): void;
-    exceptionReturn(excReturn: number): void;
-    get pendSVPriority(): number;
-    get svCallPriority(): number;
-    get systickPriority(): number;
-    exceptionPriority(n: number): number;
-    get vectPending(): number;
-    setInterrupt(irq: number, value: boolean): void;
-    checkForInterrupts(): boolean;
-    readSpecialRegister(sysm: number): number;
-    writeSpecialRegister(sysm: number, value: number): 0 | undefined;
-    BXWritePC(address: number): void;
-    private substractUpdateFlags;
-    private addUpdateFlags;
-    cyclesIO(addr: number, write?: boolean): 3 | 0 | 1 | 4;
-    executeInstruction(): void;
-}
-export {};
+import { RP2040 } from './rp2040.js';
+export declare const SYSM_MSP = 8;
+export declare const SYSM_PSP = 9;
+export declare const SYSM_PRIMASK = 16;
+export declare const SYSM_CONTROL = 20;
+declare enum ExecutionMode {
+    Mode_Thread = 0,
+    Mode_Handler = 1
+}
+declare enum StackPointerBank {
+    SPmain = 0,
+    SPprocess = 1
+}
+export declare class CortexM0Core {
+    readonly rp2040: RP2040;
+    readonly registers: Uint32Array;
+    bankedSP: number;
+    cycles: number;
+    eventRegistered: boolean;
+    waiting: boolean;
+    N: boolean;
+    C: boolean;
+    Z: boolean;
+    V: boolean;
+    breakRewind: number;
+    PM: boolean;
+    SPSEL: StackPointerBank;
+    nPRIV: boolean;
+    currentMode: ExecutionMode;
+    IPSR: number;
+    interruptNMIMask: number;
+    pendingInterrupts: number;
+    enabledInterrupts: number;
+    interruptPriorities: number[];
+    pendingNMI: boolean;
+    pendingPendSV: boolean;
+    pendingSVCall: boolean;
+    pendingSystick: boolean;
+    interruptsUpdated: boolean;
+    VTOR: number;
+    SHPR2: number;
+    SHPR3: number;
+    /** Hook to listen for function calls - branch-link (BL/BLX) instructions */
+    blTaken: (core: CortexM0Core, blx: boolean) => void;
+    constructor(rp2040: RP2040);
+    get logger(): import("./index.js").Logger;
+    reset(): void;
+    get SP(): number;
+    set SP(value: number);
+    get LR(): number;
+    set LR(value: number);
+    get PC(): number;
+    set PC(value: number);
+    get APSR(): number;
+    set APSR(value: number);
+    get xPSR(): number;
+    set xPSR(value: number);
+    checkCondition(cond: number): boolean;
+    readUint32(address: number): number;
+    readUint16(address: number): number;
+    readUint8(address: number): number;
+    writeUint32(address: number, value: number): void;
+    writeUint16(address: number, value: number): void;
+    writeUint8(address: number, value: number): void;
+    switchStack(stack: StackPointerBank): void;
+    get SPprocess(): number;
+    set SPprocess(value: number);
+    get SPmain(): number;
+    set SPmain(value: number);
+    exceptionEntry(exceptionNumber: number): void;
+    exceptionReturn(excReturn: number): void;
+    get pendSVPriority(): number;
+    get svCallPriority(): number;
+    get systickPriority(): number;
+    exceptionPriority(n: number): number;
+    get vectPending(): number;
+    setInterrupt(irq: number, value: boolean): void;
+    checkForInterrupts(): boolean;
+    readSpecialRegister(sysm: number): number;
+    writeSpecialRegister(sysm: number, value: number): 0 | undefined;
+    BXWritePC(address: number): void;
+    private substractUpdateFlags;
+    private addUpdateFlags;
+    cyclesIO(addr: number, write?: boolean): 0 | 1 | 3 | 4;
+    executeInstruction(): void;
+}
+export {};