rp2040js 0.17.16 → 0.18.0

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

@@ -1,11 +1,11 @@
-import { RP2040 } from '../rp2040';
-import { BasePeripheral, Peripheral } from './peripheral';
-export declare class RPIO extends BasePeripheral implements Peripheral {
-    constructor(rp2040: RP2040, name: string);
-    getPinFromOffset(offset: number): {
-        gpio: import("..").GPIOPin;
-        isCtrl: boolean;
-    };
-    readUint32(offset: number): number;
-    writeUint32(offset: number, value: number): void;
-}
+import { RP2040 } from '../rp2040.js';
+import { BasePeripheral, Peripheral } from './peripheral.js';
+export declare class RPIO extends BasePeripheral implements Peripheral {
+    constructor(rp2040: RP2040, name: string);
+    getPinFromOffset(offset: number): {
+        gpio: import("../gpio-pin.js").GPIOPin;
+        isCtrl: boolean;
+    };
+    readUint32(offset: number): number;
+    writeUint32(offset: number, value: number): void;
+}

package/dist/cjs/peripherals/io.js

@@ -1,100 +1,100 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RPIO = void 0;
-const peripheral_1 = require("./peripheral");
-const GPIO_CTRL_LAST = 0x0ec;
-const INTR0 = 0xf0;
-const PROC0_INTE0 = 0x100;
-const PROC0_INTF0 = 0x110;
-const PROC0_INTS0 = 0x120;
-const PROC0_INTS3 = 0x12c;
-class RPIO extends peripheral_1.BasePeripheral {
-    constructor(rp2040, name) {
-        super(rp2040, name);
-    }
-    getPinFromOffset(offset) {
-        const gpioIndex = offset >>> 3;
-        return {
-            gpio: this.rp2040.gpio[gpioIndex],
-            isCtrl: !!(offset & 0x4),
-        };
-    }
-    readUint32(offset) {
-        if (offset <= GPIO_CTRL_LAST) {
-            const { gpio, isCtrl } = this.getPinFromOffset(offset);
-            return isCtrl ? gpio.ctrl : gpio.status;
-        }
-        if (offset >= INTR0 && offset <= PROC0_INTS3) {
-            const startIndex = (offset & 0xf) * 2;
-            const register = offset & ~0xf;
-            const { gpio } = this.rp2040;
-            let result = 0;
-            for (let index = 7; index >= 0; index--) {
-                const pin = gpio[index + startIndex];
-                if (!pin) {
-                    continue;
-                }
-                result <<= 4;
-                switch (register) {
-                    case INTR0:
-                        result |= pin.irqStatus;
-                        break;
-                    case PROC0_INTE0:
-                        result |= pin.irqEnableMask;
-                        break;
-                    case PROC0_INTF0:
-                        result |= pin.irqForceMask;
-                        break;
-                    case PROC0_INTS0:
-                        result |= (pin.irqStatus & pin.irqEnableMask) | pin.irqForceMask;
-                        break;
-                }
-            }
-            return result;
-        }
-        return super.readUint32(offset);
-    }
-    writeUint32(offset, value) {
-        if (offset <= GPIO_CTRL_LAST) {
-            const { gpio, isCtrl } = this.getPinFromOffset(offset);
-            if (isCtrl) {
-                gpio.ctrl = value;
-                gpio.checkForUpdates();
-            }
-            return;
-        }
-        if (offset >= INTR0 && offset <= PROC0_INTS3) {
-            const startIndex = (offset & 0xf) * 2;
-            const register = offset & ~0xf;
-            const { gpio } = this.rp2040;
-            for (let index = 0; index < 8; index++) {
-                const pin = gpio[index + startIndex];
-                if (!pin) {
-                    continue;
-                }
-                const pinValue = (value >> (index * 4)) & 0xf;
-                const pinRawWriteValue = (this.rawWriteValue >> (index * 4)) & 0xf;
-                switch (register) {
-                    case INTR0:
-                        pin.updateIRQValue(pinRawWriteValue);
-                        break;
-                    case PROC0_INTE0:
-                        if (pin.irqEnableMask !== pinValue) {
-                            pin.irqEnableMask = pinValue;
-                            this.rp2040.updateIOInterrupt();
-                        }
-                        break;
-                    case PROC0_INTF0:
-                        if (pin.irqForceMask !== pinValue) {
-                            pin.irqForceMask = pinValue;
-                            this.rp2040.updateIOInterrupt();
-                        }
-                        break;
-                }
-            }
-            return;
-        }
-        super.writeUint32(offset, value);
-    }
-}
-exports.RPIO = RPIO;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RPIO = void 0;
+const peripheral_js_1 = require("./peripheral.js");
+const GPIO_CTRL_LAST = 0x0ec;
+const INTR0 = 0xf0;
+const PROC0_INTE0 = 0x100;
+const PROC0_INTF0 = 0x110;
+const PROC0_INTS0 = 0x120;
+const PROC0_INTS3 = 0x12c;
+class RPIO extends peripheral_js_1.BasePeripheral {
+    constructor(rp2040, name) {
+        super(rp2040, name);
+    }
+    getPinFromOffset(offset) {
+        const gpioIndex = offset >>> 3;
+        return {
+            gpio: this.rp2040.gpio[gpioIndex],
+            isCtrl: !!(offset & 0x4),
+        };
+    }
+    readUint32(offset) {
+        if (offset <= GPIO_CTRL_LAST) {
+            const { gpio, isCtrl } = this.getPinFromOffset(offset);
+            return isCtrl ? gpio.ctrl : gpio.status;
+        }
+        if (offset >= INTR0 && offset <= PROC0_INTS3) {
+            const startIndex = (offset & 0xf) * 2;
+            const register = offset & ~0xf;
+            const { gpio } = this.rp2040;
+            let result = 0;
+            for (let index = 7; index >= 0; index--) {
+                const pin = gpio[index + startIndex];
+                if (!pin) {
+                    continue;
+                }
+                result <<= 4;
+                switch (register) {
+                    case INTR0:
+                        result |= pin.irqStatus;
+                        break;
+                    case PROC0_INTE0:
+                        result |= pin.irqEnableMask;
+                        break;
+                    case PROC0_INTF0:
+                        result |= pin.irqForceMask;
+                        break;
+                    case PROC0_INTS0:
+                        result |= (pin.irqStatus & pin.irqEnableMask) | pin.irqForceMask;
+                        break;
+                }
+            }
+            return result;
+        }
+        return super.readUint32(offset);
+    }
+    writeUint32(offset, value) {
+        if (offset <= GPIO_CTRL_LAST) {
+            const { gpio, isCtrl } = this.getPinFromOffset(offset);
+            if (isCtrl) {
+                gpio.ctrl = value;
+                gpio.checkForUpdates();
+            }
+            return;
+        }
+        if (offset >= INTR0 && offset <= PROC0_INTS3) {
+            const startIndex = (offset & 0xf) * 2;
+            const register = offset & ~0xf;
+            const { gpio } = this.rp2040;
+            for (let index = 0; index < 8; index++) {
+                const pin = gpio[index + startIndex];
+                if (!pin) {
+                    continue;
+                }
+                const pinValue = (value >> (index * 4)) & 0xf;
+                const pinRawWriteValue = (this.rawWriteValue >> (index * 4)) & 0xf;
+                switch (register) {
+                    case INTR0:
+                        pin.updateIRQValue(pinRawWriteValue);
+                        break;
+                    case PROC0_INTE0:
+                        if (pin.irqEnableMask !== pinValue) {
+                            pin.irqEnableMask = pinValue;
+                            this.rp2040.updateIOInterrupt();
+                        }
+                        break;
+                    case PROC0_INTF0:
+                        if (pin.irqForceMask !== pinValue) {
+                            pin.irqForceMask = pinValue;
+                            this.rp2040.updateIOInterrupt();
+                        }
+                        break;
+                }
+            }
+            return;
+        }
+        super.writeUint32(offset, value);
+    }
+}
+exports.RPIO = RPIO;

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

