Updates to WASM port to support new controller structure and async functionality.

Author: johnnohj

ports/wasm/common-hal/busio/I2C.c

@@ -11,6 +11,7 @@
 #include "shared-bindings/microcontroller/Pin.h"
 #include "py/mperrno.h"
 #include "py/runtime.h"
+#include "proxy_c.h"
 #include <emscripten.h>
 #include <string.h>
 
@@ -46,6 +47,11 @@ typedef struct {
     uint8_t last_read_addr;
     uint8_t last_read_data[I2C_BUFFER_SIZE];
     uint16_t last_read_len;
+
+    // Rich path: Optional JsProxy for events (NULL if no web app listeners)
+    // When this exists, JS I2C bus object is the source of truth for transactions
+    // C code syncs to it via store_attr(), triggering automatic onChange events
+    mp_obj_jsproxy_t *js_bus;
 } i2c_bus_state_t;
 
 // Global I2C bus state array
@@ -70,6 +76,7 @@ void busio_reset_i2c_state(void) {
         i2c_buses[i].locked = false;
         i2c_buses[i].last_write_len = 0;
         i2c_buses[i].last_read_len = 0;
+        i2c_buses[i].js_bus = NULL;  // No JsProxy initially
 
         // Reset all devices on this bus
         for (int j = 0; j < 128; j++) {
@@ -79,6 +86,94 @@ void busio_reset_i2c_state(void) {
     }
 }
 
+// ========== JsProxy Integration Functions ==========
+
+// Create a JS I2C bus object and add it to the proxy system
+EM_JS(int, i2c_create_js_bus_proxy, (int bus_index), {
+    const board = Module._circuitPythonBoard;
+    if (!board || !board.i2c) {
+        console.warn('[I2C] CircuitPythonBoard or I2C controller not initialized');
+        return -1;
+    }
+
+    // Get the I2C bus object (controller creates it if it doesn't exist)
+    const bus = board.i2c.getBus(bus_index);
+
+    // Add to proxy system and return the reference
+    return proxy_js_add_obj(bus);
+});
+
+// Get current timestamp in milliseconds
+EM_JS(double, i2c_get_timestamp_ms, (void), {
+    return Date.now();
+});
+
+// Helper to sync transaction data to JS proxy
+static inline void i2c_sync_transaction_to_js(mp_obj_jsproxy_t *js_bus,
+    uint8_t addr, const uint8_t *data, size_t len, bool is_write) {
+    if (js_bus == NULL) {
+        return;
+    }
+
+    // Create transaction object as a Python dict
+    mp_obj_t transaction_dict = mp_obj_new_dict(5);
+
+    // Add type field
+    mp_obj_dict_store(transaction_dict,
+        mp_obj_new_str("type", 4),
+        mp_obj_new_str(is_write ? "write" : "read", is_write ? 5 : 4));
+
+    // Add address field
+    mp_obj_dict_store(transaction_dict,
+        mp_obj_new_str("addr", 4),
+        mp_obj_new_int(addr));
+
+    // Add data field (as bytes)
+    mp_obj_t data_bytes = mp_obj_new_bytes(data, len);
+    mp_obj_dict_store(transaction_dict,
+        mp_obj_new_str("data", 4),
+        data_bytes);
+
+    // Add length field
+    mp_obj_dict_store(transaction_dict,
+        mp_obj_new_str("length", 6),
+        mp_obj_new_int(len));
+
+    // Add timestamp field
+    double timestamp = i2c_get_timestamp_ms();
+    mp_obj_dict_store(transaction_dict,
+        mp_obj_new_str("timestamp", 9),
+        mp_obj_new_float(timestamp));
+
+    // Convert to JS and set as property on bus object
+    uint32_t value_out[PVN];
+    proxy_convert_mp_to_js_obj_cside(transaction_dict, value_out);
+    store_attr(js_bus->ref, "lastTransaction", value_out);
+}
+
+// Helper to sync device probe to JS proxy
+static inline void i2c_sync_probe_to_js(mp_obj_jsproxy_t *js_bus, uint8_t addr, bool found) {
+    if (js_bus == NULL) {
+        return;
+    }
+
+    // Create probe result object
+    mp_obj_t probe_dict = mp_obj_new_dict(2);
+
+    mp_obj_dict_store(probe_dict,
+        mp_obj_new_str("addr", 4),
+        mp_obj_new_int(addr));
+
+    mp_obj_dict_store(probe_dict,
+        mp_obj_new_str("found", 5),
+        mp_obj_new_bool(found));
+
+    // Convert to JS and set as property
+    uint32_t value_out[PVN];
+    proxy_convert_mp_to_js_obj_cside(probe_dict, value_out);
+    store_attr(js_bus->ref, "lastProbe", value_out);
+}
+
 // Find an I2C bus by pin pair, or return -1 if not found
 static int8_t find_i2c_bus(uint8_t scl_pin, uint8_t sda_pin) {
     for (int i = 0; i < MAX_I2C_BUSES; i++) {
@@ -128,6 +223,14 @@ void common_hal_busio_i2c_construct(busio_i2c_obj_t *self,
         i2c_buses[bus_idx].enabled = true;
         i2c_buses[bus_idx].locked = false;
         i2c_buses[bus_idx].never_reset = false;
+
+        // Create JsProxy for this bus if not already created
+        if (i2c_buses[bus_idx].js_bus == NULL) {
+            int jsref = i2c_create_js_bus_proxy(bus_idx);
+            if (jsref >= 0) {
+                i2c_buses[bus_idx].js_bus = mp_obj_new_jsproxy(jsref);
+            }
+        }
     }
 }
 
@@ -197,8 +300,13 @@ bool common_hal_busio_i2c_probe(busio_i2c_obj_t *self, uint8_t addr) {
         return false;
     }
 
-    // Check if device is active
-    return i2c_buses[bus_idx].devices[addr].active;
+    // Fast path: Check if device is active
+    bool found = i2c_buses[bus_idx].devices[addr].active;
+
+    // Rich path: Sync probe result to JsProxy (triggers automatic probe events)
+    i2c_sync_probe_to_js(i2c_buses[bus_idx].js_bus, addr, found);
+
+    return found;
 }
 
 uint8_t common_hal_busio_i2c_write(busio_i2c_obj_t *self, uint16_t address,
@@ -223,7 +331,7 @@ uint8_t common_hal_busio_i2c_write(busio_i2c_obj_t *self, uint16_t address,
         len = I2C_BUFFER_SIZE;
     }
 
-    // Store last write for JavaScript access
+    // Fast path: Store last write for JavaScript access
     i2c_buses[bus_idx].last_write_addr = address;
     memcpy(i2c_buses[bus_idx].last_write_data, data, len);
     i2c_buses[bus_idx].last_write_len = len;
@@ -235,6 +343,9 @@ uint8_t common_hal_busio_i2c_write(busio_i2c_obj_t *self, uint16_t address,
                &data[1], len - 1);
     }
 
+    // Rich path: Sync to JsProxy (triggers automatic transaction events)
+    i2c_sync_transaction_to_js(i2c_buses[bus_idx].js_bus, address, data, len, true);
+
     return 0;  // Success
 }
 
