AIngle Minimal - Ultra-Light IoT Node

Complete IoT-ready implementation of AIngle for resource-constrained devices

Overview

AIngle Minimal is an ultra-lightweight node implementation designed for IoT devices with strict resource constraints (<1MB RAM, <5MB storage). It provides enterprise-grade features while maintaining minimal footprint.

Key Features

• Ultra-Light Footprint: Target <512KB RAM, optimized for embedded systems
• CoAP Transport: RFC 7252-compliant UDP protocol for constrained networks
• DTLS Security: Optional encryption with PSK or certificate-based auth
• Smart Discovery: Both mDNS and CoAP multicast peer discovery
• Sensor Abstraction: Unified interface for all sensor types
• Power Management: Adaptive battery-aware power profiles
• OTA Updates: Secure over-the-air firmware updates with rollback
• Mesh Ready: Support for WiFi Direct, BLE, LoRa (coming soon)

Quick Start

Installation

Add to your Cargo.toml:

[dependencies]
aingle_minimal = { version = "0.1", features = ["coap", "sqlite"] }

Basic Usage

use aingle_minimal::{MinimalNode, Config};

#[smol::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create IoT-optimized node
    let config = Config::iot_mode();
    let mut node = MinimalNode::new(config)?;

    // Run the node
    node.run().await?;
    Ok(())
}

Complete IoT Device Example

use aingle_minimal::*;
use std::time::Duration;

#[smol::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 1. Initialize Power Manager
    let mut power_manager = PowerManager::new();
    power_manager.update_battery(BatteryInfo::with_level(85.0));
    power_manager.set_auto_adjust(true); // Auto-adjust based on battery

    // 2. Setup Sensors
    let mut sensor_manager = SensorManager::new();
    sensor_manager.register(Box::new(sensors::MockSensor::new(
        SensorType::Temperature
    )));
    sensor_manager.register(Box::new(sensors::MockSensor::new(
        SensorType::Humidity
    )));

    // 3. Configure OTA Updates
    let mut ota = OtaManager::new("1.0.0".to_string(), "device-001".to_string());
    ota.set_update_server("https://updates.myiot.com".to_string());
    ota.set_channel(UpdateChannel::Stable);
    ota.set_auto_download(true);

    // 4. Setup Secure CoAP Server
    let dtls_config = DtlsConfig::psk(
        b"my-pre-shared-key-32-bytes-long!".to_vec(),
        "device-001@mycompany".to_string(),
    );
    let mut coap_server = SecureCoap::new(
        "0.0.0.0".to_string(),
        5684, // CoAP over DTLS
        "device-001".to_string(),
        Some(dtls_config),
    )?;
    coap_server.start().await?;

    // 5. Main IoT Loop
    loop {
        // Read sensors
        let readings = sensor_manager.read_all();
        for reading in readings {
            if let Ok(r) = reading {
                println!("{}: {:.2} {}",
                    r.sensor_type.name(), r.value, r.unit);
            }
        }

        // Check battery and adjust power
        if let Some(level) = power_manager.get_battery_level() {
            println!("Battery: {:.1}%", level);

            if level < 10.0 {
                // Critical battery - enter deep sleep
                let sleep_config = power::SleepConfig::deep_sleep(
                    Duration::from_secs(300) // 5 minutes
                );
                power_manager.enter_sleep_mode(sleep_config)?;
            }
        }

        // Check for OTA updates (once per day)
        if let Some(update) = ota.check_for_updates().await? {
            println!("Update available: {} -> {}",
                ota.current_version(), update.version);

            if ota.config().auto_download {
                println!("Downloading update...");
                let firmware = ota.download_update(&update).await?;

                println!("Applying update...");
                ota.apply_update(&firmware)?;

                // In production, device would reboot here
                println!("Update complete! Now running {}",
                    ota.current_version());
            }
        }

        // Sleep based on power profile
        let profile = power_manager.get_power_profile();
        smol::Timer::after(profile.sensor_sampling_interval()).await;
    }
}

Feature Documentation

