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 |
1---2name: domain-iot3description: Use when building IoT apps. Keywords: IoT, Internet of Things, sensor, MQTT, device, edge computing, telemetry, actuator, smart home, gateway, protocol, 物联网, 传感器, 边缘计算, 智能家居4---5
6# IoT Domain
7
8> **Layer 3: Domain Constraints**
9
10## Domain Constraints → Design Implications
11
12| Domain Rule | Design Constraint | Rust Implication |
13|-------------|-------------------|------------------|
14| Unreliable network | Offline-first | Local buffering |
15| Power constraints | Efficient code | Sleep modes, minimal alloc |
16| Resource limits | Small footprint | no_std where needed |
17| Security | Encrypted comms | TLS, signed firmware |
18| Reliability | Self-recovery | Watchdog, error handling |
19| OTA updates | Safe upgrades | Rollback capability |
20
21---
22
23## Critical Constraints
24
25### Network Unreliability
26
27```
28RULE: Network can fail at any time
29WHY: Wireless, remote locations
30RUST: Local queue, retry with backoff
31```
32
33### Power Management
34
35```
36RULE: Minimize power consumption
37WHY: Battery life, energy costs
38RUST: Sleep modes, efficient algorithms
39```
40
41### Device Security
42
43```
44RULE: All communication encrypted
45WHY: Physical access possible
46RUST: TLS, signed messages
47```
48
49---
50
51## Trace Down ↓
52
53From constraints to design (Layer 2):
54
55```
56"Need offline-first design"
57 ↓ m12-lifecycle: Local buffer with persistence
58 ↓ m13-domain-error: Retry with backoff
59
60"Need power efficiency"
61 ↓ domain-embedded: no_std patterns
62 ↓ m10-performance: Minimal allocations
63
64"Need reliable messaging"
65 ↓ m07-concurrency: Async with timeout
66 ↓ MQTT: QoS levels
67```
68
69---
70
71## Environment Comparison
72
73| Environment | Stack | Crates |
74|-------------|-------|--------|
75| Linux gateway | tokio + std | rumqttc, reqwest |
76| MCU device | embassy + no_std | embedded-hal |
77| Hybrid | Split workloads | Both |
78
79## Key Crates
80
81| Purpose | Crate |
82|---------|-------|
83| MQTT (std) | rumqttc, paho-mqtt |
84| Embedded | embedded-hal, embassy |
85| Async (std) | tokio |
86| Async (no_std) | embassy |
87| Logging (no_std) | defmt |
88| Logging (std) | tracing |
89
90## Design Patterns
91
92| Pattern | Purpose | Implementation |
93|---------|---------|----------------|
94| Pub/Sub | Device comms | MQTT topics |
95| Edge compute | Local processing | Filter before upload |
96| OTA updates | Firmware upgrade | Signed + rollback |
97| Power mgmt | Battery life | Sleep + wake events |
98| Store & forward | Network reliability | Local queue |
99
100## Code Pattern: MQTT Client
101
102```rust
103use rumqttc::{AsyncClient, MqttOptions, QoS};
104
105async fn run_mqtt() -> anyhow::Result<()> {
106 let mut options = MqttOptions::new("device-1", "broker.example.com", 1883);
107 options.set_keep_alive(Duration::from_secs(30));
108
109 let (client, mut eventloop) = AsyncClient::new(options, 10);
110
111 // Subscribe to commands
112 client.subscribe("devices/device-1/commands", QoS::AtLeastOnce).await?;
113
114 // Publish telemetry
115 tokio::spawn(async move {
116 loop {
117 let data = read_sensor().await;
118 client.publish("devices/device-1/telemetry", QoS::AtLeastOnce, false, data).await.ok();
119 tokio::time::sleep(Duration::from_secs(60)).await;
120 }
121 });
122
123 // Process events
124 loop {
125 match eventloop.poll().await {
126 Ok(event) => handle_event(event).await,
127 Err(e) => {
128 tracing::error!("MQTT error: {}", e);
129 tokio::time::sleep(Duration::from_secs(5)).await;
130 }
131 }
132 }
133}
134```
135
136---
137
138## Common Mistakes
139
140| Mistake | Domain Violation | Fix |
141|---------|-----------------|-----|
142| No retry logic | Lost data | Exponential backoff |
143| Always-on radio | Battery drain | Sleep between sends |
144| Unencrypted MQTT | Security risk | TLS |
145| No local buffer | Network outage = data loss | Persist locally |
146
147---
148
149## Trace to Layer 1
150
151| Constraint | Layer 2 Pattern | Layer 1 Implementation |
152|------------|-----------------|------------------------|
153| Offline-first | Store & forward | Local queue + flush |
154| Power efficiency | Sleep patterns | Timer-based wake |
155| Network reliability | Retry | tokio-retry, backoff |
156| Security | TLS | rustls, native-tls |
157
158---
159
160## Related Skills
161
162| When | See |
163|------|-----|
164| Embedded patterns | domain-embedded |
165| Async patterns | m07-concurrency |
166| Error recovery | m13-domain-error |
167| Performance | m10-performance |
majiayu000