rp2040js 0.19.4 → 1.0.0

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 {};

package/dist/esm/cortex-m0-core.js

@@ -526,7 +526,7 @@ export class CortexM0Core {
         const wideInstruction = opcode >> 12 === 0b1111 || opcode >> 11 === 0b11101;
         const opcode2 = wideInstruction ? this.readUint16(opcodePC + 2) : 0;
         this.PC += 2;
-        this.cycles++;
+        let deltaCycles = 1;
         // ADCS
         if (opcode >> 6 === 0b0100000101) {
             const Rm = (opcode >> 3) & 0x7;
@@ -576,7 +576,7 @@ export class CortexM0Core {
             }
             else if (Rdn === pcRegister) {
                 this.registers[Rdn] = result & ~0x1;
-                this.cycles++;
+                deltaCycles++;
             }
             else if (Rdn === spRegister) {
                 this.registers[Rdn] = result & ~0x3;
@@ -631,7 +631,7 @@ export class CortexM0Core {
             }
             if (this.checkCondition(cond)) {
                 this.PC += imm8 + 2;
-                this.cycles++;
+                deltaCycles++;
             }
         }
         // B
@@ -641,7 +641,7 @@ export class CortexM0Core {
                 imm11 = (imm11 & 0x7ff) - 0x800;
             }
             this.PC += imm11 + 2;
-            this.cycles++;
+            deltaCycles++;
         }
         // BICS
         else if (opcode >> 6 === 0b0100001110) {
@@ -669,7 +669,7 @@ export class CortexM0Core {
             const imm32 = ((S ? 0b11111111 : 0) << 24) | ((I1 << 23) | (I2 << 22) | (imm10 << 12) | (imm11 << 1));
             this.LR = (this.PC + 2) | 0x1;
             this.PC += 2 + imm32;
-            this.cycles += 2;
+            deltaCycles += 2;
             this.blTaken(this, false);
         }
         // BLX
@@ -677,14 +677,14 @@ export class CortexM0Core {
             const Rm = (opcode >> 3) & 0xf;
             this.LR = this.PC | 0x1;
             this.PC = this.registers[Rm] & ~1;
-            this.cycles++;
+            deltaCycles++;
             this.blTaken(this, true);
         }
         // BX
         else if (opcode >> 7 === 0b010001110 && (opcode & 0x7) === 0) {
             const Rm = (opcode >> 3) & 0xf;
             this.BXWritePC(this.registers[Rm]);
-            this.cycles++;
+            deltaCycles++;
         }
         // CMN (register)
         else if (opcode >> 6 === 0b0100001011) {
@@ -722,12 +722,12 @@ export class CortexM0Core {
         // DMB SY
         else if (opcode === 0xf3bf && (opcode2 & 0xfff0) === 0x8f50) {
             this.PC += 2;
-            this.cycles += 2;
+            deltaCycles += 2;
         }
         // DSB SY
         else if (opcode === 0xf3bf && (opcode2 & 0xfff0) === 0x8f40) {
             this.PC += 2;
-            this.cycles += 2;
+            deltaCycles += 2;
         }
         // EORS
         else if (opcode >> 6 === 0b0100000001) {
@@ -741,7 +741,7 @@ export class CortexM0Core {
         // ISB SY
         else if (opcode === 0xf3bf && (opcode2 & 0xfff0) === 0x8f60) {
             this.PC += 2;
-            this.cycles += 2;
+            deltaCycles += 2;
         }
         // LDMIA
         else if (opcode >> 11 === 0b11001) {
@@ -752,7 +752,7 @@ export class CortexM0Core {
                 if (registers & (1 << i)) {
                     this.registers[i] = this.readUint32(address);
                     address += 4;
-                    this.cycles++;
+                    deltaCycles++;
                 }
             }
             // Write back
@@ -766,7 +766,7 @@ export class CortexM0Core {
             const Rn = (opcode >> 3) & 0x7;
             const Rt = opcode & 0x7;
             const addr = this.registers[Rn] + imm5;
-            this.cycles += this.cyclesIO(addr);
+            deltaCycles += this.cyclesIO(addr);
             this.registers[Rt] = this.readUint32(addr);
         }
         // LDR (sp + immediate)
@@ -774,7 +774,7 @@ export class CortexM0Core {
             const Rt = (opcode >> 8) & 0x7;
             const imm8 = opcode & 0xff;
             const addr = this.SP + (imm8 << 2);
-            this.cycles += this.cyclesIO(addr);
+            deltaCycles += this.cyclesIO(addr);
             this.registers[Rt] = this.readUint32(addr);
         }
         // LDR (literal)
@@ -783,7 +783,7 @@ export class CortexM0Core {
             const Rt = (opcode >> 8) & 7;
             const nextPC = this.PC + 2;
             const addr = (nextPC & 0xfffffffc) + imm8;
-            this.cycles += this.cyclesIO(addr);
+            deltaCycles += this.cyclesIO(addr);
             this.registers[Rt] = this.readUint32(addr);
         }
         // LDR (register)
@@ -792,7 +792,7 @@ export class CortexM0Core {
             const Rn = (opcode >> 3) & 0x7;
             const Rt = opcode & 0x7;
             const addr = this.registers[Rm] + this.registers[Rn];
-            this.cycles += this.cyclesIO(addr);
+            deltaCycles += this.cyclesIO(addr);
             this.registers[Rt] = this.readUint32(addr);
         }
         // LDRB (immediate)
@@ -801,7 +801,7 @@ export class CortexM0Core {
             const Rn = (opcode >> 3) & 0x7;
             const Rt = opcode & 0x7;
             const addr = this.registers[Rn] + imm5;
-            this.cycles += this.cyclesIO(addr);
+            deltaCycles += this.cyclesIO(addr);
             this.registers[Rt] = this.readUint8(addr);
         }
         // LDRB (register)
@@ -810,7 +810,7 @@ export class CortexM0Core {
             const Rn = (opcode >> 3) & 0x7;
             const Rt = opcode & 0x7;
             const addr = this.registers[Rm] + this.registers[Rn];
-            this.cycles += this.cyclesIO(addr);
+            deltaCycles += this.cyclesIO(addr);
             this.registers[Rt] = this.readUint8(addr);
         }
         // LDRH (immediate)
@@ -819,7 +819,7 @@ export class CortexM0Core {
             const Rn = (opcode >> 3) & 0x7;
             const Rt = opcode & 0x7;
             const addr = this.registers[Rn] + (imm5 << 1);
-            this.cycles += this.cyclesIO(addr);
+            deltaCycles += this.cyclesIO(addr);
             this.registers[Rt] = this.readUint16(addr);
         }
         // LDRH (register)
@@ -828,7 +828,7 @@ export class CortexM0Core {
             const Rn = (opcode >> 3) & 0x7;
             const Rt = opcode & 0x7;
             const addr = this.registers[Rm] + this.registers[Rn];
-            this.cycles += this.cyclesIO(addr);
+            deltaCycles += this.cyclesIO(addr);
             this.registers[Rt] = this.readUint16(addr);
         }
         // LDRSB
@@ -837,7 +837,7 @@ export class CortexM0Core {
             const Rn = (opcode >> 3) & 0x7;
             const Rt = opcode & 0x7;
             const addr = this.registers[Rm] + this.registers[Rn];
-            this.cycles += this.cyclesIO(addr);
+            deltaCycles += this.cyclesIO(addr);
             this.registers[Rt] = signExtend8(this.readUint8(addr));
         }
         // LDRSH
@@ -846,7 +846,7 @@ export class CortexM0Core {
             const Rn = (opcode >> 3) & 0x7;
             const Rt = opcode & 0x7;
             const addr = this.registers[Rm] + this.registers[Rn];
-            this.cycles += this.cyclesIO(addr);
+            deltaCycles += this.cyclesIO(addr);
             this.registers[Rt] = signExtend16(this.readUint16(addr));
         }
         // LSLS (immediate)
@@ -903,7 +903,7 @@ export class CortexM0Core {
             const Rd = ((opcode >> 4) & 0x8) | (opcode & 0x7);
             let value = Rm === pcRegister ? this.PC + 2 : this.registers[Rm];
             if (Rd === pcRegister) {
-                this.cycles++;
+                deltaCycles++;
                 value &= ~1;
             }
             else if (Rd === spRegister) {
@@ -925,7 +925,7 @@ export class CortexM0Core {
             const Rd = (opcode2 >> 8) & 0xf;
             this.registers[Rd] = this.readSpecialRegister(SYSm);
             this.PC += 2;
-            this.cycles += 2;
+            deltaCycles += 2;
         }
         // MSR
         else if (opcode >> 4 === 0b111100111000 && opcode2 >> 8 == 0b10001000) {
@@ -933,7 +933,7 @@ export class CortexM0Core {
             const Rn = opcode & 0xf;
             this.writeSpecialRegister(SYSm, this.registers[Rn]);
             this.PC += 2;
-            this.cycles += 2;
+            deltaCycles += 2;
         }
         // MULS
         else if (opcode >> 6 === 0b0100001101) {
@@ -970,13 +970,13 @@ export class CortexM0Core {
                 if (opcode & (1 << i)) {
                     this.registers[i] = this.readUint32(address);
                     address += 4;
-                    this.cycles++;
+                    deltaCycles++;
                 }
             }
             if (P) {
                 this.SP = address + 4;
                 this.BXWritePC(this.readUint32(address));
-                this.cycles += 2;
+                deltaCycles += 2;
             }
             else {
                 this.SP = address;
@@ -994,7 +994,7 @@ export class CortexM0Core {
             for (let i = 0; i <= 7; i++) {
                 if (opcode & (1 << i)) {
                     this.writeUint32(address, this.registers[i]);
-                    this.cycles++;
+                    deltaCycles++;
                     address += 4;
                 }
             }
@@ -1073,7 +1073,7 @@ export class CortexM0Core {
                 if (registers & (1 << i)) {
                     this.writeUint32(address, this.registers[i]);
                     address += 4;
-                    this.cycles++;
+                    deltaCycles++;
                 }
             }
             // Write back
@@ -1087,7 +1087,7 @@ export class CortexM0Core {
             const Rn = (opcode >> 3) & 0x7;
             const Rt = opcode & 0x7;
             const address = this.registers[Rn] + imm5;
-            this.cycles += this.cyclesIO(address, true);
+            deltaCycles += this.cyclesIO(address, true);
             this.writeUint32(address, this.registers[Rt]);
         }
         // STR (sp + immediate)
@@ -1095,7 +1095,7 @@ export class CortexM0Core {
             const Rt = (opcode >> 8) & 0x7;
             const imm8 = opcode & 0xff;
             const address = this.SP + (imm8 << 2);
-            this.cycles += this.cyclesIO(address, true);
+            deltaCycles += this.cyclesIO(address, true);
             this.writeUint32(address, this.registers[Rt]);
         }
         // STR (register)
@@ -1104,7 +1104,7 @@ export class CortexM0Core {
             const Rn = (opcode >> 3) & 0x7;
             const Rt = opcode & 0x7;
             const address = this.registers[Rm] + this.registers[Rn];
-            this.cycles += this.cyclesIO(address, true);
+            deltaCycles += this.cyclesIO(address, true);
             this.writeUint32(address, this.registers[Rt]);
         }
         // STRB (immediate)
@@ -1113,7 +1113,7 @@ export class CortexM0Core {
             const Rn = (opcode >> 3) & 0x7;
             const Rt = opcode & 0x7;
             const address = this.registers[Rn] + imm5;
-            this.cycles += this.cyclesIO(address, true);
+            deltaCycles += this.cyclesIO(address, true);
             this.writeUint8(address, this.registers[Rt]);
         }
         // STRB (register)
@@ -1122,7 +1122,7 @@ export class CortexM0Core {
             const Rn = (opcode >> 3) & 0x7;
             const Rt = opcode & 0x7;
             const address = this.registers[Rm] + this.registers[Rn];
-            this.cycles += this.cyclesIO(address, true);
+            deltaCycles += this.cyclesIO(address, true);
             this.writeUint8(address, this.registers[Rt]);
         }
         // STRH (immediate)
@@ -1131,7 +1131,7 @@ export class CortexM0Core {
             const Rn = (opcode >> 3) & 0x7;
             const Rt = opcode & 0x7;
             const address = this.registers[Rn] + imm5;
-            this.cycles += this.cyclesIO(address, true);
+            deltaCycles += this.cyclesIO(address, true);
             this.writeUint16(address, this.registers[Rt]);
         }
         // STRH (register)
@@ -1140,7 +1140,7 @@ export class CortexM0Core {
             const Rn = (opcode >> 3) & 0x7;
             const Rt = opcode & 0x7;
             const address = this.registers[Rm] + this.registers[Rn];
-            this.cycles += this.cyclesIO(address, true);
+            deltaCycles += this.cyclesIO(address, true);
             this.writeUint16(address, this.registers[Rt]);
         }
         // SUB (SP minus immediate)
@@ -1221,7 +1221,7 @@ export class CortexM0Core {
         }
         // WFE
         else if (opcode === 0b1011111100100000) {
-            this.cycles++;
+            deltaCycles++;
             if (this.eventRegistered) {
                 this.eventRegistered = false;
             }
@@ -1231,7 +1231,7 @@ export class CortexM0Core {
         }
         // WFI
         else if (opcode === 0b1011111100110000) {
-            this.cycles++;
+            deltaCycles++;
             this.waiting = true;
         }
         // YIELD
@@ -1243,5 +1243,7 @@ export class CortexM0Core {
             this.logger.warn(LOG_NAME, `Warning: Instruction at ${opcodePC.toString(16)} is not implemented yet!`);
             this.logger.warn(LOG_NAME, `Opcode: 0x${opcode.toString(16)} (0x${opcode2.toString(16)})`);
         }
+        this.cycles += deltaCycles;
+        return deltaCycles;
     }
 }

package/dist/esm/gdb/gdb-connection.d.ts

@@ -3,7 +3,7 @@ export type GDBResponseHandler = (value: string) => void;
 export declare class GDBConnection {
     private server;
     private onResponse;
-    readonly rp2040: import("../rp2040.js").RP2040;
+    readonly target: import("./gdb-target.js").IGDBTarget;
     private buf;
     constructor(server: GDBServer, onResponse: GDBResponseHandler);
     feedData(data: string): void;