rp2040js 0.17.16 → 0.18.0

package/dist/cjs/peripherals/sysinfo.js

@@ -1,22 +1,22 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RP2040SysInfo = void 0;
-const peripheral_1 = require("./peripheral");
-const CHIP_ID = 0;
-const PLATFORM = 0x4;
-const GITREF_RP2040 = 0x40;
-class RP2040SysInfo extends peripheral_1.BasePeripheral {
-    readUint32(offset) {
-        // All the values here were verified against the silicon
-        switch (offset) {
-            case CHIP_ID:
-                return 0x10002927;
-            case PLATFORM:
-                return 0x00000002;
-            case GITREF_RP2040:
-                return 0xe0c912e8;
-        }
-        return super.readUint32(offset);
-    }
-}
-exports.RP2040SysInfo = RP2040SysInfo;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RP2040SysInfo = void 0;
+const peripheral_js_1 = require("./peripheral.js");
+const CHIP_ID = 0;
+const PLATFORM = 0x4;
+const GITREF_RP2040 = 0x40;
+class RP2040SysInfo extends peripheral_js_1.BasePeripheral {
+    readUint32(offset) {
+        // All the values here were verified against the silicon
+        switch (offset) {
+            case CHIP_ID:
+                return 0x10002927;
+            case PLATFORM:
+                return 0x00000002;
+            case GITREF_RP2040:
+                return 0xe0c912e8;
+        }
+        return super.readUint32(offset);
+    }
+}
+exports.RP2040SysInfo = RP2040SysInfo;

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

@@ -1,4 +1,4 @@
-import { BasePeripheral, Peripheral } from './peripheral';
-export declare class RPTBMAN extends BasePeripheral implements Peripheral {
-    readUint32(offset: number): number;
-}
+import { BasePeripheral, Peripheral } from './peripheral.js';
+export declare class RPTBMAN extends BasePeripheral implements Peripheral {
+    readUint32(offset: number): number;
+}

package/dist/cjs/peripherals/tbman.js

@@ -1,17 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RPTBMAN = void 0;
-const peripheral_1 = require("./peripheral");
-const PLATFORM = 0;
-const ASIC = 1;
-class RPTBMAN extends peripheral_1.BasePeripheral {
-    readUint32(offset) {
-        switch (offset) {
-            case PLATFORM:
-                return ASIC;
-            default:
-                return super.readUint32(offset);
-        }
-    }
-}
-exports.RPTBMAN = RPTBMAN;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RPTBMAN = void 0;
+const peripheral_js_1 = require("./peripheral.js");
+const PLATFORM = 0;
+const ASIC = 1;
+class RPTBMAN extends peripheral_js_1.BasePeripheral {
+    readUint32(offset) {
+        switch (offset) {
+            case PLATFORM:
+                return ASIC;
+            default:
+                return super.readUint32(offset);
+        }
+    }
+}
+exports.RPTBMAN = RPTBMAN;

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

@@ -1,18 +1,18 @@
-import { RP2040 } from '../rp2040';
-import { BasePeripheral, Peripheral } from './peripheral';
-export declare class RPTimer extends BasePeripheral implements Peripheral {
-    private readonly clock;
-    private latchedTimeHigh;
-    private readonly alarms;
-    private intRaw;
-    private intEnable;
-    private intForce;
-    private paused;
-    constructor(rp2040: RP2040, name: string);
-    get intStatus(): number;
-    readUint32(offset: number): number;
-    writeUint32(offset: number, value: number): void;
-    private fireAlarm;
-    private checkInterrupts;
-    private disarmAlarm;
-}
+import { RP2040 } from '../rp2040.js';
+import { BasePeripheral, Peripheral } from './peripheral.js';
+export declare class RPTimer extends BasePeripheral implements Peripheral {
+    private readonly clock;
+    private latchedTimeHigh;
+    private readonly alarms;
+    private intRaw;
+    private intEnable;
+    private intForce;
+    private paused;
+    constructor(rp2040: RP2040, name: string);
+    get intStatus(): number;
+    readUint32(offset: number): number;
+    writeUint32(offset: number, value: number): void;
+    private fireAlarm;
+    private checkInterrupts;
+    private disarmAlarm;
+}

package/dist/cjs/peripherals/timer.js

