rp2040js 0.17.17 → 0.18.0

package/dist/esm/peripherals/uart.js

@@ -1,128 +1,128 @@
-import { FIFO } from '../utils/fifo';
-import { BasePeripheral } from './peripheral';
-const UARTDR = 0x0;
-const UARTFR = 0x18;
-const UARTLCR_H = 0x2c;
-const UARTCR = 0x30;
-const UARTIMSC = 0x38;
-const UARTIRIS = 0x3c;
-const UARTIMIS = 0x40;
-const UARTICR = 0x44;
-// UARTFR bits:
-const TXFE = 1 << 7;
-const RXFF = 1 << 6;
-const RXFE = 1 << 4;
-// UARTLCR_H bits:
-const FEN = 1 << 4;
-// UARTCR bits:
-const RXE = 1 << 9;
-const TXE = 1 << 8;
-const UARTEN = 1 << 0;
-// Interrupt bits
-const UARTRXINTR = 1 << 4;
-export class RPUART extends BasePeripheral {
-    constructor(rp2040, name, irq, dreq) {
-        super(rp2040, name);
-        this.irq = irq;
-        this.dreq = dreq;
-        this.ctrlRegister = RXE | TXE;
-        this.lineCtrlRegister = 0;
-        this.rxFIFO = new FIFO(32);
-        this.interruptMask = 0;
-        this.interruptStatus = 0;
-    }
-    get enabled() {
-        return !!(this.ctrlRegister & UARTEN);
-    }
-    get txEnabled() {
-        return !!(this.ctrlRegister & TXE);
-    }
-    get rxEnabled() {
-        return !!(this.ctrlRegister & RXE);
-    }
-    get fifosEnabled() {
-        return !!(this.lineCtrlRegister & FEN);
-    }
-    /**
-     * Number of bits per UART character
-     */
-    get wordLength() {
-        switch ((this.lineCtrlRegister >>> 5) & 0x3) {
-            case 0b00:
-                return 5;
-            case 0b01:
-                return 6;
-            case 0b10:
-                return 7;
-            case 0b11:
-                return 8;
-        }
-    }
-    get flags() {
-        return (this.rxFIFO.full ? RXFF : 0) | (this.rxFIFO.empty ? RXFE : 0) | TXFE;
-    }
-    checkInterrupts() {
-        this.rp2040.setInterrupt(this.irq, !!(this.interruptStatus & this.interruptMask));
-    }
-    feedByte(value) {
-        this.rxFIFO.push(value);
-        // TODO check if the FIFO has reached the threshold level
-        this.interruptStatus |= UARTRXINTR;
-        this.checkInterrupts();
-    }
-    readUint32(offset) {
-        switch (offset) {
-            case UARTDR: {
-                const value = this.rxFIFO.pull();
-                if (!this.rxFIFO.empty) {
-                    this.interruptStatus |= UARTRXINTR;
-                    this.checkInterrupts();
-                }
-                return value;
-            }
-            case UARTFR:
-                return this.flags;
-            case UARTLCR_H:
-                return this.lineCtrlRegister;
-            case UARTCR:
-                return this.ctrlRegister;
-            case UARTIMSC:
-                return this.interruptMask;
-            case UARTIRIS:
-                return this.interruptStatus;
-            case UARTIMIS:
-                return this.interruptStatus & this.interruptMask;
-        }
-        return super.readUint32(offset);
-    }
-    writeUint32(offset, value) {
-        var _a;
-        switch (offset) {
-            case UARTDR:
-                (_a = this.onByte) === null || _a === void 0 ? void 0 : _a.call(this, value & 0xff);
-                break;
-            case UARTLCR_H:
-                this.lineCtrlRegister = value;
-                break;
-            case UARTCR:
-                this.ctrlRegister = value;
-                if (this.enabled) {
-                    this.rp2040.dma.setDREQ(this.dreq.tx);
-                }
-                else {
-                    this.rp2040.dma.clearDREQ(this.dreq.tx);
-                }
-                break;
-            case UARTIMSC:
-                this.interruptMask = value & 0x7ff;
-                this.checkInterrupts();
-                break;
-            case UARTICR:
-                this.interruptStatus &= ~this.rawWriteValue;
-                this.checkInterrupts();
-                break;
-            default:
-                super.writeUint32(offset, value);
-        }
-    }
-}
+import { FIFO } from '../utils/fifo.js';
+import { BasePeripheral } from './peripheral.js';
+const UARTDR = 0x0;
+const UARTFR = 0x18;
+const UARTLCR_H = 0x2c;
+const UARTCR = 0x30;
+const UARTIMSC = 0x38;
+const UARTIRIS = 0x3c;
+const UARTIMIS = 0x40;
+const UARTICR = 0x44;
+// UARTFR bits:
+const TXFE = 1 << 7;
+const RXFF = 1 << 6;
+const RXFE = 1 << 4;
+// UARTLCR_H bits:
+const FEN = 1 << 4;
+// UARTCR bits:
+const RXE = 1 << 9;
+const TXE = 1 << 8;
+const UARTEN = 1 << 0;
+// Interrupt bits
+const UARTRXINTR = 1 << 4;
+export class RPUART extends BasePeripheral {
+    constructor(rp2040, name, irq, dreq) {
+        super(rp2040, name);
+        this.irq = irq;
+        this.dreq = dreq;
+        this.ctrlRegister = RXE | TXE;
+        this.lineCtrlRegister = 0;
+        this.rxFIFO = new FIFO(32);
+        this.interruptMask = 0;
+        this.interruptStatus = 0;
+    }
+    get enabled() {
+        return !!(this.ctrlRegister & UARTEN);
+    }
+    get txEnabled() {
+        return !!(this.ctrlRegister & TXE);
+    }
+    get rxEnabled() {
+        return !!(this.ctrlRegister & RXE);
+    }
+    get fifosEnabled() {
+        return !!(this.lineCtrlRegister & FEN);
+    }
+    /**
+     * Number of bits per UART character
+     */
+    get wordLength() {
+        switch ((this.lineCtrlRegister >>> 5) & 0x3) {
+            case 0b00:
+                return 5;
+            case 0b01:
+                return 6;
+            case 0b10:
+                return 7;
+            case 0b11:
+                return 8;
+        }
+    }
+    get flags() {
+        return (this.rxFIFO.full ? RXFF : 0) | (this.rxFIFO.empty ? RXFE : 0) | TXFE;
+    }
+    checkInterrupts() {
+        this.rp2040.setInterrupt(this.irq, !!(this.interruptStatus & this.interruptMask));
+    }
+    feedByte(value) {
+        this.rxFIFO.push(value);
+        // TODO check if the FIFO has reached the threshold level
+        this.interruptStatus |= UARTRXINTR;
+        this.checkInterrupts();
+    }
+    readUint32(offset) {
+        switch (offset) {
+            case UARTDR: {
+                const value = this.rxFIFO.pull();
+                if (!this.rxFIFO.empty) {
+                    this.interruptStatus |= UARTRXINTR;
+                    this.checkInterrupts();
+                }
+                return value;
+            }
+            case UARTFR:
+                return this.flags;
+            case UARTLCR_H:
+                return this.lineCtrlRegister;
+            case UARTCR:
+                return this.ctrlRegister;
+            case UARTIMSC:
+                return this.interruptMask;
+            case UARTIRIS:
+                return this.interruptStatus;
+            case UARTIMIS:
+                return this.interruptStatus & this.interruptMask;
+        }
+        return super.readUint32(offset);
+    }
+    writeUint32(offset, value) {
+        var _a;
+        switch (offset) {
+            case UARTDR:
+                (_a = this.onByte) === null || _a === void 0 ? void 0 : _a.call(this, value & 0xff);
+                break;
+            case UARTLCR_H:
+                this.lineCtrlRegister = value;
+                break;
+            case UARTCR:
+                this.ctrlRegister = value;
+                if (this.enabled) {
+                    this.rp2040.dma.setDREQ(this.dreq.tx);
+                }
+                else {
+                    this.rp2040.dma.clearDREQ(this.dreq.tx);
+                }
+                break;
+            case UARTIMSC:
+                this.interruptMask = value & 0x7ff;
+                this.checkInterrupts();
+                break;
+            case UARTICR:
+                this.interruptStatus &= ~this.rawWriteValue;
+                this.checkInterrupts();
+                break;
+            default:
+                super.writeUint32(offset, value);
+        }
+    }
+}

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

