Rust cho IoT: Xây dựng hệ thống nhúng an toàn và hiệu suất cao

// Nhập các crate cần thiết  

use embedded_hal::digital::v2::OutputPin;  



// Cấu trúc giả lập chân GPIO  

struct MockPin;  



impl OutputPin for MockPin {  

    type Error = ();  

    fn set_high(&mut self) -> Result<(), Self::Error> {  

        println!("LED đã BẬT");  

        Ok(())  

    }  

    fn set_low(&mut self) -> Result<(), Self::Error> {  

        println!("LED đã TẮT");  

        Ok(())  

    }  

}  



fn main() {  

    let mut led = MockPin;  

    // Bật LED  

    led.set_high().unwrap();  

    // Giả lập độ trễ (thay bằng delay thật khi triển khai phần cứng)  

    std::thread::sleep(std::time::Duration::from_secs(1));  

    // Tắt LED  

    led.set_low().unwrap();  

}  

use freertos_rust::{FreeRtos, Task};



fn task1() {

    loop {

        println!("Tác vụ 1 đang chạy");

        FreeRtos::delay_ms(1000); // Tạm dừng 1 giây

    }

}



fn task2() {

    loop {

        println!("Tác vụ 2 đang chạy");

        FreeRtos::delay_ms(1500); // Tạm dừng 1.5 giây

    }

}



fn main() {

    // Tạo các tác vụ

    Task::new()

        .name("Task 1")

        .stack_size(128)

        .start(task1)

        .unwrap();

        

    Task::new()

        .name("Task 2")

        .stack_size(128)

        .start(task2)

        .unwrap();

        

    FreeRtos::start_scheduler(); // Khởi động trình lập lịch RTOS

}

use rustls::{ClientConfig, StreamOwned};

use std::sync::Arc;

use std::net::TcpStream;

use webpki::DNSNameRef;



fn main() {

    // Cấu hình TLS client - nên dùng chung cho nhiều kết nối

    let mut config = ClientConfig::new();

    config.root_store.add_pem_file(&mut include_bytes!("ca-certificates.pem").as_ref())

        .unwrap(); // Xử lý lỗi certificate nên chi tiết hơn trong production

    let config = Arc::new(config);



    // Kết nối TCP tiêu chuẩn

    let stream = TcpStream::connect("iot.example.com:443").unwrap(); // Nên thêm timeout



    // Bọc kết nối bằng lớp TLS 

    let dns_name = DNSNameRef::try_from_ascii_str("iot.example.com").unwrap();

    let tls_stream = StreamOwned::new(rustls::ClientSession::new(&config, dns_name), stream);

    

    println!("Đã thiết lập kết nối bảo mật");

}

// Hàm giả lập quản lý nguồn

fn enter_sleep_mode() {

    println!("Chuyển sang chế độ ngủ...");

    std::thread::sleep(std::time::Duration::from_secs(5)); // Giả lập thời gian ngủ

    println!("Thoát khỏi chế độ ngủ...");

}



fn main() {

    loop {

        println!("Đang thực hiện các thao tác IoT...");

        std::thread::sleep(std::time::Duration::from_secs(1));

        // Kích hoạt chế độ ngủ sau khi hoàn thành

        enter_sleep_mode();

    }

}

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

use tokio::time::{self, Duration};



#[tokio::main]

async fn main() {

    let mut mqtt_options = MqttOptions::new("client_id", "broker.hivemq.com", 1883);

    mqtt_options.set_keep_alive(Duration::from_secs(5));

    

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

    

    // Vòng lặp giả lập dữ liệu cảm biến

    let mut interval = time::interval(Duration::from_secs(5));

    loop {

        interval.tick().await;

        

        // Dữ liệu nhiệt độ giả định

        let temperature = 25.5;

        let payload = format!("{{\"temperature\": {:.2}}}", temperature);

        

        client

            .publish("iot/sensors/temperature", QoS::AtLeastOnce, false, payload)

            .await

            .expect("Không thể gửi tin nhắn");

            

        println!("Đã gửi dữ liệu nhiệt độ!");

    }

}