@@ -1,156 +1,156 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RPTimer = void 0;
-const irq_1 = require("../irq");
-const peripheral_1 = require("./peripheral");
-const TIMEHR = 0x08;
-const TIMELR = 0x0c;
-const TIMERAWH = 0x24;
-const TIMERAWL = 0x28;
-const ALARM0 = 0x10;
-const ALARM1 = 0x14;
-const ALARM2 = 0x18;
-const ALARM3 = 0x1c;
-const ARMED = 0x20;
-const PAUSE = 0x30;
-const INTR = 0x34;
-const INTE = 0x38;
-const INTF = 0x3c;
-const INTS = 0x40;
-const ALARM_0 = 1 << 0;
-const ALARM_1 = 1 << 1;
-const ALARM_2 = 1 << 2;
-const ALARM_3 = 1 << 3;
-const timerInterrupts = [irq_1.IRQ.TIMER_0, irq_1.IRQ.TIMER_1, irq_1.IRQ.TIMER_2, irq_1.IRQ.TIMER_3];
-class RPTimerAlarm {
-    constructor(name, bitValue) {
-        this.name = name;
-        this.bitValue = bitValue;
-        this.armed = false;
-        this.targetMicros = 0;
-        this.timer = null;
-    }
-}
-class RPTimer extends peripheral_1.BasePeripheral {
-    constructor(rp2040, name) {
-        super(rp2040, name);
-        this.latchedTimeHigh = 0;
-        this.alarms = [
-            new RPTimerAlarm('Alarm 0', ALARM_0),
-            new RPTimerAlarm('Alarm 1', ALARM_1),
-            new RPTimerAlarm('Alarm 2', ALARM_2),
-            new RPTimerAlarm('Alarm 3', ALARM_3),
-        ];
-        this.intRaw = 0;
-        this.intEnable = 0;
-        this.intForce = 0;
-        this.paused = false;
-        this.clock = rp2040.clock;
-    }
-    get intStatus() {
-        return (this.intRaw & this.intEnable) | this.intForce;
-    }
-    readUint32(offset) {
-        const time = this.clock.micros;
-        switch (offset) {
-            case TIMEHR:
-                return this.latchedTimeHigh;
-            case TIMELR:
-                this.latchedTimeHigh = Math.floor(time / Math.pow(2, 32));
-                return time >>> 0;
-            case TIMERAWH:
-                return Math.floor(time / Math.pow(2, 32));
-            case TIMERAWL:
-                return time >>> 0;
-            case ALARM0:
-                return this.alarms[0].targetMicros;
-            case ALARM1:
-                return this.alarms[1].targetMicros;
-            case ALARM2:
-                return this.alarms[2].targetMicros;
-            case ALARM3:
-                return this.alarms[3].targetMicros;
-            case PAUSE:
-                return this.paused ? 1 : 0;
-            case INTR:
-                return this.intRaw;
-            case INTE:
-                return this.intEnable;
-            case INTF:
-                return this.intForce;
-            case INTS:
-                return this.intStatus;
-            case ARMED:
-                return ((this.alarms[0].armed ? this.alarms[0].bitValue : 0) |
-                    (this.alarms[1].armed ? this.alarms[1].bitValue : 0) |
-                    (this.alarms[2].armed ? this.alarms[2].bitValue : 0) |
-                    (this.alarms[3].armed ? this.alarms[3].bitValue : 0));
-        }
-        return super.readUint32(offset);
-    }
-    writeUint32(offset, value) {
-        switch (offset) {
-            case ALARM0:
-            case ALARM1:
-            case ALARM2:
-            case ALARM3: {
-                const alarmIndex = (offset - ALARM0) / 4;
-                const alarm = this.alarms[alarmIndex];
-                const delta = (value - this.clock.micros) >>> 0;
-                this.disarmAlarm(alarm);
-                alarm.armed = true;
-                alarm.targetMicros = value;
-                alarm.timer = this.clock.createTimer(delta, () => this.fireAlarm(alarmIndex));
-                break;
-            }
-            case ARMED:
-                for (const alarm of this.alarms) {
-                    if (this.rawWriteValue & alarm.bitValue) {
-                        this.disarmAlarm(alarm);
-                    }
-                }
-                break;
-            case PAUSE:
-                this.paused = !!(value & 1);
-                if (this.paused) {
-                    this.warn('Unimplemented Timer Pause');
-                }
-                // TODO actually pause the timer
-                break;
-            case INTR:
-                this.intRaw &= ~this.rawWriteValue;
-                this.checkInterrupts();
-                break;
-            case INTE:
-                this.intEnable = value & 0xf;
-                this.checkInterrupts();
-                break;
-            case INTF:
-                this.intForce = value & 0xf;
-                this.checkInterrupts();
-                break;
-            default:
-                super.writeUint32(offset, value);
-        }
-    }
-    fireAlarm(index) {
-        const alarm = this.alarms[index];
-        this.disarmAlarm(alarm);
-        this.intRaw |= alarm.bitValue;
-        this.checkInterrupts();
-    }
-    checkInterrupts() {
-        const { intStatus } = this;
-        for (let i = 0; i < this.alarms.length; i++) {
-            this.rp2040.setInterrupt(timerInterrupts[i], !!(intStatus & (1 << i)));
-        }
-    }
-    disarmAlarm(alarm) {
-        if (alarm.timer) {
-            this.clock.deleteTimer(alarm.timer);
-            alarm.timer = null;
-        }
-        alarm.armed = false;
-    }
-}
-exports.RPTimer = RPTimer;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RPTimer = void 0;
+const irq_js_1 = require("../irq.js");
+const peripheral_js_1 = require("./peripheral.js");
+const TIMEHR = 0x08;
+const TIMELR = 0x0c;
+const TIMERAWH = 0x24;
+const TIMERAWL = 0x28;
+const ALARM0 = 0x10;
+const ALARM1 = 0x14;
+const ALARM2 = 0x18;
+const ALARM3 = 0x1c;
+const ARMED = 0x20;
+const PAUSE = 0x30;
+const INTR = 0x34;
+const INTE = 0x38;
+const INTF = 0x3c;
+const INTS = 0x40;
+const ALARM_0 = 1 << 0;
+const ALARM_1 = 1 << 1;
+const ALARM_2 = 1 << 2;
+const ALARM_3 = 1 << 3;
+const timerInterrupts = [irq_js_1.IRQ.TIMER_0, irq_js_1.IRQ.TIMER_1, irq_js_1.IRQ.TIMER_2, irq_js_1.IRQ.TIMER_3];
+class RPTimerAlarm {
+    constructor(name, bitValue) {
+        this.name = name;
+        this.bitValue = bitValue;
+        this.armed = false;
+        this.targetMicros = 0;
+        this.timer = null;
+    }
+}
+class RPTimer extends peripheral_js_1.BasePeripheral {
+    constructor(rp2040, name) {
+        super(rp2040, name);
+        this.latchedTimeHigh = 0;
+        this.alarms = [
+            new RPTimerAlarm('Alarm 0', ALARM_0),
+            new RPTimerAlarm('Alarm 1', ALARM_1),
+            new RPTimerAlarm('Alarm 2', ALARM_2),
+            new RPTimerAlarm('Alarm 3', ALARM_3),
+        ];
+        this.intRaw = 0;
+        this.intEnable = 0;
+        this.intForce = 0;
+        this.paused = false;
+        this.clock = rp2040.clock;
+    }
+    get intStatus() {
+        return (this.intRaw & this.intEnable) | this.intForce;
+    }
+    readUint32(offset) {
+        const time = this.clock.micros;
+        switch (offset) {
+            case TIMEHR:
+                return this.latchedTimeHigh;
+            case TIMELR:
+                this.latchedTimeHigh = Math.floor(time / 2 ** 32);
+                return time >>> 0;
+            case TIMERAWH:
+                return Math.floor(time / 2 ** 32);
+            case TIMERAWL:
+                return time >>> 0;
+            case ALARM0:
+                return this.alarms[0].targetMicros;
+            case ALARM1:
+                return this.alarms[1].targetMicros;
+            case ALARM2:
+                return this.alarms[2].targetMicros;
+            case ALARM3:
+                return this.alarms[3].targetMicros;
+            case PAUSE:
+                return this.paused ? 1 : 0;
+            case INTR:
+                return this.intRaw;
+            case INTE:
+                return this.intEnable;
+            case INTF:
+                return this.intForce;
+            case INTS:
+                return this.intStatus;
+            case ARMED:
+                return ((this.alarms[0].armed ? this.alarms[0].bitValue : 0) |
+                    (this.alarms[1].armed ? this.alarms[1].bitValue : 0) |
+                    (this.alarms[2].armed ? this.alarms[2].bitValue : 0) |
+                    (this.alarms[3].armed ? this.alarms[3].bitValue : 0));
+        }
+        return super.readUint32(offset);
+    }
+    writeUint32(offset, value) {
+        switch (offset) {
+            case ALARM0:
+            case ALARM1:
+            case ALARM2:
+            case ALARM3: {
+                const alarmIndex = (offset - ALARM0) / 4;
+                const alarm = this.alarms[alarmIndex];
+                const delta = (value - this.clock.micros) >>> 0;
+                this.disarmAlarm(alarm);
+                alarm.armed = true;
+                alarm.targetMicros = value;
+                alarm.timer = this.clock.createTimer(delta, () => this.fireAlarm(alarmIndex));
+                break;
+            }
+            case ARMED:
+                for (const alarm of this.alarms) {
+                    if (this.rawWriteValue & alarm.bitValue) {
+                        this.disarmAlarm(alarm);
+                    }
+                }
+                break;
+            case PAUSE:
+                this.paused = !!(value & 1);
+                if (this.paused) {
+                    this.warn('Unimplemented Timer Pause');
+                }
+                // TODO actually pause the timer
+                break;
+            case INTR:
+                this.intRaw &= ~this.rawWriteValue;
+                this.checkInterrupts();
+                break;
+            case INTE:
+                this.intEnable = value & 0xf;
+                this.checkInterrupts();
+                break;
+            case INTF:
+                this.intForce = value & 0xf;
+                this.checkInterrupts();
+                break;
+            default:
+                super.writeUint32(offset, value);
+        }
+    }
+    fireAlarm(index) {
+        const alarm = this.alarms[index];
+        this.disarmAlarm(alarm);
+        this.intRaw |= alarm.bitValue;
+        this.checkInterrupts();
+    }
+    checkInterrupts() {
+        const { intStatus } = this;
+        for (let i = 0; i < this.alarms.length; i++) {
+            this.rp2040.setInterrupt(timerInterrupts[i], !!(intStatus & (1 << i)));
+        }
+    }
+    disarmAlarm(alarm) {
+        if (alarm.timer) {
+            this.clock.deleteTimer(alarm.timer);
+            alarm.timer = null;
+        }
+        alarm.armed = false;
+    }
+}
+exports.RPTimer = RPTimer;

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

