Initial: WIT sensor contract and addressing scheme

README.md

@@ -0,0 +1,22 @@
+# Synapse Agriculture — Specifications
+
+Public specifications and contracts for the Synapse farm infrastructure platform.
+
+## Contents
+
+- `sensor.wit` — WebAssembly Interface Types definition for the sensor module API. This is the immortal contract between MCU sensor firmware (WASM), field gateways, Houston services, and the browser frontend.
+
+## Addressing Scheme
+
+Synapse uses a numeric addressing scheme: `{realm}.{layer}.{sublayer}.{instance}`
+
+- Realm 0: Meta (protocols, contracts)
+- Realm 1: Farm (Build a Farm layers 0-10, field assets)
+- Realm 2: Governance (Board personas, decision-making)
+- Realm 3: Infrastructure (services, databases, proxies)
+
+Alternate namespace: B (Board), S (Service), F (Field), P (Protocol)
+
+## License
+
+AGPL-3.0-or-later

sensor.wit

@@ -0,0 +1,197 @@
+// Synapse Agriculture — Sensor Module Interface
+// This WIT definition is the IMMORTAL CONTRACT between:
+//   - Guest: sensor WASM modules (runs on MCU/gateway/host)
+//   - Host:  wasm3 (MCU), wasmtime (gateway/host), browser VM
+//
+// Adding a new sensor type = add to this file, regen bindings,
+// type-check catches every integration point at compile time.
+//
+// Changing this file is a BREAKING CHANGE across the entire stack.
+// Treat it like a database migration — versioned, reviewed, irreversible.
+
+package synapse:sensor@0.1.0;
+
+/// Types shared across all sensor modules and host runtimes.
+/// These compile into synapse-core and are used everywhere.
+interface types {
+    /// Sensor reading with metadata for provenance tracking
+    record reading {
+        /// Unix timestamp in milliseconds (from host clock or RTC)
+        timestamp-ms: u64,
+        /// Sensor channel identifier (maps to physical probe)
+        channel: u8,
+        /// Raw ADC or digital value before calibration
+        raw-value: s32,
+        /// Calibrated value as fixed-point (value * 1000)
+        /// Using s32 instead of f32 because wasm3 soft-float
+        /// on Cortex-M is slow and we don't need the precision
+        calibrated-value: s32,
+        /// Unit of measurement after calibration
+        unit: measurement-unit,
+        /// Quality/confidence flag from self-diagnostics
+        quality: reading-quality,
+    }
+
+    /// Fixed-point calibration coefficients for linear cal:
+    ///   calibrated = (raw * slope / 1000) + (offset / 1000)
+    /// Two-point cal: derive slope/offset from known standards
+    record calibration {
+        slope: s32,     // multiplied by 1000
+        offset: s32,    // multiplied by 1000
+    }
+
+    /// What physical quantity this reading represents
+    enum measurement-unit {
+        /// Water chemistry
+        ph,               // pH units (0-14)
+        ec,               // electrical conductivity, µS/cm
+        dissolved-oxygen,  // mg/L
+        orp,              // mV
+        temperature-water, // °C * 1000
+
+        /// Soil
+        moisture-vwc,     // volumetric water content, % * 1000
+        temperature-soil, // °C * 1000
+
+        /// Atmosphere
+        temperature-air,  // °C * 1000
+        humidity,         // % * 1000
+        pressure,         // hPa * 1000
+        light-lux,        // lux
+        light-par,        // µmol/m²/s (photosynthetically active)
+
+        /// Power (Layer 7)
+        voltage,          // mV
+        current,          // mA
+        power,            // mW
+        battery-soc,      // state of charge, % * 10
+    }
+
+    /// Self-diagnostic quality assessment
+    enum reading-quality {
+        good,
+        degraded,     // reading taken but outside expected range
+        cal-needed,   // calibration overdue or drift detected
+        fault,        // sensor not responding or shorted
+    }
+
+    /// Configuration pushed from gateway to node
+    record sensor-config {
+        /// Sampling interval in seconds
+        sample-interval-secs: u32,
+        /// Which channels to read (bitmask, up to 8 channels)
+        active-channels: u8,
+        /// Per-channel calibration (indexed by channel number)
+        calibrations: list<calibration>,
+    }
+
+    /// Compact transmission payload for LoRa
+    /// Designed to fit in a single LoRa packet (<= 242 bytes at SF7)
+    record transmission-payload {
+        /// Node identifier (unique per site)
+        node-id: u16,
+        /// Sequence number for dedup and gap detection
+        sequence: u16,
+        /// Battery voltage in mV (for power monitoring)
+        battery-mv: u16,
+        /// All readings from this sample cycle
+        readings: list<reading>,
+    }
+}
+
+/// Host functions provided TO the sensor module BY the runtime.
+/// The MCU firmware implements these against real hardware.
+/// The test harness implements them as mocks.
+/// The browser implements them as no-ops or simulations.
+interface host {
+    use types.{reading, calibration};
+
+    /// Read raw value from I2C sensor
+    /// address: 7-bit I2C device address (e.g., 0x63 for Atlas pH)
+    /// register: register to read from
+    /// length: bytes to read (max 32)
+    /// Returns: raw bytes from device, or error
+    read-i2c: func(address: u8, register: u8, length: u8) -> result<list<u8>, sensor-error>;
+
+    /// Read ADC channel (for analog sensors)
+    /// channel: ADC channel number (0-7 on RP2350)
+    /// Returns: raw 12-bit ADC value (0-4095)
+    read-adc: func(channel: u8) -> result<u16, sensor-error>;
+
+    /// Get current timestamp from RTC or host clock
+    get-timestamp-ms: func() -> u64;
+
+    /// Queue a LoRa transmission
+    /// payload: CBOR-encoded bytes to transmit
+    /// Returns: number of bytes queued, or error
+    transmit: func(payload: list<u8>) -> result<u32, sensor-error>;
+
+    /// Enter low-power sleep for specified duration
+    /// The WASM module yields execution here; host handles
+    /// actual MCU sleep modes (DORMANT on RP2350)
+    sleep-ms: func(duration-ms: u32);
+
+    /// Log a diagnostic message (forwarded to gateway if possible)
+    /// Compiled out / no-op on MCU builds via feature flag
+    log: func(level: log-level, message: string);
+
+    enum sensor-error {
+        /// Device not responding on bus
+        not-found,
+        /// Bus arbitration failure
+        bus-error,
+        /// Device returned NAK
+        nak,
+        /// Read timed out
+        timeout,
+        /// Transmission queue full
+        queue-full,
+        /// Generic / unclassified
+        other,
+    }
+
+    enum log-level {
+        debug,
+        info,
+        warn,
+        error,
+    }
+}
+
+/// The interface that every sensor module MUST implement.
+/// This is the guest-side contract — the "main" of the module.
+interface guest {
+    use types.{reading, sensor-config, transmission-payload};
+
+    /// Called once at boot. Host passes stored config.
+    /// Module initializes internal state, validates config.
+    /// Returns: true if init succeeded, false to signal fault.
+    init: func(config: sensor-config) -> bool;
+
+    /// Called each sample cycle by the host's main loop.
+    /// Module reads sensors (via host.read-i2c / host.read-adc),
+    /// applies calibration, builds readings list.
+    /// Returns: payload ready for LoRa transmission.
+    sample: func() -> transmission-payload;
+
+    /// Called when gateway pushes new config (e.g., new cal values).
+    /// Module validates and applies, returns success/failure.
+    reconfigure: func(config: sensor-config) -> bool;
+
+    /// Self-diagnostic. Module checks sensor responsiveness,
+    /// validates readings against expected ranges, reports health.
+    /// Returns: list of (channel, quality) pairs.
+    diagnose: func() -> list<tuple<u8, reading-quality>>;
+
+    use host.{sensor-error};
+
+    /// Redeclare quality enum access for diagnose return
+    use types.{reading-quality};
+}
+
+/// The complete world — wires guest to host.
+/// cargo-component uses this to generate the full bindings.
+world sensor-node {
+    import host;
+    export guest;
+}