@@ -1,29 +1,29 @@
-import { BasePeripheral } from './peripheral';
-export declare class RPUSBController extends BasePeripheral {
-    private mainCtrl;
-    private intRaw;
-    private intEnable;
-    private intForce;
-    private sieStatus;
-    private buffStatus;
-    onUSBEnabled?: () => void;
-    onResetReceived?: () => void;
-    onEndpointWrite?: (endpoint: number, buffer: Uint8Array) => void;
-    onEndpointRead?: (endpoint: number, byteCount: number) => void;
-    readDelayMicroseconds: number;
-    writeDelayMicroseconds: number;
-    get intStatus(): number;
-    readUint32(offset: number): number;
-    writeUint32(offset: number, value: number): void;
-    private readEndpointControlReg;
-    private getEndpointBufferOffset;
-    DPRAMUpdated(offset: number, value: number): void;
-    endpointReadDone(endpoint: number, buffer: Uint8Array, delay?: number): void;
-    private finishRead;
-    private checkInterrupts;
-    resetDevice(): void;
-    sendSetupPacket(setupPacket: Uint8Array): void;
-    private indicateBufferReady;
-    private buffStatusUpdated;
-    private sieStatusUpdated;
-}
+import { BasePeripheral } from './peripheral.js';
+export declare class RPUSBController extends BasePeripheral {
+    private mainCtrl;
+    private intRaw;
+    private intEnable;
+    private intForce;
+    private sieStatus;
+    private buffStatus;
+    onUSBEnabled?: () => void;
+    onResetReceived?: () => void;
+    onEndpointWrite?: (endpoint: number, buffer: Uint8Array) => void;
+    onEndpointRead?: (endpoint: number, byteCount: number) => void;
+    readDelayMicroseconds: number;
+    writeDelayMicroseconds: number;
+    get intStatus(): number;
+    readUint32(offset: number): number;
+    writeUint32(offset: number, value: number): void;
+    private readEndpointControlReg;
+    private getEndpointBufferOffset;
+    DPRAMUpdated(offset: number, value: number): void;
+    endpointReadDone(endpoint: number, buffer: Uint8Array, delay?: number): void;
+    private finishRead;
+    private checkInterrupts;
+    resetDevice(): void;
+    sendSetupPacket(setupPacket: Uint8Array): void;
+    private indicateBufferReady;
+    private buffStatusUpdated;
+    private sieStatusUpdated;
+}