@@ -1,13 +1,13 @@
-import { RP2040 } from '../rp2040';
-import { BasePeripheral, Peripheral } from './peripheral';
-export declare type IIOBank = 'qspi' | 'bank0';
-export declare class RPPADS extends BasePeripheral implements Peripheral {
-    readonly bank: IIOBank;
-    voltageSelect: number;
-    private readonly firstPadRegister;
-    private readonly lastPadRegister;
-    constructor(rp2040: RP2040, name: string, bank: IIOBank);
-    getPinFromOffset(offset: number): import("..").GPIOPin;
-    readUint32(offset: number): number;
-    writeUint32(offset: number, value: number): void;
-}
+import { RP2040 } from '../rp2040.js';
+import { BasePeripheral, Peripheral } from './peripheral.js';
+export type IIOBank = 'qspi' | 'bank0';
+export declare class RPPADS extends BasePeripheral implements Peripheral {
+    readonly bank: IIOBank;
+    voltageSelect: number;
+    private readonly firstPadRegister;
+    private readonly lastPadRegister;
+    constructor(rp2040: RP2040, name: string, bank: IIOBank);
+    getPinFromOffset(offset: number): import("../gpio-pin.js").GPIOPin;
+    readUint32(offset: number): number;
+    writeUint32(offset: number, value: number): void;
+}