@@ -260,14 +371,17 @@ uint8_t common_hal_busio_i2c_read(busio_i2c_obj_t *self, uint16_t address,
         len = I2C_BUFFER_SIZE;
     }
 
-    // Read from device registers (starting from register 0)
+    // Fast path: Read from device registers (starting from register 0)
     memcpy(data, i2c_buses[bus_idx].devices[address].registers, len);
 
     // Store last read for JavaScript access
     i2c_buses[bus_idx].last_read_addr = address;
     memcpy(i2c_buses[bus_idx].last_read_data, data, len);
     i2c_buses[bus_idx].last_read_len = len;
 
+    // Rich path: Sync to JsProxy (triggers automatic transaction events)
+    i2c_sync_transaction_to_js(i2c_buses[bus_idx].js_bus, address, data, len, false);
+
     return 0;  // Success
 }
 
@@ -296,7 +410,7 @@ uint8_t common_hal_busio_i2c_write_read(busio_i2c_obj_t *self, uint16_t address,
         in_len = I2C_BUFFER_SIZE;
     }
 
-    // Read from specified register
+    // Fast path: Read from specified register
     memcpy(in_data, &i2c_buses[bus_idx].devices[address].registers[reg_addr], in_len);
 
     // Store transaction info
@@ -310,6 +424,14 @@ uint8_t common_hal_busio_i2c_write_read(busio_i2c_obj_t *self, uint16_t address,
     memcpy(i2c_buses[bus_idx].last_read_data, in_data, in_len);
     i2c_buses[bus_idx].last_read_len = in_len;
 
+    // Rich path: Sync write and read to JsProxy (triggers automatic transaction events)
+    // First sync the write part (register address)
+    if (out_len > 0) {
+        i2c_sync_transaction_to_js(i2c_buses[bus_idx].js_bus, address, out_data, out_len, true);
+    }
+    // Then sync the read part (data read from register)
+    i2c_sync_transaction_to_js(i2c_buses[bus_idx].js_bus, address, in_data, in_len, false);
+
     return 0;  // Success
 }
 

