IoT Domain

Layer 3: Domain Constraints

Domain Constraints → Design Implications

Domain Rule Design Constraint Rust Implication

Unreliable network Offline-first Local buffering

Power constraints Efficient code Sleep modes, minimal alloc

Resource limits Small footprint no_std where needed

Security Encrypted comms TLS, signed firmware

Reliability Self-recovery Watchdog, error handling

OTA updates Safe upgrades Rollback capability

Critical Constraints

Network Unreliability

RULE: Network can fail at any time WHY: Wireless, remote locations RUST: Local queue, retry with backoff

Power Management

RULE: Minimize power consumption WHY: Battery life, energy costs RUST: Sleep modes, efficient algorithms

Device Security

RULE: All communication encrypted WHY: Physical access possible RUST: TLS, signed messages

Trace Down ↓

From constraints to design (Layer 2):

"Need offline-first design" ↓ m12-lifecycle: Local buffer with persistence ↓ m13-domain-error: Retry with backoff

"Need power efficiency" ↓ domain-embedded: no_std patterns ↓ m10-performance: Minimal allocations

"Need reliable messaging" ↓ m07-concurrency: Async with timeout ↓ MQTT: QoS levels

Environment Comparison

Environment Stack Crates

Linux gateway tokio + std rumqttc, reqwest

MCU device embassy + no_std embedded-hal

Hybrid Split workloads Both

Key Crates

Purpose Crate

MQTT (std) rumqttc, paho-mqtt

Embedded embedded-hal, embassy

Async (std) tokio

Async (no_std) embassy

Logging (no_std) defmt

Logging (std) tracing

Design Patterns

Pattern Purpose Implementation

Pub/Sub Device comms MQTT topics

Edge compute Local processing Filter before upload

OTA updates Firmware upgrade Signed + rollback

Power mgmt Battery life Sleep + wake events

Store & forward Network reliability Local queue

Code Pattern: MQTT Client

use rumqttc::{AsyncClient, MqttOptions, QoS};

async fn run_mqtt() -> anyhow::Result<()> { let mut options = MqttOptions::new("device-1", "broker.example.com", 1883); options.set_keep_alive(Duration::from_secs(30));

let (client, mut eventloop) = AsyncClient::new(options, 10);

// Subscribe to commands
client.subscribe("devices/device-1/commands", QoS::AtLeastOnce).await?;

// Publish telemetry
tokio::spawn(async move {
    loop {
        let data = read_sensor().await;
        client.publish("devices/device-1/telemetry", QoS::AtLeastOnce, false, data).await.ok();
        tokio::time::sleep(Duration::from_secs(60)).await;
    }
});

// Process events
loop {
    match eventloop.poll().await {
        Ok(event) => handle_event(event).await,
        Err(e) => {
            tracing::error!("MQTT error: {}", e);
            tokio::time::sleep(Duration::from_secs(5)).await;
        }
    }
}

}

Common Mistakes

Mistake Domain Violation Fix

No retry logic Lost data Exponential backoff

Always-on radio Battery drain Sleep between sends

Unencrypted MQTT Security risk TLS

No local buffer Network outage = data loss Persist locally

Trace to Layer 1

Constraint Layer 2 Pattern Layer 1 Implementation

Offline-first Store & forward Local queue + flush

Power efficiency Sleep patterns Timer-based wake

Network reliability Retry tokio-retry, backoff

Security TLS rustls, native-tls

Related Skills

When See

Embedded patterns domain-embedded

Async patterns m07-concurrency

Error recovery m13-domain-error

Performance m10-performance