package/dist/cjs/peripherals/pads.js

@@ -1,58 +1,58 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RPPADS = void 0;
-const peripheral_1 = require("./peripheral");
-const VOLTAGE_SELECT = 0;
-const GPIO_FIRST = 0x4;
-const GPIO_LAST = 0x78;
-const QSPI_FIRST = 0x4;
-const QSPI_LAST = 0x18;
-class RPPADS extends peripheral_1.BasePeripheral {
-    constructor(rp2040, name, bank) {
-        super(rp2040, name);
-        this.bank = bank;
-        this.voltageSelect = 0;
-        this.firstPadRegister = this.bank === 'qspi' ? QSPI_FIRST : GPIO_FIRST;
-        this.lastPadRegister = this.bank === 'qspi' ? QSPI_LAST : GPIO_LAST;
-    }
-    getPinFromOffset(offset) {
-        const gpioIndex = (offset - this.firstPadRegister) >>> 2;
-        if (this.bank === 'qspi') {
-            return this.rp2040.qspi[gpioIndex];
-        }
-        else {
-            return this.rp2040.gpio[gpioIndex];
-        }
-    }
-    readUint32(offset) {
-        if (offset >= this.firstPadRegister && offset <= this.lastPadRegister) {
-            const gpio = this.getPinFromOffset(offset);
-            return gpio.padValue;
-        }
-        switch (offset) {
-            case VOLTAGE_SELECT:
-                return this.voltageSelect;
-        }
-        return super.readUint32(offset);
-    }
-    writeUint32(offset, value) {
-        if (offset >= this.firstPadRegister && offset <= this.lastPadRegister) {
-            const gpio = this.getPinFromOffset(offset);
-            const oldInputEnable = gpio.inputEnable;
-            gpio.padValue = value;
-            gpio.checkForUpdates();
-            if (oldInputEnable !== gpio.inputEnable) {
-                gpio.refreshInput();
-            }
-            return;
-        }
-        switch (offset) {
-            case VOLTAGE_SELECT:
-                this.voltageSelect = value & 1;
-                break;
-            default:
-                super.writeUint32(offset, value);
-        }
-    }
-}
-exports.RPPADS = RPPADS;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RPPADS = void 0;
+const peripheral_js_1 = require("./peripheral.js");
+const VOLTAGE_SELECT = 0;
+const GPIO_FIRST = 0x4;
+const GPIO_LAST = 0x78;
+const QSPI_FIRST = 0x4;
+const QSPI_LAST = 0x18;
+class RPPADS extends peripheral_js_1.BasePeripheral {
+    constructor(rp2040, name, bank) {
+        super(rp2040, name);
+        this.bank = bank;
+        this.voltageSelect = 0;
+        this.firstPadRegister = this.bank === 'qspi' ? QSPI_FIRST : GPIO_FIRST;
+        this.lastPadRegister = this.bank === 'qspi' ? QSPI_LAST : GPIO_LAST;
+    }
+    getPinFromOffset(offset) {
+        const gpioIndex = (offset - this.firstPadRegister) >>> 2;
+        if (this.bank === 'qspi') {
+            return this.rp2040.qspi[gpioIndex];
+        }
+        else {
+            return this.rp2040.gpio[gpioIndex];
+        }
+    }
+    readUint32(offset) {
+        if (offset >= this.firstPadRegister && offset <= this.lastPadRegister) {
+            const gpio = this.getPinFromOffset(offset);
+            return gpio.padValue;
+        }
+        switch (offset) {
+            case VOLTAGE_SELECT:
+                return this.voltageSelect;
+        }
+        return super.readUint32(offset);
+    }
+    writeUint32(offset, value) {
+        if (offset >= this.firstPadRegister && offset <= this.lastPadRegister) {
+            const gpio = this.getPinFromOffset(offset);
+            const oldInputEnable = gpio.inputEnable;
+            gpio.padValue = value;
+            gpio.checkForUpdates();
+            if (oldInputEnable !== gpio.inputEnable) {
+                gpio.refreshInput();
+            }
+            return;
+        }
+        switch (offset) {
+            case VOLTAGE_SELECT:
+                this.voltageSelect = value & 1;
+                break;
+            default:
+                super.writeUint32(offset, value);
+        }
+    }
+}
+exports.RPPADS = RPPADS;

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

