stm32f4-emu 0.1.0

package/site/netsim.js

@@ -0,0 +1,212 @@
+// In-browser network simulator: answers the eth_http firmware's DHCP, TCP
+// and HTTP traffic with canned replies (no real stack, no gateway needed).
+//
+// Mirrors the openhw-local-gateway roles:
+//   server MAC  = 5a:94:ef:e4:0c:dd  (the firmware's compile-time gw_mac)
+//   server IP   = 192.168.4.1, offered client IP = 192.168.4.2
+//   TCP target  = <client IP>:8092 (HTTP)
+
+export function createNetSim({ log = () => {} } = {}) {
+    const SERVER_MAC = [0x5a, 0x94, 0xef, 0xe4, 0x0c, 0xdd];
+    const CLIENT_MAC = [0x02, 0x00, 0x00, 0x00, 0x00, 0x01];
+    const SERVER_IP = [192, 168, 4, 1];
+    const CLIENT_IP = [192, 168, 4, 2];
+    const MASK = [255, 255, 255, 0];
+    const HTTP_PORT = 8092;
+    const HTTP_BODY =
+        'HTTP/1.1 200 OK\r\n' +
+        'Content-Length: 29\r\n' +
+        'Connection: close\r\n\r\n' +
+        'Hello from openhw HTTP server';
+
+    let clientMac = CLIENT_MAC.slice();
+    let srvSeq = 0x10000000; // server ISN
+    let clientSeq = 0;       // learned from the client SYN
+    let lastMsgType = 0;
+
+    const stats = { tx: 0, rx: 0, dhcpOffers: 0, dhcpAcks: 0, synAcks: 0, httpResponses: 0 };
+
+    const cksum = (bytes) => {
+        let sum = 0;
+        for (let i = 0; i < bytes.length; i += 2) {
+            const w = (bytes[i] << 8) | (i + 1 < bytes.length ? bytes[i + 1] : 0);
+            sum += w;
+        }
+        while (sum >> 16) sum = (sum & 0xffff) + (sum >> 16);
+        return (~sum) & 0xffff;
+    };
+
+    // Build a complete Ethernet+IP(+UDP/TCP) frame with correct IP checksum.
+    const buildFrame = (dstIp, proto, udpOrTcpPayload) => {
+        const ipLen = 20 + udpOrTcpPayload.length;
+        const f = new Uint8Array(14 + ipLen);
+        f.set(dstIp === 255 ? [255,255,255,255,255,255] : clientMac, 0);
+        f.set(SERVER_MAC, 6);
+        f[12] = 0x08; f[13] = 0x00;
+        const ip = 14;
+        f[ip] = 0x45; f[ip + 1] = 0;
+        f[ip + 2] = ipLen >> 8; f[ip + 3] = ipLen & 0xff;
+        f[ip + 8] = 128; f[ip + 9] = proto;
+        f.set(SERVER_IP, ip + 12);
+        f.set(dstIp, ip + 16);
+        const ck = cksum(f.subarray(ip, ip + 20));
+        f[ip + 10] = ck >> 8; f[ip + 11] = ck & 0xff;
+        f.set(udpOrTcpPayload, ip + 20);
+        return f;
+    };
+
+    // ── DHCP reply (Offer or Ack) ──
+    const dhcpReply = (req, msgType) => {
+        // BOOTP fixed part
+        const bootp = new Uint8Array(300);
+        const xid = (req[4] << 24) | (req[5] << 16) | (req[6] << 8) | req[7];
+        bootp[0] = 2;                          // op = reply
+        bootp[1] = 1;                          // htype = ethernet
+        bootp[2] = 6;                          // hlen
+        bootp[4] = xid >> 24; bootp[5] = xid >> 16; bootp[6] = xid >> 8; bootp[7] = xid;
+        bootp[8] = 0x80; bootp[9] = 0x00;      // broadcast flag
+        bootp.set(CLIENT_IP, 16);              // yiaddr
+        bootp.set(SERVER_IP, 20);              // siaddr
+        // chaddr = client's chaddr (12 bytes: MAC + 6 pad)
+        bootp.set(req.subarray(28, 40), 28);
+        bootp.set([0x63, 0x82, 0x53, 0x63], 236); // magic cookie
+        const opts = [53, 1, msgType,
+                      1, 4, ...MASK,
+                      3, 4, ...SERVER_IP,
+                      6, 4, ...SERVER_IP,
+                      54, 4, ...SERVER_IP,
+                      51, 4, 0, 0, 1, 0x80,  // lease 86400
+                      255];
+        bootp.set(opts, 240);
+        // UDP header (src 67, dst 68) + bootp
+        const udp = new Uint8Array(8 + bootp.length);
+        udp[0] = 0; udp[1] = 67; udp[2] = 0; udp[3] = 68;
+        const ulen = 8 + bootp.length;
+        udp[4] = ulen >> 8; udp[5] = ulen & 0xff;
+        udp.set(bootp, 8);
+        return buildFrame(255, 17, udp);       // dst IP = broadcast
+    };
+
+    // ── TCP ──
+    const tcpFrame = (flags, seq, ack, payload) => {
+        const data = payload || new Uint8Array(0);
+        const tcp = new Uint8Array(20 + data.length);
+        tcp[0] = HTTP_PORT >> 8; tcp[1] = HTTP_PORT & 0xff;   // src = server port
+        tcp[2] = tcpSrcPort >> 8; tcp[3] = tcpSrcPort & 0xff; // dst = client's ephemeral
+        tcp[4] = seq >> 24; tcp[5] = seq >> 16; tcp[6] = seq >> 8; tcp[7] = seq;
+        tcp[8] = ack >> 24; tcp[9] = ack >> 16; tcp[10] = ack >> 8; tcp[11] = ack;
+        tcp[12] = 0x50; tcp[13] = flags;
+        tcp[14] = 0xff; tcp[15] = 0xff;
+        tcp.set(data, 20);
+        return buildFrame(CLIENT_IP, 6, tcp);
+    };
+
+    let tcpSrcPort = 0; // client ephemeral port, learned from SYN
+
+    // Parse a TX frame; return an array of reply frames.
+    function onTx(frame) {
+        stats.tx++;
+        const replies = [];
+        if (frame.length < 14) return replies;
+        const et = (frame[12] << 8) | frame[13];
+
+        if (et === 0x1234) { // eth_irq_test: echo PING -> PONG
+            if (new TextDecoder().decode(frame.subarray(14, 27)).includes('PING')) {
+                const r = new Uint8Array(60);
+                r.set(frame.subarray(6, 12), 0);  // dst = requester MAC
+                r.set(frame.subarray(0, 6), 6);   // src = requester's dst MAC
+                r[12] = 0x12; r[13] = 0x34;
+                r.set(new TextEncoder().encode('ETH IRQ PONG'), 14);
+                replies.push(r);
+            }
+            return replies;
+        }
+
+        if (et === 0x0806) { // ARP: answer requests for the server IP
+            const a = 14;
+            if (frame[a] === 0 && frame[a + 1] === 1 && frame[a + 6] === 0 && frame[a + 7] === 1) {
+                const tip = [frame[a + 24], frame[a + 25], frame[a + 26], frame[a + 27]];
+                if (tip[0] === SERVER_IP[0] && tip[1] === SERVER_IP[1] && tip[2] === SERVER_IP[2] && tip[3] === SERVER_IP[3]) {
+                    const r = new Uint8Array(42);
+                    r.set(frame.subarray(6, 12), 0);  // dst = requester MAC
+                    r.set(SERVER_MAC, 6);             // src = our MAC
+                    r[12] = 0x08; r[13] = 0x06;
+                    const p = 14;
+                    r[p] = 0; r[p + 1] = 1; r[p + 2] = 0x08; r[p + 3] = 0;
+                    r[p + 4] = 6; r[p + 5] = 4;
+                    r[p + 6] = 0; r[p + 7] = 2;        // reply
+                    r.set(SERVER_MAC, p + 8);          // sha
+                    r.set(SERVER_IP, p + 14);          // spa
+                    r.set(frame.subarray(p + 8, p + 14), p + 18); // tha = requester
+                    r.set(frame.subarray(p + 14, p + 18), p + 24); // tpa
+                    replies.push(r);
+                }
+            }
+            return replies;
+        }
+
+        if (et !== 0x0800) return replies;
+        const proto = frame[23];
+        const ihl = (frame[14] & 0x0f) * 4;
+        const ipStart = 14 + ihl;
+
+        if (proto === 17) { // UDP -> DHCP
+            const sport = (frame[ipStart] << 8) | frame[ipStart + 1];
+            const dport = (frame[ipStart + 2] << 8) | frame[ipStart + 3];
+            if (sport === 68 && dport === 67) {
+                const dhcp = frame.subarray(ipStart + 8);
+                let mt = 0;
+                const opt = dhcp.subarray(240);
+                for (let o = 0; o < opt.length;) {
+                    if (opt[o] === 0xff) break;
+                    if (opt[o] === 0) { o++; continue; }
+                    if (opt[o] === 53) { mt = opt[o + 2]; break; }
+                    o += opt[o + 1] + 2;
+                }
+                clientMac = Array.from(dhcp.subarray(28, 34));
+                lastMsgType = mt;
+                if (mt === 1) { // Discover -> Offer
+                    stats.dhcpOffers++;
+                    log('DHCP Discover -> Offer (XID=0x' + ((dhcp[4] << 24) | (dhcp[5] << 16) | (dhcp[6] << 8) | dhcp[7]).toString(16).padStart(8, '0') + ')');
+                    replies.push(dhcpReply(dhcp, 2));
+                } else if (mt === 3) { // Request -> Ack
+                    stats.dhcpAcks++;
+                    log('DHCP Request -> Ack');
+                    replies.push(dhcpReply(dhcp, 5));
+                }
+            }
+            return replies;
+        }
+
+        if (proto === 6) { // TCP
+            const sport = (frame[ipStart] << 8) | frame[ipStart + 1];
+            const dport = (frame[ipStart + 2] << 8) | frame[ipStart + 3];
+            if (sport !== 0 || dport !== HTTP_PORT) {
+                // client -> server frames; learn the ephemeral port
+                if (dport === HTTP_PORT) tcpSrcPort = sport;
+                if (tcpSrcPort === 0) return replies;
+            }
+            const seq = (frame[ipStart + 4] << 24) | (frame[ipStart + 5] << 16) | (frame[ipStart + 6] << 8) | frame[ipStart + 7];
+            const fl = frame[ipStart + 13];
+            const th = ((frame[ipStart + 12] >> 4) & 0x0f) * 4;
+            const dlen = frame.length - ipStart - th;
+
+            if (fl === 0x02) { // SYN
+                clientSeq = seq;
+                stats.synAcks++;
+                log('TCP SYN -> SYN-ACK (seq=' + seq + ')');
+                replies.push(tcpFrame(0x12, srvSeq, seq + 1, null));
+            } else if ((fl & 0x18) === 0x18 && dlen > 0) { // PSH|ACK with data (HTTP GET)
+                const ack = seq + dlen;
+                log('HTTP GET (' + dlen + 'B) -> ACK + 200 response');
+                replies.push(tcpFrame(0x10, srvSeq, ack, null));
+                replies.push(tcpFrame(0x19, srvSeq, ack, new TextEncoder().encode(HTTP_BODY))); // PSH|ACK|FIN
+                stats.httpResponses++;
+            }
+            return replies;
+        }
+        return replies;
+    }
+
+    return { onTx, stats };
+}

