rp2040js 0.18.1 → 0.19.0

package/dist/cjs/peripherals/ssi.js

@@ -9,6 +9,9 @@ const SSI_DR0 = 0x00000060;
 const SSI_SR_TFNF_BITS = 0x00000002;
 const SSI_SR_TFE_BITS = 0x00000004;
 const SSI_SR_RFNE_BITS = 0x00000008;
+/** Identification register */
+const SSI_IDR = 0x00000058;
+const SSI_VERSION_ID = 0x0000005c;
 const CMD_READ_STATUS = 0x05;
 class RPSSI extends peripheral_js_1.BasePeripheral {
     constructor() {
@@ -23,6 +26,10 @@ class RPSSI extends peripheral_js_1.BasePeripheral {
                 return 0;
             case SSI_SR:
                 return SSI_SR_TFE_BITS | SSI_SR_RFNE_BITS | SSI_SR_TFNF_BITS;
+            case SSI_IDR:
+                return 0x51535049;
+            case SSI_VERSION_ID:
+                return 0x3430312a;
             case SSI_DR0:
                 return this.dr0;
         }

package/dist/cjs/peripherals/uart.d.ts

@@ -13,7 +13,10 @@ export declare class RPUART extends BasePeripheral implements Peripheral {
     private rxFIFO;
     private interruptMask;
     private interruptStatus;
+    private intDivisor;
+    private fracDivisor;
     onByte?: (value: number) => void;
+    onBaudRateChange?: (baudRate: number) => void;
     constructor(rp2040: RP2040, name: string, irq: number, dreq: IUARTDMAChannels);
     get enabled(): boolean;
     get txEnabled(): boolean;
@@ -23,6 +26,8 @@ export declare class RPUART extends BasePeripheral implements Peripheral {
      * Number of bits per UART character
      */
     get wordLength(): 5 | 6 | 7 | 8 | undefined;
+    get baudDivider(): number;
+    get baudRate(): number;
     get flags(): number;
     checkInterrupts(): void;
     feedByte(value: number): void;

package/dist/cjs/peripherals/uart.js

@@ -5,12 +5,22 @@ const fifo_js_1 = require("../utils/fifo.js");
 const peripheral_js_1 = require("./peripheral.js");
 const UARTDR = 0x0;
 const UARTFR = 0x18;
+const UARTIBRD = 0x24;
+const UARTFBRD = 0x28;
 const UARTLCR_H = 0x2c;
 const UARTCR = 0x30;
 const UARTIMSC = 0x38;
 const UARTIRIS = 0x3c;
 const UARTIMIS = 0x40;
 const UARTICR = 0x44;
+const UARTPERIPHID0 = 0xfe0;
+const UARTPERIPHID1 = 0xfe4;
+const UARTPERIPHID2 = 0xfe8;
+const UARTPERIPHID3 = 0xfec;
+const UARTPCELLID0 = 0xff0;
+const UARTPCELLID1 = 0xff4;
+const UARTPCELLID2 = 0xff8;
+const UARTPCELLID3 = 0xffc;
 // UARTFR bits:
 const TXFE = 1 << 7;
 const RXFF = 1 << 6;
@@ -33,6 +43,8 @@ class RPUART extends peripheral_js_1.BasePeripheral {
         this.rxFIFO = new fifo_js_1.FIFO(32);
         this.interruptMask = 0;
         this.interruptStatus = 0;
+        this.intDivisor = 0;
+        this.fracDivisor = 0;
     }
     get enabled() {
         return !!(this.ctrlRegister & UARTEN);
@@ -61,6 +73,12 @@ class RPUART extends peripheral_js_1.BasePeripheral {
                 return 8;
         }
     }
+    get baudDivider() {
+        return this.intDivisor + this.fracDivisor / 64;
+    }
+    get baudRate() {
+        return Math.round(this.rp2040.clkPeri / (this.baudDivider * 16));
+    }
     get flags() {
         return (this.rxFIFO.full ? RXFF : 0) | (this.rxFIFO.empty ? RXFE : 0) | TXFE;
     }
@@ -85,6 +103,10 @@ class RPUART extends peripheral_js_1.BasePeripheral {
             }
             case UARTFR:
                 return this.flags;
+            case UARTIBRD:
+                return this.intDivisor;
+            case UARTFBRD:
+                return this.fracDivisor;
             case UARTLCR_H:
                 return this.lineCtrlRegister;
             case UARTCR:
@@ -95,15 +117,39 @@ class RPUART extends peripheral_js_1.BasePeripheral {
                 return this.interruptStatus;
             case UARTIMIS:
                 return this.interruptStatus & this.interruptMask;
+            case UARTPERIPHID0:
+                return 0x11;
+            case UARTPERIPHID1:
+                return 0x10;
+            case UARTPERIPHID2:
+                return 0x34;
+            case UARTPERIPHID3:
+                return 0x00;
+            case UARTPCELLID0:
+                return 0x0d;
+            case UARTPCELLID1:
+                return 0xf0;
+            case UARTPCELLID2:
+                return 0x05;
+            case UARTPCELLID3:
+                return 0xb1;
         }
         return super.readUint32(offset);
     }
     writeUint32(offset, value) {
-        var _a;
+        var _a, _b, _c;
         switch (offset) {
             case UARTDR:
                 (_a = this.onByte) === null || _a === void 0 ? void 0 : _a.call(this, value & 0xff);
                 break;
+            case UARTIBRD:
+                this.intDivisor = value & 0xffff;
+                (_b = this.onBaudRateChange) === null || _b === void 0 ? void 0 : _b.call(this, this.baudRate);
+                break;
+            case UARTFBRD:
+                this.fracDivisor = value & 0x3f;
+                (_c = this.onBaudRateChange) === null || _c === void 0 ? void 0 : _c.call(this, this.baudRate);
+                break;
             case UARTLCR_H:
                 this.lineCtrlRegister = value;
                 break;

package/dist/cjs/peripherals/watchdog.d.ts

@@ -0,0 +1,19 @@
+import { RP2040 } from '../rp2040.js';
+import { Timer32, Timer32PeriodicAlarm } from '../utils/timer32.js';
+import { BasePeripheral, Peripheral } from './peripheral.js';
+export declare class RPWatchdog extends BasePeripheral implements Peripheral {
+    readonly timer: Timer32;
+    readonly alarm: Timer32PeriodicAlarm;
+    readonly scratchData: Uint32Array;
+    private enable;
+    private tickEnable;
+    private reason;
+    private pauseDbg0;
+    private pauseDbg1;
+    private pauseJtag;
+    /** Called when the watchdog triggers - override with your own soft reset implementation */
+    onWatchdogTrigger: () => void;
+    constructor(rp2040: RP2040, name: string);
+    readUint32(offset: number): number;
+    writeUint32(offset: number, value: number): void;
+}

package/dist/cjs/peripherals/watchdog.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RPWatchdog = void 0;
+const timer32_js_1 = require("../utils/timer32.js");
+const peripheral_js_1 = require("./peripheral.js");
+const CTRL = 0x00; // Control register
+const LOAD = 0x04; // Load the watchdog timer.
+const REASON = 0x08; // Logs the reason for the last reset.
+const SCRATCH0 = 0x0c; // Scratch register
+const SCRATCH1 = 0x10; // Scratch register
+const SCRATCH2 = 0x14; // Scratch register
+const SCRATCH3 = 0x18; // Scratch register
+const SCRATCH4 = 0x1c; // Scratch register
+const SCRATCH5 = 0x20; // Scratch register
+const SCRATCH6 = 0x24; // Scratch register
+const SCRATCH7 = 0x28; // Scratch register
+const TICK = 0x2c; // Controls the tick generator
+// CTRL bits:
+const TRIGGER = 1 << 31;
+const ENABLE = 1 << 30;
+const PAUSE_DBG1 = 1 << 26;
+const PAUSE_DBG0 = 1 << 25;
+const PAUSE_JTAG = 1 << 24;
+const TIME_MASK = 0xffffff;
+const TIME_SHIFT = 0;
+// LOAD bits
+const LOAD_MASK = 0xffffff;
+const LOAD_SHIFT = 0;
+// REASON bits:
+const FORCE = 1 << 1;
+const TIMER = 1 << 0;
+// TICK bits:
+const COUNT_MASK = 0x1ff;
+const COUNT_SHIFT = 11;
+const RUNNING = 1 << 10;
+const TICK_ENABLE = 1 << 9;
+const CYCLES_MASK = 0x1ff;
+const CYCLES_SHIFT = 0;
+const TICK_FREQUENCY = 2000000; // Actually 1 MHz, but due to errata RP2040-E1, the timer is decremented twice per tick
+class RPWatchdog extends peripheral_js_1.BasePeripheral {
+    // User provided
+    constructor(rp2040, name) {
+        super(rp2040, name);
+        this.scratchData = new Uint32Array(8);
+        this.enable = false;
+        this.tickEnable = true;
+        this.reason = 0;
+        this.pauseDbg0 = true;
+        this.pauseDbg1 = true;
+        this.pauseJtag = true;
+        /** Called when the watchdog triggers - override with your own soft reset implementation */
+        this.onWatchdogTrigger = () => {
+            this.rp2040.logger.warn(this.name, 'Watchdog triggered, but no reset handler provided');
+        };
+        this.timer = new timer32_js_1.Timer32(rp2040.clock, TICK_FREQUENCY);
+        this.timer.mode = timer32_js_1.TimerMode.Decrement;
+        this.timer.enable = false;
+        this.alarm = new timer32_js_1.Timer32PeriodicAlarm(this.timer, () => {
+            var _a;
+            this.reason = TIMER;
+            (_a = this.onWatchdogTrigger) === null || _a === void 0 ? void 0 : _a.call(this);
+        });
+        this.alarm.target = 0;
+        this.alarm.enable = false;
+    }
+    readUint32(offset) {
+        switch (offset) {
+            case CTRL:
+                return ((this.timer.enable ? ENABLE : 0) |
+                    (this.pauseDbg0 ? PAUSE_DBG0 : 0) |
+                    (this.pauseDbg1 ? PAUSE_DBG1 : 0) |
+                    (this.pauseJtag ? PAUSE_JTAG : 0) |
+                    ((this.timer.counter & TIME_MASK) << TIME_SHIFT));
+            case REASON:
+                return this.reason;
+            case SCRATCH0:
+            case SCRATCH1:
+            case SCRATCH2:
+            case SCRATCH3:
+            case SCRATCH4:
+            case SCRATCH5:
+            case SCRATCH6:
+            case SCRATCH7:
+                return this.scratchData[(offset - SCRATCH0) >> 2];
+            case TICK:
+                // TODO COUNT bits
+                return this.tickEnable ? RUNNING | TICK_ENABLE : 0;
+        }
+        return super.readUint32(offset);
+    }
+    writeUint32(offset, value) {
+        var _a;
+        switch (offset) {
+            case CTRL:
+                if (value & TRIGGER) {
+                    this.reason = FORCE;
+                    (_a = this.onWatchdogTrigger) === null || _a === void 0 ? void 0 : _a.call(this);
+                }
+                this.enable = !!(value & ENABLE);
+                this.timer.enable = this.enable && this.tickEnable;
+                this.alarm.enable = this.enable && this.tickEnable;
+                this.pauseDbg0 = !!(value & PAUSE_DBG0);
+                this.pauseDbg1 = !!(value & PAUSE_DBG1);
+                this.pauseJtag = !!(value & PAUSE_JTAG);
+                break;
+            case LOAD:
+                this.timer.set((value >>> LOAD_SHIFT) & LOAD_MASK);
+                break;
+            case SCRATCH0:
+            case SCRATCH1:
+            case SCRATCH2:
+            case SCRATCH3:
+            case SCRATCH4:
+            case SCRATCH5:
+            case SCRATCH6:
+            case SCRATCH7:
+                this.scratchData[(offset - SCRATCH0) >> 2] = value;
+                break;
+            case TICK:
+                this.tickEnable = !!(value & TICK_ENABLE);
+                this.timer.enable = this.enable && this.tickEnable;
+                this.alarm.enable = this.enable && this.tickEnable;
+                // TODO - handle CYCLES (tick also affectes timer)
+                break;
+            default:
+                super.writeUint32(offset, value);
+        }
+    }
+}
+exports.RPWatchdog = RPWatchdog;

package/dist/cjs/rp2040.js

@@ -26,6 +26,7 @@ const tbman_js_1 = require("./peripherals/tbman.js");
 const timer_js_1 = require("./peripherals/timer.js");
 const uart_js_1 = require("./peripherals/uart.js");
 const usb_js_1 = require("./peripherals/usb.js");
+const watchdog_js_1 = require("./peripherals/watchdog.js");
 const sio_js_1 = require("./sio.js");
 const logging_js_1 = require("./utils/logging.js");
 exports.FLASH_START_ADDRESS = 0x10000000;
@@ -150,7 +151,7 @@ class RP2040 {
             0x4004c: this.adc,
             0x40050: this.pwm,
             0x40054: new timer_js_1.RPTimer(this, 'TIMER_BASE'),
-            0x40058: new peripheral_js_1.UnimplementedPeripheral(this, 'WATCHDOG_BASE'),
+            0x40058: new watchdog_js_1.RPWatchdog(this, 'WATCHDOG_BASE'),
             0x4005c: new rtc_js_1.RP2040RTC(this, 'RTC_BASE'),
             0x40060: new peripheral_js_1.UnimplementedPeripheral(this, 'ROSC_BASE'),
             0x40064: new peripheral_js_1.UnimplementedPeripheral(this, 'VREG_AND_CHIP_RESET_BASE'),

package/dist/esm/peripherals/ssi.js

@@ -6,6 +6,9 @@ const SSI_DR0 = 0x00000060;
 const SSI_SR_TFNF_BITS = 0x00000002;
 const SSI_SR_TFE_BITS = 0x00000004;
 const SSI_SR_RFNE_BITS = 0x00000008;
+/** Identification register */
+const SSI_IDR = 0x00000058;
+const SSI_VERSION_ID = 0x0000005c;
 const CMD_READ_STATUS = 0x05;
 export class RPSSI extends BasePeripheral {
     constructor() {
@@ -20,6 +23,10 @@ export class RPSSI extends BasePeripheral {
                 return 0;
             case SSI_SR:
                 return SSI_SR_TFE_BITS | SSI_SR_RFNE_BITS | SSI_SR_TFNF_BITS;
+            case SSI_IDR:
+                return 0x51535049;
+            case SSI_VERSION_ID:
+                return 0x3430312a;
             case SSI_DR0:
                 return this.dr0;
         }

package/dist/esm/peripherals/uart.d.ts

@@ -13,7 +13,10 @@ export declare class RPUART extends BasePeripheral implements Peripheral {
     private rxFIFO;
     private interruptMask;
     private interruptStatus;
+    private intDivisor;
+    private fracDivisor;
     onByte?: (value: number) => void;
+    onBaudRateChange?: (baudRate: number) => void;
     constructor(rp2040: RP2040, name: string, irq: number, dreq: IUARTDMAChannels);
     get enabled(): boolean;
     get txEnabled(): boolean;
@@ -23,6 +26,8 @@ export declare class RPUART extends BasePeripheral implements Peripheral {
      * Number of bits per UART character
      */
     get wordLength(): 5 | 6 | 7 | 8 | undefined;
+    get baudDivider(): number;
+    get baudRate(): number;
     get flags(): number;
     checkInterrupts(): void;
     feedByte(value: number): void;

package/dist/esm/peripherals/uart.js

@@ -2,12 +2,22 @@ import { FIFO } from '../utils/fifo.js';
 import { BasePeripheral } from './peripheral.js';
 const UARTDR = 0x0;
 const UARTFR = 0x18;
+const UARTIBRD = 0x24;
+const UARTFBRD = 0x28;
 const UARTLCR_H = 0x2c;
 const UARTCR = 0x30;
 const UARTIMSC = 0x38;
 const UARTIRIS = 0x3c;
 const UARTIMIS = 0x40;
 const UARTICR = 0x44;
+const UARTPERIPHID0 = 0xfe0;
+const UARTPERIPHID1 = 0xfe4;
+const UARTPERIPHID2 = 0xfe8;
+const UARTPERIPHID3 = 0xfec;
+const UARTPCELLID0 = 0xff0;
+const UARTPCELLID1 = 0xff4;
+const UARTPCELLID2 = 0xff8;
+const UARTPCELLID3 = 0xffc;
 // UARTFR bits:
 const TXFE = 1 << 7;
 const RXFF = 1 << 6;
@@ -30,6 +40,8 @@ export class RPUART extends BasePeripheral {
         this.rxFIFO = new FIFO(32);
         this.interruptMask = 0;
         this.interruptStatus = 0;
+        this.intDivisor = 0;
+        this.fracDivisor = 0;
     }
     get enabled() {
         return !!(this.ctrlRegister & UARTEN);
@@ -58,6 +70,12 @@ export class RPUART extends BasePeripheral {
                 return 8;
         }
     }
+    get baudDivider() {
+        return this.intDivisor + this.fracDivisor / 64;
+    }
+    get baudRate() {
+        return Math.round(this.rp2040.clkPeri / (this.baudDivider * 16));
+    }
     get flags() {
         return (this.rxFIFO.full ? RXFF : 0) | (this.rxFIFO.empty ? RXFE : 0) | TXFE;
     }
@@ -82,6 +100,10 @@ export class RPUART extends BasePeripheral {
             }
             case UARTFR:
                 return this.flags;
+            case UARTIBRD:
+                return this.intDivisor;
+            case UARTFBRD:
+                return this.fracDivisor;
             case UARTLCR_H:
                 return this.lineCtrlRegister;
             case UARTCR:
@@ -92,15 +114,39 @@ export class RPUART extends BasePeripheral {
                 return this.interruptStatus;
             case UARTIMIS:
                 return this.interruptStatus & this.interruptMask;
+            case UARTPERIPHID0:
+                return 0x11;
+            case UARTPERIPHID1:
+                return 0x10;
+            case UARTPERIPHID2:
+                return 0x34;
+            case UARTPERIPHID3:
+                return 0x00;
+            case UARTPCELLID0:
+                return 0x0d;
+            case UARTPCELLID1:
+                return 0xf0;
+            case UARTPCELLID2:
+                return 0x05;
+            case UARTPCELLID3:
+                return 0xb1;
         }
         return super.readUint32(offset);
     }
     writeUint32(offset, value) {
-        var _a;
+        var _a, _b, _c;
         switch (offset) {
             case UARTDR:
                 (_a = this.onByte) === null || _a === void 0 ? void 0 : _a.call(this, value & 0xff);
                 break;
+            case UARTIBRD:
+                this.intDivisor = value & 0xffff;
+                (_b = this.onBaudRateChange) === null || _b === void 0 ? void 0 : _b.call(this, this.baudRate);
+                break;
+            case UARTFBRD:
+                this.fracDivisor = value & 0x3f;
+                (_c = this.onBaudRateChange) === null || _c === void 0 ? void 0 : _c.call(this, this.baudRate);
+                break;
             case UARTLCR_H:
                 this.lineCtrlRegister = value;
                 break;

package/dist/esm/peripherals/watchdog.d.ts

@@ -0,0 +1,19 @@
+import { RP2040 } from '../rp2040.js';
+import { Timer32, Timer32PeriodicAlarm } from '../utils/timer32.js';
+import { BasePeripheral, Peripheral } from './peripheral.js';
+export declare class RPWatchdog extends BasePeripheral implements Peripheral {
+    readonly timer: Timer32;
+    readonly alarm: Timer32PeriodicAlarm;
+    readonly scratchData: Uint32Array;
+    private enable;
+    private tickEnable;
+    private reason;
+    private pauseDbg0;
+    private pauseDbg1;
+    private pauseJtag;
+    /** Called when the watchdog triggers - override with your own soft reset implementation */
+    onWatchdogTrigger: () => void;
+    constructor(rp2040: RP2040, name: string);
+    readUint32(offset: number): number;
+    writeUint32(offset: number, value: number): void;
+}

package/dist/esm/peripherals/watchdog.js

@@ -0,0 +1,126 @@
+import { Timer32, Timer32PeriodicAlarm, TimerMode } from '../utils/timer32.js';
+import { BasePeripheral } from './peripheral.js';
+const CTRL = 0x00; // Control register
+const LOAD = 0x04; // Load the watchdog timer.
+const REASON = 0x08; // Logs the reason for the last reset.
+const SCRATCH0 = 0x0c; // Scratch register
+const SCRATCH1 = 0x10; // Scratch register
+const SCRATCH2 = 0x14; // Scratch register
+const SCRATCH3 = 0x18; // Scratch register
+const SCRATCH4 = 0x1c; // Scratch register
+const SCRATCH5 = 0x20; // Scratch register
+const SCRATCH6 = 0x24; // Scratch register
+const SCRATCH7 = 0x28; // Scratch register
+const TICK = 0x2c; // Controls the tick generator
+// CTRL bits:
+const TRIGGER = 1 << 31;
+const ENABLE = 1 << 30;
+const PAUSE_DBG1 = 1 << 26;
+const PAUSE_DBG0 = 1 << 25;
+const PAUSE_JTAG = 1 << 24;
+const TIME_MASK = 0xffffff;
+const TIME_SHIFT = 0;
+// LOAD bits
+const LOAD_MASK = 0xffffff;
+const LOAD_SHIFT = 0;
+// REASON bits:
+const FORCE = 1 << 1;
+const TIMER = 1 << 0;
+// TICK bits:
+const COUNT_MASK = 0x1ff;
+const COUNT_SHIFT = 11;
+const RUNNING = 1 << 10;
+const TICK_ENABLE = 1 << 9;
+const CYCLES_MASK = 0x1ff;
+const CYCLES_SHIFT = 0;
+const TICK_FREQUENCY = 2000000; // Actually 1 MHz, but due to errata RP2040-E1, the timer is decremented twice per tick
+export class RPWatchdog extends BasePeripheral {
+    // User provided
+    constructor(rp2040, name) {
+        super(rp2040, name);
+        this.scratchData = new Uint32Array(8);
+        this.enable = false;
+        this.tickEnable = true;
+        this.reason = 0;
+        this.pauseDbg0 = true;
+        this.pauseDbg1 = true;
+        this.pauseJtag = true;
+        /** Called when the watchdog triggers - override with your own soft reset implementation */
+        this.onWatchdogTrigger = () => {
+            this.rp2040.logger.warn(this.name, 'Watchdog triggered, but no reset handler provided');
+        };
+        this.timer = new Timer32(rp2040.clock, TICK_FREQUENCY);
+        this.timer.mode = TimerMode.Decrement;
+        this.timer.enable = false;
+        this.alarm = new Timer32PeriodicAlarm(this.timer, () => {
+            var _a;
+            this.reason = TIMER;
+            (_a = this.onWatchdogTrigger) === null || _a === void 0 ? void 0 : _a.call(this);
+        });
+        this.alarm.target = 0;
+        this.alarm.enable = false;
+    }
+    readUint32(offset) {
+        switch (offset) {
+            case CTRL:
+                return ((this.timer.enable ? ENABLE : 0) |
+                    (this.pauseDbg0 ? PAUSE_DBG0 : 0) |
+                    (this.pauseDbg1 ? PAUSE_DBG1 : 0) |
+                    (this.pauseJtag ? PAUSE_JTAG : 0) |
+                    ((this.timer.counter & TIME_MASK) << TIME_SHIFT));
+            case REASON:
+                return this.reason;
+            case SCRATCH0:
+            case SCRATCH1:
+            case SCRATCH2:
+            case SCRATCH3:
+            case SCRATCH4:
+            case SCRATCH5:
+            case SCRATCH6:
+            case SCRATCH7:
+                return this.scratchData[(offset - SCRATCH0) >> 2];
+            case TICK:
+                // TODO COUNT bits
+                return this.tickEnable ? RUNNING | TICK_ENABLE : 0;
+        }
+        return super.readUint32(offset);
+    }
+    writeUint32(offset, value) {
+        var _a;
+        switch (offset) {
+            case CTRL:
+                if (value & TRIGGER) {
+                    this.reason = FORCE;
+                    (_a = this.onWatchdogTrigger) === null || _a === void 0 ? void 0 : _a.call(this);
+                }
+                this.enable = !!(value & ENABLE);
+                this.timer.enable = this.enable && this.tickEnable;
+                this.alarm.enable = this.enable && this.tickEnable;
+                this.pauseDbg0 = !!(value & PAUSE_DBG0);
+                this.pauseDbg1 = !!(value & PAUSE_DBG1);
+                this.pauseJtag = !!(value & PAUSE_JTAG);
+                break;
+            case LOAD:
+                this.timer.set((value >>> LOAD_SHIFT) & LOAD_MASK);
+                break;
+            case SCRATCH0:
+            case SCRATCH1:
+            case SCRATCH2:
+            case SCRATCH3:
+            case SCRATCH4:
+            case SCRATCH5:
+            case SCRATCH6:
+            case SCRATCH7:
+                this.scratchData[(offset - SCRATCH0) >> 2] = value;
+                break;
+            case TICK:
+                this.tickEnable = !!(value & TICK_ENABLE);
+                this.timer.enable = this.enable && this.tickEnable;
+                this.alarm.enable = this.enable && this.tickEnable;
+                // TODO - handle CYCLES (tick also affectes timer)
+                break;
+            default:
+                super.writeUint32(offset, value);
+        }
+    }
+}

package/dist/esm/rp2040.js

@@ -23,6 +23,7 @@ import { RPTBMAN } from './peripherals/tbman.js';
 import { RPTimer } from './peripherals/timer.js';
 import { RPUART } from './peripherals/uart.js';
 import { RPUSBController } from './peripherals/usb.js';
+import { RPWatchdog } from './peripherals/watchdog.js';
 import { RPSIO } from './sio.js';
 import { ConsoleLogger, LogLevel } from './utils/logging.js';
 export const FLASH_START_ADDRESS = 0x10000000;
@@ -147,7 +148,7 @@ export class RP2040 {
             0x4004c: this.adc,
             0x40050: this.pwm,
             0x40054: new RPTimer(this, 'TIMER_BASE'),
-            0x40058: new UnimplementedPeripheral(this, 'WATCHDOG_BASE'),
+            0x40058: new RPWatchdog(this, 'WATCHDOG_BASE'),
             0x4005c: new RP2040RTC(this, 'RTC_BASE'),
             0x40060: new UnimplementedPeripheral(this, 'ROSC_BASE'),
             0x40064: new UnimplementedPeripheral(this, 'VREG_AND_CHIP_RESET_BASE'),

package/package.json

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