@@ -1,22 +1,22 @@
-import { RP2040 } from '../rp2040';
-export declare function atomicUpdate(currentValue: number, atomicType: number, newValue: number): number;
-export interface Peripheral {
-    readUint32(offset: number): number;
-    writeUint32(offset: number, value: number): void;
-    writeUint32Atomic(offset: number, value: number, atomicType: number): void;
-}
-export declare class BasePeripheral implements Peripheral {
-    protected rp2040: RP2040;
-    readonly name: string;
-    protected rawWriteValue: number;
-    constructor(rp2040: RP2040, name: string);
-    readUint32(offset: number): number;
-    writeUint32(offset: number, value: number): void;
-    writeUint32Atomic(offset: number, value: number, atomicType: number): void;
-    debug(msg: string): void;
-    info(msg: string): void;
-    warn(msg: string): void;
-    error(msg: string): void;
-}
-export declare class UnimplementedPeripheral extends BasePeripheral {
-}
+import { RP2040 } from '../rp2040.js';
+export declare function atomicUpdate(currentValue: number, atomicType: number, newValue: number): number;
+export interface Peripheral {
+    readUint32(offset: number): number;
+    writeUint32(offset: number, value: number): void;
+    writeUint32Atomic(offset: number, value: number, atomicType: number): void;
+}
+export declare class BasePeripheral implements Peripheral {
+    protected rp2040: RP2040;
+    readonly name: string;
+    protected rawWriteValue: number;
+    constructor(rp2040: RP2040, name: string);
+    readUint32(offset: number): number;
+    writeUint32(offset: number, value: number): void;
+    writeUint32Atomic(offset: number, value: number, atomicType: number): void;
+    debug(msg: string): void;
+    info(msg: string): void;
+    warn(msg: string): void;
+    error(msg: string): void;
+}
+export declare class UnimplementedPeripheral extends BasePeripheral {
+}

package/dist/cjs/peripherals/peripheral.js