package/site/vendor/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "stm32-periph-wasm",
+  "type": "module",
+  "version": "0.1.0",
+  "files": [
+    "stm32_periph_wasm_bg.wasm",
+    "stm32_periph_wasm.js",
+    "stm32_periph_wasm.d.ts"
+  ],
+  "main": "stm32_periph_wasm.js",
+  "types": "stm32_periph_wasm.d.ts",
+  "sideEffects": [
+    "./snippets/*"
+  ]
+}

package/site/vendor/stm32_periph_wasm.d.ts

@@ -0,0 +1,400 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * Remove a channel override, reverting it to the synthetic default.
+ */
+export function adc_clear_channel_value(peripheral: string, channel: number): void;
+
+/**
+ * Force an ADC channel's next conversion(s) to return `value` (clamped to
+ * 12-bit) instead of the synthetic temp/vref/vbat/random default. Unlike
+ * spi_tap/i2c_register_slave this can be called any time, including after
+ * init() — it's a global override table, not per-instance device wiring
+ * (see docs/components.md).
+ */
+export function adc_set_channel_value(peripheral: string, channel: number, value: number): void;
+
+export function add_i2c_eeprom(peripheral: string, address: number, data: Uint8Array): void;
+
+/**
+ * Register a software SPI device. Must be called before init().
+ */
+export function add_software_spi(name: string, cs: string | null | undefined, clk: string, miso: string, mosi: string): void;
+
+/**
+ * Add an SPI flash device. Must be called before init().
+ */
+export function add_spi_flash(peripheral: string, jedec_id: number, data: Uint8Array, cs?: string | null): void;
+
+/**
+ * Reset the audio source and capture FIFO.
+ */
+export function audio_clear(): void;
+
+/**
+ * Load a WAV file (PCM 16-bit) as the I2S/SAI sample source. DR reads then
+ * consume samples from it. Returns an error string on malformed input.
+ */
+export function audio_load_wav(bytes: Uint8Array): void;
+
+/**
+ * Remaining source samples (0 when no WAV is loaded or it is exhausted).
+ */
+export function audio_source_remaining(): number;
+
+/**
+ * Drain the I2S/SAI TX capture FIFO (all DR writes since the last call).
+ */
+export function audio_take_capture(): Uint16Array;
+
+/**
+ * Forget any fed frame (stop the camera).
+ */
+export function dcmi_clear(): void;
+
+/**
+ * Provide the next camera frame to the DCMI controller (8-bit pixels,
+ * row-major, width x height). The next CAPTURE start consumes it.
+ */
+export function dcmi_feed_frame(w: number, h: number, pixels: Uint8Array): void;
+
+export function dma_get_pending(index: number): Uint32Array;
+
+export function dma_get_pending_count(): number;
+
+/**
+ * DMA peripheral-side chunked read: read `size` bytes from peripheral
+ * `addr` (4-byte-aligned, tail chunk partial). Replaces the JS per-chunk
+ * periph_read loop (one WASM call instead of size/4).
+ */
+export function dma_periph_read(addr: number, size: number, pinc: boolean, psize: number): Uint8Array;
+
+/**
+ * DMA peripheral-side chunked write: write `bytes` to peripheral `addr` in
+ * 4-byte chunks (tail chunk partial). Replaces the JS per-chunk periph_write
+ * loop (one WASM call instead of size/4).
+ */
+export function dma_periph_write(addr: number, bytes: Uint8Array): void;
+
+export function dma_set_completed(stream_idx: number, success: boolean): void;
+
+/**
+ * Clear the RX poll flag (call after processing descriptors).
+ */
+export function eth_clear_rx_poll(): void;
+
+/**
+ * Clear the TX poll flag (call after processing descriptors).
+ */
+export function eth_clear_tx_poll(): void;
+
+/**
+ * Get the RX descriptor list address for the current poll.
+ */
+export function eth_get_rx_desc_addr(): number;
+
+/**
+ * Get the TX descriptor list address for the current poll.
+ */
+export function eth_get_tx_desc_addr(): number;
+
+/**
+ * Check if an Ethernet RX poll is pending (firmware wants to receive a packet).
+ */
+export function eth_is_rx_poll(): boolean;
+
+/**
+ * Check if an Ethernet TX poll is pending (firmware wants to send a packet).
+ */
+export function eth_is_tx_poll(): boolean;
+
+/**
+ * Signal to the peripheral that RX descriptor processing is complete.
+ * Call this after writing received data into RX buffers.
+ */
+export function eth_rx_done(): void;
+
+/**
+ * Re-arm the RX poll flag from JS (used when more packets are pending in gwRxQueue).
+ */
+export function eth_signal_rx_poll(desc_addr: number): void;
+
+/**
+ * Re-arm the TX poll flag from JS (used when more TX descriptors are pending).
+ */
+export function eth_signal_tx_poll(desc_addr: number): void;
+
+/**
+ * Signal to the peripheral that TX descriptor processing is complete.
+ * Call this after walking TX descriptors and sending the packet.
+ */
+export function eth_tx_done(): void;
+
+/**
+ * Called by the JS driver after it applied the queued erase to guest memory;
+ * clears BSY/EOP so the firmware's busy-wait can proceed.
+ */
+export function flash_erase_applied(): void;
+
+/**
+ * True when the FLASH peripheral is unlocked with PG set and !BSY — the
+ * JS driver applies program writes to guest memory when this is true.
+ */
+export function flash_is_programming(): boolean;
+
+/**
+ * Consume a completed erase request (start, len) the JS driver must apply
+ * to guest memory (all bytes 0xFF). Empty vec = nothing pending.
+ */
+export function flash_take_erase(): Uint32Array;
+
+/**
+ * Queue values the JS device answers on subsequent bank reads, oldest
+ * first. An exhausted queue reads back 0.
+ */
+export function fsmc_push_data(bank: number, values: Uint32Array): void;
+
+/**
+ * Drain all FSMC tap events for a bank since the last call (2 words per
+ * access, see `fsmc_tap`).
+ */
+export function fsmc_take_events(bank: number): Uint32Array;
+
+/**
+ * Register a protocol-agnostic tap on an FSMC memory bank (0 = BANK1, the
+ * 0x6000_0000 window). Must be called before init(): the Fsmc peripheral
+ * binds its banks' devices once at construction and never rescans.
+ *
+ * Every data-space access to the bank is queued for JS as TWO words —
+ * header then value — where the header is `1<<31 | offset` for a write and
+ * `offset` for a read. The offset matters: memory-mapped displays in
+ * 8080 mode decode an address line as RS/DC, so the address is the only
+ * thing separating a command write from a pixel write.
+ */
+export function fsmc_tap(bank: number): void;
+
+export function get_next_pending_interrupt(): number;
+
+/**
+ * Collect UART output since last call.
+ */
+export function get_uart_output(): string;
+
+export function gpio_read_input(port: number, pin: number): boolean;
+
+export function gpio_read_output(port: number, pin: number): boolean;
+
+export function gpio_set_input(port: number, pin: number, value: boolean): void;
+
+/**
+ * Check if any interrupt is pending (non-consuming).
+ */
+export function has_pending_interrupt(): boolean;
+
+/**
+ * Queue bytes the tapped I2C slave answers on master reads.
+ */
+export function i2c_push_rx(peripheral: string, bytes: Uint8Array): void;
+
+/**
+ * Read one register of the first matching regfile on a peripheral.
+ */
+export function i2c_regfile_get(peripheral: string, offset: number): number;
+
+/**
+ * Write one register of the first matching regfile on a peripheral
+ * (JS-side poke, e.g. temperature coming from outside the guest).
+ */
+export function i2c_regfile_set(peripheral: string, offset: number, value: number): void;
+
+/**
+ * Register a pointer-addressed register file (DS3231 RTC style) on an I2C
+ * peripheral. Must be called before init(). The first write byte of each
+ * transaction is the register pointer, subsequent bytes land at `ptr++`;
+ * reads return `regs[ptr++]` (pointer persists across address matches).
+ */
+export function i2c_register_regfile(peripheral: string, address: number, size: number, init: Uint8Array): void;
+
+/**
+ * Register a protocol-agnostic I2C slave on a peripheral. Must be called
+ * before init(). The address is ACKed like any other registered slave;
+ * master writes queue for JS (`i2c_take_tx`) and JS-pushed bytes are
+ * returned on master reads (`i2c_push_rx`).
+ */
+export function i2c_register_slave(peripheral: string, address: number): void;
+
+/**
+ * Drain all events for a tapped I2C slave since the last call. Each entry
+ * is a u32: bit31 = START/STOP boundary event (bit30 = 1 START / 0 STOP),
+ * otherwise the low byte is one byte the master wrote to the slave.
+ */
+export function i2c_take_events(peripheral: string): Uint32Array;
+
+/**
+ * Initialize the emulator with hardcoded peripheral map.
+ * Must be called after adding all ext devices (add_spi_flash, add_i2c_eeprom).
+ */
+export function init(): void;
+
+/**
+ * Initialize the emulator from an SVD XML string (e.g., STM32F407.svd).
+ * Must be called after adding all ext devices (add_spi_flash, add_i2c_eeprom).
+ */
+export function init_svd(svd_xml: string): void;
+
+export function is_watchdog_reset_requested(): boolean;
+
+/**
+ * Frames completed by the LTDC scanout since enable.
+ */
+export function ltdc_get_frame_count(): number;
+
+/**
+ * Current LTDC scanline (0xFFFF when the controller is disabled).
+ */
+export function ltdc_get_scanline(): number;
+
+export function periph_read(addr: number, width: number): number;
+
+export function periph_write(addr: number, width: number, value: number): void;
+
+/**
+ * Clear all process-lifetime globals so a NEW emulator instance starts
+ * clean.  Must be called before registering that instance's devices.
+ * Without it, `ExtDevices` accumulates and a second instance silently binds
+ * to the FIRST instance's devices (see system::reset_globals).
+ */
+export function reset_state(): void;
+
+/**
+ * Debug: flash state summary [wel, status1, cs_state, dummy_pending, pending_program_len]
+ */
+export function spi_flash_debug(peripheral: string): Uint32Array;
+
+/**
+ * Push bytes the JS device answers on the MISO line (read transactions).
+ */
+export function spi_push_miso(peripheral: string, bytes: Uint8Array): void;
+
+/**
+ * Drain all SPI tap events for a peripheral since the last call.
+ */
+export function spi_take_events(peripheral: string): Uint32Array;
+
+/**
+ * Register a protocol-agnostic tap on an SPI peripheral. Must be called
+ * before init(). `cs` optionally names the GPIO pin used as chip select
+ * ("PA4"); when given, CS edges are reported in the event stream. `dc`
+ * optionally names a data/command pin; its level is reported in bit 29 of
+ * each byte event (1 = data) so the JS device can parse TFT-style traffic.
+ */
+export function spi_tap(peripheral: string, cs?: string | null, dc?: string | null): void;
+
+export function tick(): void;
+
+/**
+ * Same as tick() but accounts for `delta` instructions at once. Timer
+ * peripherals are instruction-count driven, so batching ticks with a
+ * delta is semantically identical to one tick per instruction.
+ */
+export function tick_n(delta: number): void;
+
+/**
+ * Inject a received byte into the UART at the given peripheral base address.
+ * Returns true if a peripheral was found at that address.
+ */
+export function uart_rx_byte(addr: number, byte: number): boolean;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly adc_clear_channel_value: (a: number, b: number, c: number) => void;
+    readonly adc_set_channel_value: (a: number, b: number, c: number, d: number) => void;
+    readonly add_i2c_eeprom: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly add_software_spi: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
+    readonly add_spi_flash: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly audio_clear: () => void;
+    readonly audio_load_wav: (a: number, b: number) => [number, number];
+    readonly audio_source_remaining: () => number;
+    readonly audio_take_capture: () => [number, number];
+    readonly dcmi_clear: () => void;
+    readonly dcmi_feed_frame: (a: number, b: number, c: number, d: number) => void;
+    readonly dma_get_pending: (a: number) => [number, number];
+    readonly dma_get_pending_count: () => number;
+    readonly dma_periph_read: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly dma_periph_write: (a: number, b: number, c: number) => void;
+    readonly dma_set_completed: (a: number, b: number) => void;
+    readonly eth_clear_rx_poll: () => void;
+    readonly eth_clear_tx_poll: () => void;
+    readonly eth_get_rx_desc_addr: () => number;
+    readonly eth_get_tx_desc_addr: () => number;
+    readonly eth_is_rx_poll: () => number;
+    readonly eth_is_tx_poll: () => number;
+    readonly eth_rx_done: () => void;
+    readonly eth_signal_rx_poll: (a: number) => void;
+    readonly eth_signal_tx_poll: (a: number) => void;
+    readonly eth_tx_done: () => void;
+    readonly flash_erase_applied: () => void;
+    readonly flash_is_programming: () => number;
+    readonly flash_take_erase: () => [number, number];
+    readonly fsmc_push_data: (a: number, b: number, c: number) => void;
+    readonly fsmc_take_events: (a: number) => [number, number];
+    readonly fsmc_tap: (a: number) => void;
+    readonly get_next_pending_interrupt: () => number;
+    readonly get_uart_output: () => [number, number];
+    readonly gpio_read_input: (a: number, b: number) => number;
+    readonly gpio_read_output: (a: number, b: number) => number;
+    readonly gpio_set_input: (a: number, b: number, c: number) => void;
+    readonly has_pending_interrupt: () => number;
+    readonly i2c_push_rx: (a: number, b: number, c: number, d: number) => void;
+    readonly i2c_regfile_get: (a: number, b: number, c: number) => number;
+    readonly i2c_regfile_set: (a: number, b: number, c: number, d: number) => void;
+    readonly i2c_register_regfile: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly i2c_register_slave: (a: number, b: number, c: number) => void;
+    readonly i2c_take_events: (a: number, b: number) => [number, number];
+    readonly init: () => void;
+    readonly init_svd: (a: number, b: number) => void;
+    readonly is_watchdog_reset_requested: () => number;
+    readonly ltdc_get_frame_count: () => number;
+    readonly ltdc_get_scanline: () => number;
+    readonly periph_read: (a: number, b: number) => number;
+    readonly periph_write: (a: number, b: number, c: number) => void;
+    readonly reset_state: () => void;
+    readonly spi_flash_debug: (a: number, b: number) => [number, number];
+    readonly spi_push_miso: (a: number, b: number, c: number, d: number) => void;
+    readonly spi_take_events: (a: number, b: number) => [number, number];
+    readonly spi_tap: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly tick: () => void;
+    readonly tick_n: (a: number) => void;
+    readonly uart_rx_byte: (a: number, b: number) => number;
+    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_malloc: (a: number, b: number) => number;
+    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __externref_table_dealloc: (a: number) => void;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;