@@ -1,28 +1,31 @@
-import { RP2040 } from '../rp2040';
-import { BasePeripheral, Peripheral } from './peripheral';
-export declare class RPUART extends BasePeripheral implements Peripheral {
-    readonly index: number;
-    readonly irq: number;
-    private ctrlRegister;
-    private lineCtrlRegister;
-    private rxFIFO;
-    private interruptMask;
-    private interruptStatus;
-    private readonly rxDREQ;
-    private readonly txDREQ;
-    onByte?: (value: number) => void;
-    constructor(rp2040: RP2040, name: string, index: number, irq: number);
-    get enabled(): boolean;
-    get txEnabled(): boolean;
-    get rxEnabled(): boolean;
-    get fifosEnabled(): boolean;
-    /**
-     * Number of bits per UART character
-     */
-    get wordLength(): 8 | 6 | 5 | 7 | undefined;
-    get flags(): number;
-    checkInterrupts(): void;
-    feedByte(value: number): void;
-    readUint32(offset: number): number;
-    writeUint32(offset: number, value: number): void;
-}
+import { RP2040 } from '../rp2040.js';
+import { DREQChannel } from './dma.js';
+import { BasePeripheral, Peripheral } from './peripheral.js';
+export interface IUARTDMAChannels {
+    rx: DREQChannel;
+    tx: DREQChannel;
+}
+export declare class RPUART extends BasePeripheral implements Peripheral {
+    readonly irq: number;
+    readonly dreq: IUARTDMAChannels;
+    private ctrlRegister;
+    private lineCtrlRegister;
+    private rxFIFO;
+    private interruptMask;
+    private interruptStatus;
+    onByte?: (value: number) => void;
+    constructor(rp2040: RP2040, name: string, irq: number, dreq: IUARTDMAChannels);
+    get enabled(): boolean;
+    get txEnabled(): boolean;
+    get rxEnabled(): boolean;
+    get fifosEnabled(): boolean;
+    /**
+     * Number of bits per UART character
+     */
+    get wordLength(): 5 | 6 | 7 | 8 | undefined;
+    get flags(): number;
+    checkInterrupts(): void;
+    feedByte(value: number): void;
+    readUint32(offset: number): number;
+    writeUint32(offset: number, value: number): void;
+}