ports/wasm/common-hal/busio/SPI.c

@@ -11,6 +11,7 @@
 #include "shared-bindings/microcontroller/Pin.h"
 #include "py/mperrno.h"
 #include "py/runtime.h"
+#include "proxy_c.h"
 #include <emscripten.h>
 #include <string.h>
 
@@ -36,6 +37,11 @@ typedef struct {
     uint8_t last_read_data[SPI_BUFFER_SIZE];
     uint16_t last_write_len;
     uint16_t last_read_len;
+
+    // Rich path: Optional JsProxy for events (NULL if no web app listeners)
+    // When this exists, JS SPI bus object is the source of truth for transactions
+    // C code syncs to it via store_attr(), triggering automatic onChange events
+    mp_obj_jsproxy_t *js_spi;
 } spi_bus_state_t;
 
 // State array for up to 4 SPI buses
@@ -80,9 +86,83 @@ void busio_reset_spi_state(void) {
         spi_buses[i].half_duplex = false;
         spi_buses[i].last_write_len = 0;
         spi_buses[i].last_read_len = 0;
+        spi_buses[i].js_spi = NULL;  // No JsProxy initially
     }
 }
 
+// ========== JsProxy Integration Functions ==========
+
+// Create a JS SPI bus object and add it to the proxy system
+EM_JS(int, spi_create_js_bus_proxy, (int bus_index), {
+    const board = Module._circuitPythonBoard;
+    if (!board || !board.spi) {
+        console.warn('[SPI] CircuitPythonBoard or SPI controller not initialized');
+        return -1;
+    }
+
+    // Get the SPI bus object (controller creates it if it doesn't exist)
+    const bus = board.spi.getBus(bus_index);
+
+    // Add to proxy system and return the reference
+    return proxy_js_add_obj(bus);
+});
+
+// Get current timestamp in milliseconds
+EM_JS(double, spi_get_timestamp_ms, (void), {
+    return Date.now();
+});
+
+// Helper to sync transaction data to JS proxy
+static inline void spi_sync_transaction_to_js(mp_obj_jsproxy_t *js_spi,
+    const uint8_t *write_data, size_t write_len,
+    const uint8_t *read_data, size_t read_len,
+    const char *type) {
+    if (js_spi == NULL) {
+        return;
+    }
+
+    // Create transaction object as a Python dict
+    mp_obj_t transaction_dict = mp_obj_new_dict(5);
+
+    // Add type field ("write", "read", or "transfer")
+    mp_obj_dict_store(transaction_dict,
+        mp_obj_new_str("type", 4),
+        mp_obj_new_str(type, strlen(type)));
+
+    // Add write data if present
+    if (write_data != NULL && write_len > 0) {
+        mp_obj_t write_bytes = mp_obj_new_bytes(write_data, write_len);
+        mp_obj_dict_store(transaction_dict,
+            mp_obj_new_str("writeData", 9),
+            write_bytes);
+        mp_obj_dict_store(transaction_dict,
+            mp_obj_new_str("writeLen", 8),
+            mp_obj_new_int(write_len));
+    }
+
+    // Add read data if present
+    if (read_data != NULL && read_len > 0) {
+        mp_obj_t read_bytes = mp_obj_new_bytes(read_data, read_len);
+        mp_obj_dict_store(transaction_dict,
+            mp_obj_new_str("readData", 8),
+            read_bytes);
+        mp_obj_dict_store(transaction_dict,
+            mp_obj_new_str("readLen", 7),
+            mp_obj_new_int(read_len));
+    }
+
+    // Add timestamp field
+    double timestamp = spi_get_timestamp_ms();
+    mp_obj_dict_store(transaction_dict,
+        mp_obj_new_str("timestamp", 9),
+        mp_obj_new_float(timestamp));
+
+    // Convert to JS and set as property on bus object
+    uint32_t value_out[PVN];
+    proxy_convert_mp_to_js_obj_cside(transaction_dict, value_out);
+    store_attr(js_spi->ref, "lastTransaction", value_out);
+}
+
 void common_hal_busio_spi_construct(busio_spi_obj_t *self,
     const mcu_pin_obj_t *clock, const mcu_pin_obj_t *mosi,
     const mcu_pin_obj_t *miso, bool half_duplex) {
@@ -133,6 +213,14 @@ void common_hal_busio_spi_construct(busio_spi_obj_t *self,
         spi_buses[bus_idx].locked = false;
         spi_buses[bus_idx].never_reset = false;
         spi_buses[bus_idx].half_duplex = half_duplex;
+
+        // Create JsProxy for this bus if not already created
+        if (spi_buses[bus_idx].js_spi == NULL) {
+            int jsref = spi_create_js_bus_proxy(bus_idx);
+            if (jsref >= 0) {
+                spi_buses[bus_idx].js_spi = mp_obj_new_jsproxy(jsref);
+            }
+        }
     }
 
     // Store configuration in object
@@ -258,11 +346,14 @@ bool common_hal_busio_spi_write(busio_spi_obj_t *self, const uint8_t *data, size
         return false;
     }
 
-    // Store write data for JavaScript access (up to buffer size)
+    // Fast path: Store write data for JavaScript access (up to buffer size)
     size_t copy_len = (len > SPI_BUFFER_SIZE) ? SPI_BUFFER_SIZE : len;
     memcpy(spi_buses[bus_idx].last_write_data, data, copy_len);
     spi_buses[bus_idx].last_write_len = copy_len;
 
+    // Rich path: Sync to JsProxy (triggers automatic transaction events)
+    spi_sync_transaction_to_js(spi_buses[bus_idx].js_spi, data, copy_len, NULL, 0, "write");
+
     return true;
 }
 
