tasmor_lib 0.6.0

Rust library to control Tasmota devices via MQTT and HTTP
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

// SPDX-License-Identifier: MPL-2.0

//! Test program: Turn on a bulb for 8 seconds, then turn it off.
//!
//! # Usage
//!
//! ```bash
//! cargo run --example bulb_test -- <host> <topic> <username> <password>
//! ```
//!
//! # Example
//!
//! ```bash
//! cargo run --example bulb_test -- 192.168.1.50 tasmota_ABCDEF mqtt_user mqtt_pass
//! ```

use std::env;
use std::time::Duration;
use tasmor_lib::{CapabilitiesBuilder, MqttBroker};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let args: Vec<String> = env::args().collect();

    if args.len() != 5 {
        eprintln!("Usage: {} <host> <topic> <username> <password>", args[0]);
        eprintln!();
        eprintln!("Example:");
        eprintln!("  cargo run --example bulb_test -- 192.168.1.50 tasmota_ABCDEF user pass");
        std::process::exit(1);
    }

    let host = &args[1];
    let topic = &args[2];
    let username = &args[3];
    let password = &args[4];

    println!("Connecting to MQTT broker {host}...");

    let broker = MqttBroker::builder()
        .host(host)
        .credentials(username, password)
        .build()
        .await?;

    let capabilities = CapabilitiesBuilder::new()
        .with_dimmer_control()
        .with_color_temperature_control()
        .build();

    let (device, initial_state) = broker
        .device(topic)
        .with_capabilities(capabilities)
        .build_without_probe()
        .await?;

    println!("Connected!");
    if let Some(power) = initial_state.power(1) {
        println!("Initial power state: {power:?}");
    }
    println!("Turning on the bulb...");
    match device.power_on().await {
        Ok(resp) => println!("Bulb ON: {resp:?}"),
        Err(e) => println!("Power ON sent (response parse error: {e})"),
    }

    println!("Waiting 8 seconds...");
    tokio::time::sleep(Duration::from_secs(8)).await;

    println!("Turning off the bulb...");
    match device.power_off().await {
        Ok(resp) => println!("Bulb OFF: {resp:?}"),
        Err(e) => println!("Power OFF sent (response parse error: {e})"),
    }

    println!("Disconnecting...");
    device.disconnect().await;
    broker.disconnect().await?;

    println!("Done!");
    Ok(())
}