1. DTLS Security

Secure your CoAP communications with DTLS:

use aingle_minimal::*;

// PSK (Pre-Shared Key) - Recommended for IoT
let dtls_config = DtlsConfig::psk(
    dtls::psk::generate_psk(32),
    dtls::psk::create_identity("sensor-42", "acme-corp"),
);

// Or derive from passphrase
let psk = dtls::psk::derive_psk_from_passphrase(
    "my-secret-passphrase",
    b"unique-device-salt",
    10000 // iterations
);

// Create secure server
let mut server = SecureCoap::new(
    "0.0.0.0".to_string(),
    5684,
    "my-device".to_string(),
    Some(dtls_config),
)?;

server.start().await?;
println!("Secure CoAP running on port 5684");

2. Sensor Management

Unified interface for all sensor types:

use aingle_minimal::sensors::*;

// Create sensor manager
let mut manager = SensorManager::new();

// Register sensors
manager.register(Box::new(MockSensor::new(SensorType::Temperature)));
manager.register(Box::new(MockSensor::new(SensorType::Humidity)));
manager.register(Box::new(MockSensor::new(SensorType::Pressure)));

// Read all sensors
for reading in manager.read_all() {
    if let Ok(r) = reading {
        println!("{}: {:.2}{} (quality: {:.0}%)",
            r.sensor_type.name(),
            r.value,
            r.unit,
            r.quality * 100.0
        );
    }
}

// Calibrate a sensor
let mut sensor = MockSensor::new(SensorType::Temperature);
sensor.calibrate(CalibrationParams {
    offset: 2.5,  // Add 2.5°C
    scale: 1.0,
    reference: Some(20.0),
    calibrated_at: chrono::Utc::now().timestamp() as u64,
})?;

3. Power Management

Battery-aware adaptive power profiles:

use aingle_minimal::power::*;

let mut pm = PowerManager::new();

// Update battery status
pm.update_battery(BatteryInfo::with_level(45.0));

// Auto-adjust profile based on battery
pm.set_auto_adjust(true);

// Or manually set profile
pm.set_power_profile(PowerProfile::LowPower);

// Check recommended actions
if pm.should_enter_low_power() {
    println!("Battery low! Switching to low power mode");
}

// Estimate time to empty
if let Some(minutes) = pm.estimate_time_to_empty() {
    println!("Battery will last ~{} minutes", minutes);
}

// Enter sleep mode
let sleep_config = SleepConfig::new(Duration::from_secs(60));
pm.enter_sleep_mode(sleep_config)?;

// Get power statistics
let stats = pm.get_stats();
println!("Uptime: {}s, Sleep: {:.1}%",
    stats.uptime_secs, stats.sleep_percentage());

4. OTA Updates

Secure firmware updates over the network:

use aingle_minimal::ota::*;

let mut ota = OtaManager::new(
    "1.0.0".to_string(),
    "device-001".to_string()
);

// Configure update server
ota.set_update_server("https://ota.example.com".to_string());
ota.set_channel(UpdateChannel::Stable);

// Check for updates
if let Some(update) = ota.check_for_updates().await? {
    println!("New version available: {}", update.version);
    println!("Size: {} bytes", update.size);
    println!("Critical: {}", update.critical);

    // Download firmware
    let firmware = ota.download_update(&update).await?;

    // Verify and apply
    ota.apply_update(&firmware)?;

    println!("Updated to version {}", ota.current_version());
}

// Monitor progress
let progress = ota.progress();
println!("State: {:?}, Progress: {}%",
    progress.state, progress.percentage);

5. Device Discovery

Multi-protocol peer discovery:

use aingle_minimal::*;

// Create discovery service
let mut discovery = Discovery::new(
    "my-node-id".to_string(),
    5683
)?;

// Register for mDNS discovery
discovery.register()?;

// Start browsing for peers
discovery.start_browsing()?;

// Wait for peers to be discovered
smol::Timer::after(Duration::from_secs(5)).await;

