Domain Iot

by actionbook5c40d3ad7851No license1.5K starsListed Oct 8, 2026Updated Oct 8, 2026Repository updated 6 weeks ago

Use when building IoT apps. Keywords: IoT, Internet of Things, sensor, MQTT, device, edge computing, telemetry, actuator, smart home, gateway, protocol, 物联网, 传感器, 边缘计算, 智能家居

Instructions onlySoftware Development

AI-generated overview

Reference guidance for building IoT applications in Rust, covering MQTT, edge, power, security and OTA constraints.

What it does: This skill supplies domain constraints and design guidance for IoT software, mapping rules such as unreliable networks, power limits, resource limits and device security to Rust design implications. It lists environment stacks and crates for Linux gateways, MCU devices and hybrid setups, plus design patterns like pub/sub, edge compute, OTA updates and store-and-forward. It also includes an MQTT client code pattern and tables of common mistakes and related skills.
When to use it: Use it when designing or implementing IoT applications, especially in Rust, where offline-first behavior, power efficiency, encrypted communication or firmware updates matter. It is also relevant when choosing between std and no_std stacks or MQTT crates for gateway and embedded targets.
Requirements: No scripts or bundled assets; it is an instructions-only document. Applying its examples assumes a Rust toolchain and crates such as rumqttc, tokio, embassy or embedded-hal, and network access to an MQTT broker for the sample client.

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 timeWHY: Wireless, remote locationsRUST: Local queue, retry with backoff

RULE: Network can fail at any timeWHY: Wireless, remote locationsRUST: Local queue, retry with backoff

Power Management

RULE: Minimize power consumptionWHY: Battery life, energy costsRUST: Sleep modes, efficient algorithms

RULE: Minimize power consumptionWHY: Battery life, energy costsRUST: Sleep modes, efficient algorithms

Device Security

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

"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

Key Crates

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

rust

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;            }        }    }}

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

Source and attribution

Source:actionbook/rust-skillsinskills/domain-iotat commit5c40d3a

License: No license

Content belongs to its original authors. SourceWeft indexes it from a public repository.

Report or request removal

Environment	Stack	Crates
Linux gateway	tokio + std	rumqttc, reqwest
MCU device	embassy + no_std	embedded-hal
Hybrid	Split workloads	Both

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

Domain Iot

IoT Domain

Domain Constraints → Design Implications

Critical Constraints

Network Unreliability

Power Management

Device Security

Trace Down ↓

Environment Comparison

Key Crates

Design Patterns

Code Pattern: MQTT Client

Common Mistakes

Trace to Layer 1

Related Skills

Source and attribution

More from actionbook/rust-skills

Rust Trait Explorer

Rust Symbol Analyzer

Rust Skill Creator

Rust Router

Rust Refactor Helper

Rust Daily

More in Software Development

Playground

M5 Onboard

Cardputer Buddy

Web Design Guidelines

Vercel React Native Skills

Vercel React Best Practices

When	See
Embedded patterns	domain-embedded
Async patterns	m07-concurrency
Error recovery	m13-domain-error
Performance	m10-performance