@@ -1,61 +1,61 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnimplementedPeripheral = exports.BasePeripheral = exports.atomicUpdate = void 0;
-const ATOMIC_NORMAL = 0;
-const ATOMIC_XOR = 1;
-const ATOMIC_SET = 2;
-const ATOMIC_CLEAR = 3;
-function atomicUpdate(currentValue, atomicType, newValue) {
-    switch (atomicType) {
-        case ATOMIC_XOR:
-            return currentValue ^ newValue;
-        case ATOMIC_SET:
-            return currentValue | newValue;
-        case ATOMIC_CLEAR:
-            return currentValue & ~newValue;
-        default:
-            console.warn('Atomic update called with invalid writeType', atomicType);
-            return newValue;
-    }
-}
-exports.atomicUpdate = atomicUpdate;
-class BasePeripheral {
-    constructor(rp2040, name) {
-        this.rp2040 = rp2040;
-        this.name = name;
-        this.rawWriteValue = 0;
-    }
-    readUint32(offset) {
-        this.warn(`Unimplemented peripheral read from ${offset.toString(16)}`);
-        if (offset > 0x1000) {
-            this.warn('Unimplemented read from peripheral in the atomic operation region');
-        }
-        return 0xffffffff;
-    }
-    writeUint32(offset, value) {
-        this.warn(`Unimplemented peripheral write to ${offset.toString(16)}: ${value}`);
-    }
-    writeUint32Atomic(offset, value, atomicType) {
-        this.rawWriteValue = value;
-        const newValue = atomicType != ATOMIC_NORMAL
-            ? atomicUpdate(this.readUint32(offset), atomicType, value)
-            : value;
-        this.writeUint32(offset, newValue);
-    }
-    debug(msg) {
-        this.rp2040.logger.debug(this.name, msg);
-    }
-    info(msg) {
-        this.rp2040.logger.info(this.name, msg);
-    }
-    warn(msg) {
-        this.rp2040.logger.warn(this.name, msg);
-    }
-    error(msg) {
-        this.rp2040.logger.error(this.name, msg);
-    }
-}
-exports.BasePeripheral = BasePeripheral;
-class UnimplementedPeripheral extends BasePeripheral {
-}
-exports.UnimplementedPeripheral = UnimplementedPeripheral;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnimplementedPeripheral = exports.BasePeripheral = exports.atomicUpdate = void 0;
+const ATOMIC_NORMAL = 0;
+const ATOMIC_XOR = 1;
+const ATOMIC_SET = 2;
+const ATOMIC_CLEAR = 3;
+function atomicUpdate(currentValue, atomicType, newValue) {
+    switch (atomicType) {
+        case ATOMIC_XOR:
+            return currentValue ^ newValue;
+        case ATOMIC_SET:
+            return currentValue | newValue;
+        case ATOMIC_CLEAR:
+            return currentValue & ~newValue;
+        default:
+            console.warn('Atomic update called with invalid writeType', atomicType);
+            return newValue;
+    }
+}
+exports.atomicUpdate = atomicUpdate;
+class BasePeripheral {
+    constructor(rp2040, name) {
+        this.rp2040 = rp2040;
+        this.name = name;
+        this.rawWriteValue = 0;
+    }
+    readUint32(offset) {
+        this.warn(`Unimplemented peripheral read from ${offset.toString(16)}`);
+        if (offset > 0x1000) {
+            this.warn('Unimplemented read from peripheral in the atomic operation region');
+        }
+        return 0xffffffff;
+    }
+    writeUint32(offset, value) {
+        this.warn(`Unimplemented peripheral write to ${offset.toString(16)}: ${value}`);
+    }
+    writeUint32Atomic(offset, value, atomicType) {
+        this.rawWriteValue = value;
+        const newValue = atomicType != ATOMIC_NORMAL
+            ? atomicUpdate(this.readUint32(offset), atomicType, value)
+            : value;
+        this.writeUint32(offset, newValue);
+    }
+    debug(msg) {
+        this.rp2040.logger.debug(this.name, msg);
+    }
+    info(msg) {
+        this.rp2040.logger.info(this.name, msg);
+    }
+    warn(msg) {
+        this.rp2040.logger.warn(this.name, msg);
+    }
+    error(msg) {
+        this.rp2040.logger.error(this.name, msg);
+    }
+}
+exports.BasePeripheral = BasePeripheral;
+class UnimplementedPeripheral extends BasePeripheral {
+}
+exports.UnimplementedPeripheral = UnimplementedPeripheral;