@@ -280,12 +371,15 @@ bool common_hal_busio_spi_read(busio_spi_obj_t *self, uint8_t *data, size_t len,
         return false;
     }
 
-    // For WASM simulation, JavaScript can write to last_read_data
+    // Fast path: For WASM simulation, JavaScript can write to last_read_data
     // to simulate peripheral responses
     size_t copy_len = (len > SPI_BUFFER_SIZE) ? SPI_BUFFER_SIZE : len;
     memcpy(data, spi_buses[bus_idx].last_read_data, copy_len);
     spi_buses[bus_idx].last_read_len = copy_len;
 
+    // Rich path: Sync to JsProxy (triggers automatic transaction events)
+    spi_sync_transaction_to_js(spi_buses[bus_idx].js_spi, NULL, 0, data, copy_len, "read");
+
     return true;
 }
 
@@ -303,13 +397,16 @@ bool common_hal_busio_spi_transfer(busio_spi_obj_t *self, const uint8_t *data_ou
         return false;
     }
 
-    // Store write data and read simulated response
+    // Fast path: Store write data and read simulated response
     size_t copy_len = (len > SPI_BUFFER_SIZE) ? SPI_BUFFER_SIZE : len;
     memcpy(spi_buses[bus_idx].last_write_data, data_out, copy_len);
     memcpy(data_in, spi_buses[bus_idx].last_read_data, copy_len);
     spi_buses[bus_idx].last_write_len = copy_len;
     spi_buses[bus_idx].last_read_len = copy_len;
 
+    // Rich path: Sync to JsProxy (triggers automatic transaction events)
+    spi_sync_transaction_to_js(spi_buses[bus_idx].js_spi, data_out, copy_len, data_in, copy_len, "transfer");
+
     return true;
 }