// Get discovered peers
let peers = discovery.get_peers();
println!("Found {} peers:", peers.len());
for peer in peers {
    println!("  - {} at {:?}", peer.node_id, peer.addresses);
}

// CoAP multicast discovery (if enabled)
#[cfg(feature = "coap")]
{
    let mut coap = CoapServer::new(
        "0.0.0.0".to_string(),
        5683,
        "my-node".to_string()
    );
    coap.start().await?;
    discovery.discover_coap_multicast(&mut coap).await?;
}

Power Profiles Comparison

*Estimated with 3000mAh battery at 3.7V

Supported Sensor Types

• Environmental: Temperature, Humidity, Pressure, Air Quality
• Light: Ambient light, UV index
• Motion: Accelerometer, Gyroscope, Magnetometer, PIR
• Location: GPS coordinates with altitude
• Energy: Voltage, Current, Power consumption
• Proximity: Distance sensors
• Sound: Noise level (dB)
• Custom: Extensible via Sensor trait

Memory Budget

Build Profiles

Development (Debug)

cargo build --features "coap,sqlite,mdns"

Production (Release)

cargo build --release --features "coap,rocksdb,mdns"

Ultra-Minimal (Embedded)

cargo build --release \
  --features "no_std,coap,minimal_crypto" \
  --no-default-features

Feature Flags

Testing

Run all tests:

cargo test --all-features

Run IoT integration tests:

cargo test --test iot_integration_tests --features "coap"

Run benchmarks:

cargo bench --features "coap,sqlite"

Hardware Compatibility

Tested on:

• ESP32 (WiFi, BLE)
• ESP8266 (WiFi only)
• STM32 (with external network)
• Raspberry Pi Zero W (full features)
• Arduino (via esp-rs)

Minimum requirements:

• RAM: 512KB (1MB recommended)
• Flash: 2MB (4MB recommended)
• CPU: 80MHz+ (240MHz recommended)
• Network: WiFi, Ethernet, BLE, or LoRa

Real-World Examples

Temperature Monitoring Station

// Read DHT22 sensor every minute
let mut sensor = sensors::adapters::Dht22Sensor::new();
loop {
    if let Ok(reading) = sensor.read() {
        // Publish to AIngle graph
        println!("Temp: {:.1}°C", reading.value);
    }
    smol::Timer::after(Duration::from_secs(60)).await;
}

Solar-Powered Weather Station

// Ultra low power mode for solar devices
let mut pm = PowerManager::new();
pm.set_power_profile(PowerProfile::UltraLowPower);

// Wake every 5 minutes, take reading, sleep
loop {
    let readings = sensor_manager.read_all();
    // ... publish readings ...

    pm.enter_sleep_mode(
        SleepConfig::deep_sleep(Duration::from_secs(300))
    )?;
}

Smart Home Gateway

// Discover devices on local network
let mut discovery = Discovery::new("gateway".to_string(), 5683)?;
discovery.register()?;
discovery.start_browsing()?;

// Handle device connections
loop {
    let peers = discovery.get_alive_peers(Duration::from_secs(30));
    for peer in peers {
        println!("Device online: {}", peer.node_id);
    }
    smol::Timer::after(Duration::from_secs(5)).await;
}

Performance

Benchmarks on ESP32 (240MHz, 520KB RAM):

*Firmware stored in external flash

Contributing

We welcome contributions! Please see CONTRIBUTING.md for guidelines.

License

Licensed under Apache License 2.0. See LICENSE for details.

Links

• Documentation: https://docs.rs/aingle_minimal
• Repository: https://github.com/ApiliumCode/aingle
• Issues: https://github.com/ApiliumCode/aingle/issues

Roadmap

• CoAP Transport (RFC 7252)
• DTLS Security Layer
• Sensor Abstraction
• Power Management
• OTA Updates
• Device Discovery (mDNS + CoAP multicast)
• BLE Transport
• LoRa Transport
• WiFi Direct Mesh
• Edge ML Inference
• CBOR Encoding (smaller than JSON)
• LwM2M Protocol Support

Built with ❤️ for the IoT community